1. Lesson 12 Object-Oriented Databases

2. 2 Object-Oriented Database n OODBM u DB is a collection of objects u each object represents a physical entity and an idea of interest to the DB application u new trend in data modeling and DB processing n Goal of Object-Oriented Data Modeling u maintain direct correspondence between real-world and database objects u use concepts of class or abstract data type to encapsulate structural properties & operations on types of objects

3. 3 Object-Oriented Data Model n Objects u encapsulate code & data into a single unit u interact w/ others by message passing u consist of variables that contain data for the objects; the value of each variables by itself is an object u state of an object: set of values for the attribute called instance variable of the object u contain methods: a method is a body of code, also called behavior of an object u flexible in modifying the definitions (e.g., methods) & variables of objects (e.g., referencing)

4. 4 Object-Oriented Databases StudentFaculty Spouse Name Address Street City State SSNO Advises Teaches Fname Sal_Hist Year Salary FID Has Sname Birthdate Figure. An Entity Relationship Schema Diagram N M 1 N 1 1

5. 5 Object-Oriented Database StudentFaculty Spouse Name Address Street City State SSNO Advises Teaches Fname Sal_Hist Year Salary FID Has Sname Birthdate N M 1 N 1 1 Student(Name, Address(Street, City, State), SSNO) Faculty(Fname, Sal_Hist(Year, Salary), FID) Advises(SSNO, FID) Teaches(SSNO, FID) Spouse(Sname, Birthdate) Has(FID, Sname) Figure. The Structure of a Nested Relational Database Schema NRDS

6. 6 Object-Oriented Database Figure. An Instance of the Entity Relationship Schema SSNO = 721009897 Address(Street, City, State) = (90 N 70 E, Provo, Utah) Name = Susan Tang SSNO = 123456789 Address(Street, City, State) = (123 Perry, Orem, Utah) Name = Joe Young Fname = David Hays Sal_Hist(Year, Salary) ={ (1991, 23K), (1994, 27K) } FID = 5624 Fname = Chris Smith Sal_Hist(Year, Salary) = { (1989, 25K), (1993, 30K) } FID = 2134 Sname = Mary Smith Birthday = July 15, 1955 s1s1 f2f2 a1a1 a2a2 t1t1 s2s2 f1f1 h1h1 sp 1

7. 7 Object-Oriented Databases Type Date: tuple (Month: integer, Day: integer, Year: integer); Class Student type tuple (SSNO: string, /* key */ Name: string, Address: tuple (Street: string, City: string, State: string), Advisor: Faculty, Teachers: set (Faculty)) end Figure. The structure of an Object- Oriented Database Schema OODS StudentFaculty Name Address Street City State SSNO Advises Teaches Fname Sal_Hist Year Salary FID N M 1 N

8. 8 Object-Oriented Databases Class Faculty type tuple ( FID: string, /* key */ Fname: string, Sal_Hist: set ( tuple( Year: integer, Salary: real) ), Advisees: set (Student), Teaches: set (Student), Spouse_of: Spouse) method Add_advisee (Std: Student), Average_salary, Raise_curr_salary (Percent: real) End Class Spouse type tuple ( Sname: string, /* key */ Birthdate: Date, Spouse_of: Faculty) method Compute_age end Figure. The structure of an Object- Oriented Database Schema OODS Faculty Spouse Fname Sal_Hist Year Salary FID Has Sname Birthdate 1 1

9. 9 name Susan_Tang: Student; /* a persistent root to hold a single Student object */ name Joe_Young: Student; /* a persistent root to hold a single Student object */ name David_Hays: Faculty; /* a persistent root to hold a single Faculty object */ name Chris_Smith: Faculty; /* a persistent root to hold a single Faculty object */ name Mary_Smith: Spouse; /* a persistent root to hold a single Spouse object */ Susan_Tang->SSNO = “721009897”, Susan_Tang->Name = “Susan Tang”, Susan_Tang->Address = tuple(Street: “90 N 70 E”, City: “Provo”, State: “Utah”), Susan_Tang->Advisor = David_Hays; Joe_Young->SSNO = “123456789”, Joe_Young->Name = “Joe Young”, Joe_Young->Address = tuple(Street: “123 Perry”, City: “Orem”, State: “Utah”), Joe_Young->Advisor = Chris_Smith, Joe_Young->Teachers = set(Chris_Smith); David_Hays->FID = “5624”, David_Hays->Fname = “David Hays”, David_Hays->Sal_Hist = set ( tuple (Year: 1991, Salary: 23K), tuple (Year: 1994, Salary: 27K)), David_Hays->Advisees = set (Susan_Tang); Chris_Smith->FID = “2134”, Chris_Smith->Fname = “Chris Smith”, Chris_Smith->Sal_Hist = set ( tuple (Year: 1989, Salary: 25K), tuple (Year: 1993, Salary: 30K)), Chris_Smith->Advisees = set (Joe_Young), Chris_Smith->Teaches = set (Joe_Young), Chris_Smith->Spouse_of = Mary_Smith; Mary_Smith->Sname = “Mary Smith”, Mary_Smith->Birthdate = tuple (Month: 7, Day: 15, Year: 1995), Mary_Smith->Spouse_of = Chris_Smith; Figure. An Instance of OODS

10. 10 method body Add_advisee(std: Student) in class Faculty { self->Advisees += set(std); /* += is the set union operation used to add std to a set of advisees */ } method body Average_salary: float in class Faculty { float sum = 0; int cnt = 0; for (fac in self->Sal_Hist) { sum += fac->salary; /* add up salary */ cnt++; } return(sum/cnt); } method body Compute_age: integer in class Spouse /* Calculate a spouse’s age, */ { /* using spouse’s birthday and today’s date */ int i = 0; Date d = today(); /* self: object for which the method is invoked */ if (d->month birthday->month || (d->month == self->birthday->month && d->day birthday->day)) - - i; return(d->year - self->birthday->year + i); } method body Raise_curr_salary(percent: float): float in class Faculty { Date d = today(); for (fac in self->Sal_Hist) /* self: object for which the method is invoked */ if (d->year == fac->year) { fac->salary = fac->salary * (1 + percent); break; } } Figure. Definitions of Methods in OODS using O2C

11. 11 Define class Employee: type tuple( name: string, ssn: string, birthdate: Date, sex: char, dept: Department ); operations age(e: Employee): integer, create_new_emp: Employee, destroy_emp(e: Employee): boolean; define class Department type tuple( dname: string, dnumber: integer, mgr: tuple (manager: Employee, startdate: Date), locations: set(string), employees: set(Employee), projects: set(Project) ) operations number_of_emps(d: Department): integer, create_new_dept: Department, destroy_dept (d: Department): boolean, add_emp (d: Department, e: Employee): boolean, (* adds a new employee *) remove_emp (d: Department, e: Employee): boolean, (* removes an employee *); Figure. Using OODDL to define Employee and Department classes.

12. 12 Object-Oriented Data Model n Objects u each object maintains unique identity, represented by object identifier generated by the system and is independent of its attributes values (tuple identity) n Classes u primitive class: a class which has associated instances, but no attributes, e.g., integer, string, and boolean u correspond to abstract data types (encapsulate structural properties of objects and specify valid operations on data of objects) u contain groups of similar objects, instances of a class u objects in the same class share a common definition (may have different values of variables)

13. 13 Object-Oriented Data Model n Class Hierarchy: u allows users to derive a new class (subclass) from an existing class (super class) u users may also specify additional attributes and methods for the subclass u Specialization (subclass of a class, e.g., student: undergraduate/graduate), structural inheritance & behavioral inheritance a) structural inheritance: subclass inherits instance variables of its superclass (e.g., graduate student has name) but not vice versa b) behavioral inheritance: subclass inherits all methods applied to its superclass (e.g., GPA can be computed) but not vice versa

14. 14 Object-Oriented Data Model person employee officer teller secretary customer Figure. Class hierarchy for the banking example. person employee officer teller secretary customer Figure. Class hierarchy for full- and part-time employees. full-time teller part-time teller full-time secretary part-time secretary

15. 15 Object-Oriented Data Model person employee customer Figure. Class DAG for the banking example. full-time part-time teller secretary officer full-time teller part-time teller full-time secretary part-time secretary

16. 16 Object-Oriented Data Model n Single Inheritance: a class inherits attributes and methods from only one class; a hierarchical structure n Multiple Inheritance: u a subclass inherits variables and methods from multiple superclass, a rooted directed graph structure u ambiguous inheritance problem: if same variable/method is inherited from more than one superclass n Object Containment: u ability to define complex/composite objects from previously defined objects in a nested/hierarchical manner u non-hierarchical containment: an object is contained in several objects u allow data (objects) to be viewed in different ways (sub-part/ whole)

17. 17 Object-Oriented Data Model employee Figure. Containment hierarchy for computer system design database. board bus device instr-set chips interfaces

18. 18 OO Database Design by EER-to-OO Mapping STEP 1: Create an oo class for each EER class. The type of the OO class should include all the attributes of the EER class by using a tuple constructor at the top level of the type. Multivalued attributes are declared by using the set, bag, or list constructors. If the values of the multivalued attribute for an object should be ordered, the list constructor is chosen; if duplicates are allowed, the bag constructor should be chosen. Composite attributes are mapped into a tuple constructor. STEP 2: Add reference attributes for each binary relationship into the oo classes that participate in the relationship. The attributes may be created in one direction or in both directions. The attributes are single-valued for relationships in the 1:1 or N:1 direction; they are set-valued or list-valued for relationships in the 1:N or M:N direction. If a binary relationship is represented by references in both directions, declare the references to be inverses of one another, if such a facility exists. If relationship attributes exist, a tuple constructor can be used to create a structure of the form, which is included instead of the reference attribute. STEP 3: Include appropriate methods for each class. These are not available from the EER schema and must be added to the database design as needed. A constructor method should include code that checks any constraints that must hold when a new object is created. A destructor method should check any constraints that may be violated when an object is deleted. Other methods should include any further constraint checks that are relevant.

19. 19 OO Database Design by EER-to-OO Mapping STEP 4: An OO class that corresponds to a subclass in the EER schema inherits the type and methods of its superclass(es) in the OO schema. Its specific attributes and references are specified as discussed in steps 1 and 2. STEP 5: Weak entity types that do not participate in any relationships except their identifying relationship can be mapped as though they were composite multivalued attributes of the owner entity type, by using the set(tuple(…)) constructor. STEP 6: n-ary relationships with n > 2 can be mapped into a separate object type, with appropriate references to each participating object type. These references are based on mapping a 1:N relationship from each participating entity type to the n-ary relationship. M:N binary relationships may also use this option, if desired.

20. 20 Type Phone: tuple ( area_code: integer, number: integer); Type Date: tuple ( year: integer, month: integer, day: integer); Class Person type tuple ( ssn: string, name: tuple ( firstname: string, middlename: string, lastname: string), address: tuple (street: string, apt_no: string, city: string, state: string, zipcode: string ), birthdate: Date, sex: character ) method age: integer end Class Student inherit Person type tuple ( class: string, majors_in: Department, minors_in: Department, registered_in: set (Section), transcript: set ( tuple ( grade: character, section: Section ))) method grade_point_average: real, change_class: boolean, change_major ( new_major: Department ): boolean end Figure. O2 class declarations for part of the UNIVERSITY database (continued on next page) Person Student Faculty Grad-Std

21. 21 Class Grad_Student inherit Student type tuple ( degrees: set ( tuple ( college: string, degree: string, year: integer )), advisor: Faculty ) end Class Faculty_Student inherit Student type tuple ( salary: real, rank: string, foffice: string, fphone: Phone, grants: set ( string ), advise: set ( Student ), belongs_to: set ( Department ), chair: Department teach: set( Section )) method promotte_faculty (rank: string), give_raise ( percent: real ) end class Department type tuple ( dname: string, office: string, dphone: Phone, members: set ( Faculty ), major: set ( Student ), minor: set ( Student ), chairperson: Faculty, courses: set ( Course ) ) method add_major ( s: Student ), remove_major ( s: Student ) end Class Section type tuple ( sec_num: integer, qtr: Quarter, year: Year, transcript: set(tuple( stud: Student, grade: character)), register: set( Student ), course: Course, teacher: Instructor ) method change_grade ( s: Student, g: string) end class Course type tuple ( cname: string, cnumber: string, cdescription: string, sections: set ( Section ), offering_dept: Department ) method update_description (new d: string ) end Figure. (continued)

22. 22 Q1: select tuple (fname: s.name.firstname, lname: s.name.lastname) from s in Student where s.majors_in.dname = “Computer Science” Q2: select tuple (fname: s.name.firstname, lname: s.name.lastname) transcript: select tuple ( sec_no: sc.section.sec_num, quarter: sc.section.qtr, year: sc.section.year, grade: sc.grade) from sc in sec) from s in Student, sec in s.transcript where s.majors_in.dname = “Computer Science” Figure. Two queries in O2SQL. Object-Oriented Data Model

23. 23 EMPLOYEE: Name, Address, Birthdate, Age, SSN, Salary, HireDate, Seniority STUDENT: Name, Address, Birthdate, Age, SSN, Major, GPA EMPLOYEE subtype-of PERSON: Salary, HireDate, Seniority STUDENT subtype-of PERSON: Major, GPA PERSON: Name, Address, Birthdate, Age, SSN GEOMETRY_OBJECT: Shape, Area, ReferencePoint RECTANGLE subtype-of GEOMETRY_OBJECT: Width, Height TRIANGLE subtype-of GEOMETRY_OBJECT: Side1, Side2, Angle CIRCLE subtype-of GEOMETRY_OBJECT: Radius GEOMETRY_OBJECT: Shape, Area, CenterPoint RECTANGLE subtype-of GEOMETRY_OBJECT (Shape = ‘rectangle’): Width, Height TRIANGLE subtype-of GEOMETRY_OBJECT (Shape = ‘triangle’): Side1, Side2, Angle CIRCLE subtype-of GEOMETRY_OBJECT (Shape = ‘circle’): Radius Object-Oriented Data Model

24. 24 Name All_Person: set (Person) /*a persistent root to hold all persistent Person objects*/ name John_Smith: Person; /*a persistent root to hold a single Person objects*/ run body { o2 Person p = new Person; /*creates a new Person object p*/ *p = tuple (ssn: “333445555”, name: tuple (firstname, “Franklin”, middlename: “T”, lastname: “Wong”), address: tuple (number: 638, street: “Voss Road”, city: “Houston”, state: “Texas”, zipcode: “77079”), birthdate: tuple (year: 1945, month: 12, day: 8), sex: M); All_Person += set (p); /*p becomes persistent by attaching to persistent root*/ /*new values in persistent named object John Smith*/ John_Smith->ssn = “123456789”, John_Smith->name: tuple(firstname: “John”, middlename: “B”, lastname: “Smith”), John_Smith->address: tuple(number: 731, street: “Fondren Road”, city: “Houston”, state: “Texas”, zipcode: “77036”), John_Smith->birthdate: tuple(year: 1955, month: 1, day: 9), John_Smith->sex: M; } Figure. (continued)