lesson 12 object-oriented databases. 2 object-oriented database n oodbm u db is a collection of...
TRANSCRIPT
Lesson 12
Object-Oriented Databases
2
Object-Oriented Database
OODBM
DB is a collection of objects
each object represents a physical entity and an idea of interest to the DB application
new trend in data modeling and DB processing
Goal of Object-Oriented Data Modeling
maintain direct correspondence between real-world and database objects
use concepts of class or abstract data type to encapsulate structural properties & operations on types of objects
3
Object-Oriented Data Model Objects
encapsulate code & data into a single unit
interact w/ others by message passing
consist of variables that contain data for the objects; the value of each variables by itself is an
object
state of an object: set of values for the attribute called instance variable of the object
contain methods: a method is a body of code, also called behavior of an object
flexible in modifying the definitions (e.g., methods) & variables of objects (e.g., referencing)
4
Object-Oriented Databases
Student Faculty
Spouse
Name
Address
Street
City
State
SSNO
Advises
Teaches
FnameSal_Hist
Year Salary
FID
Has
Sname
Birthdate
Figure. An Entity Relationship Schema Diagram
N
M
1
N1
1
5
Object-Oriented Database
Student Faculty
Spouse
Name
Address
Street
City
State
SSNO
Advises
Teaches
FnameSal_Hist
Year Salary
FID
Has
Sname
Birthdate
N
M
1
N1
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
Object-Oriented Database
Figure. An Instance of the Entity Relationship Schema
SSNO = 721009897Address(Street, City, State) = (90 N 70 E, Provo, Utah)
Name = Susan Tang
SSNO = 123456789Address(Street, City, State) = (123 Perry, Orem, Utah)
Name = Joe Young
Fname = David HaysSal_Hist(Year, Salary) ={ (1991, 23K), (1994, 27K) }FID = 5624
Fname = Chris SmithSal_Hist(Year, Salary) = { (1989, 25K), (1993, 30K) }FID = 2134
Sname = Mary SmithBirthday = July 15, 1955
s1
f2
a1
a2
t1
s2 f1
h1
sp1
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
Student Faculty
Name
Address
Street
City
State
SSNO
Advises
Teaches
FnameSal_Hist
Year Salary
FID
N
M
1
N
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_ageend Figure. The structure of an Object-
Oriented Database Schema OODS
Faculty
Spouse
FnameSal_Hist
Year Salary
FID
Has
Sname
Birthdate
1
1
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
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 < self->birthday->month || (d->month == self->birthday->month && d->day < self->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
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 Departmenttype 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
Object-Oriented Data Model Objects
each object maintains unique identity, represented by object identifier generated by the system and is independent of its attributes values (tuple identity)
Classes primitive class: a class which has associated instances,
but no attributes, e.g., integer, string, and boolean correspond to abstract data types (encapsulate structural
properties of objects and specify valid operations on data of objects)
contain groups of similar objects, instances of a class objects in the same class share a common definition (may
have different values of variables)
13
Object-Oriented Data Model Class Hierarchy:
allows users to derive a new class (subclass) from an existing class (super class)
users may also specify additional attributes and methods for the subclass
Specialization (subclass of a class, e.g., student: undergraduate/graduate), structural inheritance &
behavioral inheritance
a) structural inheritance: subclass inherits instancevariables 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
Object-Oriented Data Modelperson
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
Object-Oriented Data Modelperson
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
Object-Oriented Data Model Single Inheritance: a class inherits attributes and methods
from only one class; a hierarchical structure
Multiple Inheritance: a subclass inherits variables and methods from multiple
superclass, a rooted directed graph structure
ambiguous inheritance problem: if same variable/methodis inherited from more than one superclass
Object Containment: ability to define complex/composite objects from previously
defined objects in a nested/hierarchical manner
non-hierarchical containment: an object is contained in several objects
allow data (objects) to be viewed in different ways (sub-part/ whole)
17
Object-Oriented Data Model
employee
Figure. Containment hierarchy for computer system design database.
board bus device instr-set
chips interfaces
18
OO Database Design by EER-to-OO MappingSTEP 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 <reference, relationship attributes>, 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
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
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: integerendClass 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 ):
booleanend
Figure. O2 class declarations for part of the UNIVERSITY database (continued on next page)
Person
Student Faculty
Grad-Std
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
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
EMPLOYEE: Name, Address, Birthdate, Age, SSN, Salary, HireDate, SenioritySTUDENT: Name, Address, Birthdate, Age, SSN, Major, GPA
EMPLOYEE subtype-of PERSON: Salary, HireDate, SenioritySTUDENT subtype-of PERSON: Major, GPA
PERSON: Name, Address, Birthdate, Age, SSN
GEOMETRY_OBJECT: Shape, Area, ReferencePoint
RECTANGLE subtype-of GEOMETRY_OBJECT: Width, HeightTRIANGLE subtype-of GEOMETRY_OBJECT: Side1, Side2, AngleCIRCLE subtype-of GEOMETRY_OBJECT: Radius
GEOMETRY_OBJECT: Shape, Area, CenterPointRECTANGLE subtype-of GEOMETRY_OBJECT (Shape = ‘rectangle’): Width, HeightTRIANGLE subtype-of GEOMETRY_OBJECT (Shape = ‘triangle’): Side1, Side2, AngleCIRCLE subtype-of GEOMETRY_OBJECT (Shape = ‘circle’): Radius
Object-Oriented Data Model
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)