Lesson:12

Topic: Intoduction to Object-Database Systems

OBJECT DATABASE SYSTEMS

Introduction:

Object-oriented concepts strongly influenced efforts to enhance database support for

complex data and led to the development of object-database systems.
Object-database systems have developed along two distinct paths:
• Object-Oriented Database Systems: These are proposed to relational systems
and are aimed at application domains where complex objects play a central role.
The Object Database Management Group(ODMG) has developed a standard
Object Data Model(ODM) and Object Query Language(OQL), which are the
equivalent of the SQL standard for relational database systems.
• Object-Relational Database Systems: It extends relational database systems
with the functionality necessary to support a broader class of applications and
provide a bridge between the relational and object-oriented paradigms.

SQL:1999 DDL statements for Dinky Schema

1. create table frames(frameno integer, image jpeg_image, category integer);
2. create table categories(cid integer, name text, lease_price float, comments
text);
3. create type theatre_t as row(tno integer, name text, address text, phone
text) ref is system generated;
4. create table theatres of theatre_t ref is tid system generated;
5. create table nowshowing(film integer,theatre ref(theatre_t) scope theatres,
star date, end date);
6. create table films(filmno integer,title text,stars varchar(25)
array[10]),director text, budget float);
7. create table countries(name text,boundary polygon,population
integer,language text);

User-defined ADTs:

We consider the fictional Dinky Entertainment Company, a large Hollywood

conglomerate whose main assets are a collection of cartoon characters. Dinky has several
Herbert the Worm films, many of which are shown in theatres around the world at any
given time. Dinky also makes a good deal of money licencing Herbert’s image, voice,
and video footage for various purposes. Dinky’s database is used to manage the sales and
leasing records for the various Herbert-related products, as well as the video and audio
data that make up Herbert’s many films.
Dinky’s assets include Herbert’s image, voice, and video footage, and these must be
stored in the database. To handle these new types, we need to be able to represent richer
structure. Further, we need special functions to manipulate these objects. By hiding the
details of the data structure through the functions that capture the behavior, we achieve
data abstraction, leading to cleaner code design.

Structured Data Types:

SQL:1999 allows users to define new data types, in addition to the built-in types. It also
introduced two type constructors that allow us to define new types with internal structure.
Types defined using type constructors are called structured types.
• ROW(N1T1,…,NnTn): A type representing a row, or tuple, of n fields with fields
N1,..,Nn of types T1,…,Tn respectively.
• Base ARRAY[i]: A type representing an array of (up to) I base-type items.
• Example:
ROW(filmno: integer, stars: VARCHAR(25) ARRAY[10])
Collection Types:
• Listof(base): A type representing a sequence of base-type items.
• Setoff(base): A type representing a set of base-type items. Sets cannot contain
duplicate elements.
• Bagof(base): A type representing a bag or multiset of bse-type items.
Operations on structured data:
Operations on rows:
Given an item I whose type is ROW(N1T1,..,NnTn), the field extraction method
allows us to access an individual field Nk using the traditional dot notation I.Nk. This
nested-dot notation is often called a path expression, because it describes a path through
the nested structure.
Operations on Arrays:
Array types support an ‘array index’ method to allow users to access array items at a
particular offset. A postfix ‘square bracket’ syntax is usually used. Since the number of
elements can vary, there is an operator (CARDINALITY) that returns the number of
elements in the array.
SELECT F.filmno, (F.stars || [‘BRANDO’,’PACINO’])
FROM Films F
WHERE CARDINALITY(F.stars) < 3AND F.stars[1]=’REDFORD’
Oprations on other collection types:
Future versions of SQL are expected to support other collection types, One could
additionally allow aggregate operators count, sum, avg, max, and min to be applied to
any object of a collection type with an appropriate base type (e.g., INTEGER). One could
also support operators for type conversions.

Sets and Multisets:

• Set objects can be compared using the traditional set methods.
• Two set objects can be combined to form a new object.
• Each of the methods for sets can be defined for multisets, taking the number of
copies of elements into account.

Lists:
Traditional list operations:
• Head – returns the first element.
• Tail – returns the list obtained by removing the first element.
• Prepend – takes an element and inserts it as the first element in a list.
• Append – appends one list to another.
Queries over nested collections:
SELECT F.filmno
FROM Films F
WHERE CARDINALITY(F.stars) > 2
A nested relation, Films
Filmno Title Stars
50 Casablanca {Bogart,Bergman}
60 Earth Worms Are Juicy {Herbert,Wanda}

SELECT F.filmno,F.title,S AS star

FROM Films F,F.stars AS S
Filmno Title Star
50 Casablanca Bogart
50 Casablanca Bergman
60 Earth Worms Are Juicy Herbert
60 Earth Worms Are Juicy Wanda

SELECT F.filmno,F.title,set_gen(F.star)
FROM Films_flat F
GROUP BY F.filmno, F.title
The set_gen operator collects the set of star values in a partition and creates a set_valued
object. This operation is called nesting.

ENCAPSULATION AND ADTS

• Allowing users to define arbitrary new data types is a key feature of ORDBMSs.
• New atomic data types usually need to have type-specific operations defined by
the user who creates them.
• One can define operations on an image data type such as compress, rotate, shrink,
and crop.
• The combination of an atomic data type and its associated methods is called an
abstract data type, or ADT.
• Hiding ADT internals is called encapsulation.
Defining methods:
• To register a new method for a user-defined data type, users must write the code
for the method and then inform the database system about the method.
• Ex. The ORDBMS may handle Java code in the Linux operating system.
• An SQL-style method registration command is given to the ORDBMS so that it
recognizes the new method:
CREATE FUNCTION is_sunrise(jpeg_image) RETURNS Boolean
 AS EXTERNAL NAME ‘/a/b/c/dinky.class’ LANGUAGE ‘java’;

Atomic type declaration commands for Dinky database

1. CREATE ABSTRACT DATA TYPE jpeg_image
(internallength=variable, input=jpeg_in, output=jpeg_out);
2. CREATE ABSTRACT DATA TYPE polygon
(internallength=variable, input=poly_in, output=poly_out);

INHERITANCE
• Inheritance is supported directly and allows type definitions to be reused and
refined easily.
• In object-database systems, it can be used in two ways: for reusing and refining
types and for creating hierarchies of collections of similar but not identical
objects.
Defining types with Inheritance:
CREATE TYPE theatrecafe_t UNDER theatre_t (menu text);
Supertype – theatre_t
Subtype – theatrecafe_t.
An object of the subtype is also considered to be an object of the supertype.
The substitution principle: Given a supertype A and a subtype B, it is always possible to
substitute an object of type B into a legal expression written for objects of type A,
without producing type errors.
Binding methods:

CREATE FUNCTION display(jpeg_image) RETURNS jpeg_image AS EXTERNAL

NAME ‘/a/b/c/jpeg.class’ LANGUAGE ‘java’;
• Registering a new method with the same name as an old method is called
overloading the method name.
• Because of overloading, the system must understand which method is intended in
a particular expression.
• The process of deciding which method to invoke is called binding the method to
the object.
• Early binding – In certain situations, this binding can be done when an expression
is parsed.
• Late binding – In other cases, the most specific type of an object cannot be known
until run-time, so the method cannot be bound until then.
Collection hierarchies:
The UNDER clause can be used to generate an arbitrary tree of tables, called a
collection hierarchy.
CREATE TABLE theatre_cafes OF TYPE theatrecafe_t UNDER theatres;

OBJECTS,OIDS,AND REFERENCE TYPES

• Data objects can be given an object identifier(oid), which is some value that is
unique in the database across time.
 • An oid has a type similar to the type of a pointer in a programming language.
• Every tuple in a table can be given an oid by defining the table in terms of a
structured type and declaring that a REF type is associated with it.
• REF types have values that are unique identifiers or oids.
• SQL:1999 requires that a given REF type must be associated with a specific table.
Notions of Equality:
The distinction between reference types and reference-free structured types raises
another issue: the definition of equality. Two objects having the same type are defined to
be deep equal if and only if
1. The objects are of atomic type and have the same value.
2. The objects are of reference type and the deep equals operator is true for the two
referenced objects.
3. The objects are of structured type and the deep equals operator is true for all the
corresponding subparts of the two objects.
Two objects that have the same reference type are defined to be shallow equal if both
refer to the same object. The definition of shallow equality can be extended to objects of
arbitrary type by taking the definition of deep equality and replacing deep equals by
shallow equals in parts(2) and (3).

Dereferencing reference types:

Nowshowing.deref(theatre).name.

URLs and OIDs in SQL:1999:

• OIDs uniquely identify a single object over all time, whereas the Web resource
pointed at by an URL can change over time.
• Are simply identifiers and carry no physical information about the objects they
identify-this makes it possible to change the storage location of an object without
modifying pointers to the object.
• URLs include network addresses and often file-system names as well.
• OIDs are automatically generated by the DBMS for each object, whereas URLs
are user-generated.