Concepts for Object-Oriented Databases – Advanced Database Systems

Meta Description: Learn the fundamental concepts of Object-Oriented Databases including object identity, object structure, type constructors, encapsulation, and inheritance in this comprehensive lesson for Advanced Database Systems students.

1. Overview of Object-Oriented Concepts

1.1 What is an Object?

An object is a way of thinking about and representing real-world things in programming. It matches how humans naturally see and understand the world around them.

Detailed Explanation:

Think about a car in the real world. A car has:

• Properties: color, brand, model, speed
• Actions: accelerate, brake, turn

In object-oriented programming, we create a “Car” object that has both these properties and actions together in one package. This is similar to how we think about cars in real life – we don’t separate the car’s properties from what it can do.

Real World Object: CAR
+----------------------------------+
|  Properties (Data)               |
|  - Color: Red                    |
|  - Brand: Toyota                 |
|  - Speed: 120 km/h               |
+----------------------------------+
|  Actions (Methods)               |
|  - Accelerate()                  |
|  - Brake()                       |
|  - Turn()                        |
+----------------------------------+

Example:

A “Student” object would have:

• Properties: name, ID, age, grade
• Actions: study(), takeExam(), getGrade()

1.2 What are Object-Oriented Databases (OODBS)?

Detailed Explanation:

Traditional databases (relational databases) store data in tables with rows and columns. However, they have limitations when dealing with complex data like images, videos, or engineering designs.

Object-Oriented Database Systems (OODBS) solve these problems by:

1. Storing data with methods: The data and the code to manipulate it are stored together
2. Handling complex data: Can store complex structures like designs, images, and documents
3. Supporting multiple data types: Can store text, images, audio, video, and structured data in the same database
4. Tracking object evolution: Can follow how objects change over time

Traditional Database          Object-Oriented Database
+-------------------+         +-------------------+
| Data only         |         | Data + Methods    |
| Simple tables     |         | Complex objects   |
| Fixed structure   |         | Flexible structure|
+-------------------+         +-------------------+

Example:

In a Computer-Aided Design (CAD) application:

• A traditional database would struggle to store complex 3D models
• An OODBS can store the 3D model as an object with all its properties and the methods to manipulate it

1.3 Applications of Object-Oriented Databases

Detailed Explanation:

Object-Oriented Databases have evolved from specialized applications to broader use:

Early Applications:

Modern Applications:

Example:

In healthcare, an OODBS can store:

• Patient information (text)
• X-ray images (images)
• Medical history documents (documents)
• Treatment methods (code/procedures)

1.4 Basic Data Representation Terminology

Detailed Explanation:

Before diving deeper into object-oriented concepts, let’s understand the basic terminology:

         RELATION (Table)
+-----------------------------------+
|  Attribute  |  Attribute  |  Attr |
|   (Name)    |   (Age)     | (City)|
+-------------+-------------+-------+
|    Abebe    |     25      | Addis |  <-- Tuple (Row)
+-------------+-------------+-------+
|    Tigist   |     22      | Gondar|  <-- Tuple (Row)
+-------------+-------------+-------+

Definitions:

• Attribute: A named column that represents a property. Example: "Student_Name" is an attribute that stores names of students.
• Relation: A table that contains related data. Example: A "Students" table containing student information.
• Tuple: A row in a table representing one complete record. Example: (Abebe, 25, Addis) is one tuple.

Example:

For a "Courses" relation:

• Attributes: Course_ID, Course_Name, Credit_Hours
• Tuple: (CS101, "Database Systems", 3)

2. Object Identity, Object Structure and Type Constructors

2.1 Understanding Object Identity

Detailed Explanation:

In object-oriented databases, every object gets a unique identifier that distinguishes it from all other objects, even if they have identical data.

What is OID (Object Identifier)?

OID is a unique, system-generated identifier assigned to each object when it is created. Unlike primary keys in relational databases:

• OID is automatically generated by the system
• Users cannot see or modify the OID
• OID is used internally to reference objects
• OID never changes throughout the object's lifetime

Object Identity Comparison:

Relational Database:
+-------------------+
| Student Table     |
| ID (Primary Key)  |  <-- User can see and may change
| Name              |
| Age               |
+-------------------+

Object-Oriented Database:
+-------------------+
| Student Object    |
| OID: #7A3F2B      |  <-- System-generated, invisible to user
| Name: Abebe       |
| Age: 21           |
+-------------------+

Why is Object Identity Important?

1. Uniqueness: Two objects with identical data are still different objects
2. Reference: Objects can refer to each other using OIDs
3. Persistence: Objects maintain identity even when their data changes

Example:

Consider two Employee objects:

• Employee A: Name = "Abebe", Age = 30, OID = #X100
• Employee B: Name = "Abebe", Age = 30, OID = #X101

Even though they have the same data, they are different objects because they have different OIDs.

2.2 Properties of Object Identifier (OID)

Detailed Explanation:

OID has two critical properties that ensure data integrity:

Property 1: Immutability

The OID of an object, once assigned, never changes. This means:

• Even if the object's data changes completely, its OID stays the same
• References to the object remain valid throughout its lifetime

Property 2: Single Use

Each OID is used only once in the entire history of the database:

• When an object is deleted, its OID is retired forever
• A new object will get a completely new OID
• This prevents confusion from old references pointing to new objects

OID Lifecycle:

Create Object A  -->  OID: #001 assigned
                      |
                      v
Modify Object A  -->  OID: #001 (unchanged)
                      |
                      v
Delete Object A  -->  OID: #001 retired (never reused)
                      |
                      v
Create Object B  -->  OID: #002 assigned (new OID)

Example:

If a student object with OID #1001 is deleted, no future student will ever get OID #1001, even if there are millions of new students added later.

2.3 Forms of Object Identity

Detailed Explanation:

Object identity can be represented in three different ways:

1. Value-Based Identity

• Uses data values to identify objects
• Common in relational databases
• Example: Student_ID = "STU001" identifies a student
• Problem: If the value changes, identity changes

2. Name-Based Identity

• Uses user-supplied names
• Common in programming variables
• Example: Variable name "studentRecord"
• Problem: Limited scope and user-dependent

3. Built-in Identity

• Identity is built into the data model
• Used in object-oriented systems
• No user-supplied identifier needed
• Most robust form of identity

Forms of Identity Comparison:

+------------------+-------------------+-------------------+
|     Form         |     Example       |     System        |
+------------------+-------------------+-------------------+
| Value-based      | Primary Key       | Relational DB     |
| Name-based       | Variable name     | Programming       |
| Built-in         | OID               | Object-Oriented   |
+------------------+-------------------+-------------------+

Example:

In a university database:

• Value-based: Student with ID "U001" - identity depends on ID value
• Name-based: "currentStudent" variable - identity is the name
• Built-in: Internal OID #7F2A - identity is system-generated

2.4 Object Structure

Detailed Explanation:

In object-oriented databases, every object has a structure that can be described formally. An object is represented as a triple with three components:

The Object Triple: (i, c, v)

Understanding Each Component:

1. Object Identifier (i): The unique system-generated ID
2. Type Constructor (c): Indicates how the object's state is built (atom, tuple, set, etc.)
3. Object State (v): The actual data stored in the object

Object Structure Example:

Student Object = (i, c, v)

i = #OID12345 (unique identifier)
c = tuple (type constructor)
v = {
      name: "Abebe",
      age: 21,
      courses: { "CS101", "CS102", "CS103" }
    }

Visual representation:
+----------------------------------+
| OID: #OID12345                   |
| Type: Tuple                      |
+----------------------------------+
| State:                           |
|   name: "Abebe"                  |
|   age: 21                        |
|   courses: {"CS101","CS102",...} |
+----------------------------------+

Example:

A "Department" object might be:

• i = #DEPT001
• c = tuple
• v = {name: "Computer Science", location: "Building A", students: {set of student objects}}

2.5 Type Constructors

Detailed Explanation:

Type constructors are the building blocks used to create complex object structures. Think of them as templates or patterns for organizing data.

The Three Basic Type Constructors:

A. Atom Constructor

The atom constructor represents basic, indivisible values:

• Integers: 1, 42, -7
• Real numbers: 3.14, 2.718
• Character strings: "Hello", "Database"
• Booleans: true, false

Atom Constructor Examples:

Integer Atom:    42
                 |
                 +-- Single, indivisible value

String Atom:     "Hello World"
                 |
                 +-- Single text value

Boolean Atom:    TRUE
                 |
                 +-- Single logical value

B. Tuple Constructor

The tuple constructor groups multiple related values:

• Similar to a record or struct
• Each component has a name and a value
• Can contain atoms or other complex objects

Tuple Constructor Example:

Student Tuple:
+------------------------+
| name: "Aster"          |  <-- Atom (string)
| age: 22                |  <-- Atom (integer)
| gpa: 3.85              |  <-- Atom (real)
+------------------------+

Formal: tuple{name: atom, age: atom, gpa: atom}

C. Set Constructor

The set constructor represents a collection of unordered, unique elements:

• Elements have no specific order
• No duplicates allowed
• Can contain atoms or complex objects

Set Constructor Example:

Course_Set: { "CS101", "CS102", "CS103" }

Properties:
- Unordered: {CS101, CS102} = {CS102, CS101}
- Unique: Cannot have duplicate values

Formal: set{atom, atom, atom}

Other Type Constructors:

Example of Nested Constructors:

Complex Object with Nested Constructors:

University Object:
+------------------------------------------+
| name: "Addis Ababa University"           | (atom)
| departments: {                           | (set)
|     tuple{name: "CS", students: list{...}},|
|     tuple{name: "Math", students: list{...}}|
|   }                                      |
| established: 1950                        | (atom)
+------------------------------------------+

Structure: tuple{
    name: atom,
    departments: set(tuple),
    established: atom
}

3. Encapsulation of Operations, Methods and Persistence

3.1 Understanding Encapsulation

Detailed Explanation:

Encapsulation is a fundamental concept in object-oriented systems that protects data and organizes code. It is like a protective capsule around an object's data.

What is Encapsulation?

Encapsulation means bundling data (variables) and methods (functions) together inside an object, while hiding the internal details from the outside world.

Key Ideas of Encapsulation:

1. Data Hiding: The internal structure of the object is hidden from external access
2. Controlled Access: Objects can only be accessed through predefined operations (methods)
3. Interface-Based: External users only see the interface, not the implementation

Encapsulation Visualization:

+----------------------------------+
|         OBJECT                   |
|  +--------------------------+    |
|  |   Hidden Data (Private)  |    |
|  |   - Internal variables   |    |
|  |   - Implementation code  |    |
|  +--------------------------+    |
|                                  |
|  +--------------------------+    |
|  |   Public Interface       |    |
|  |   - Operation 1          |<---|--- External Access
|  |   - Operation 2          |    |
|  |   - Operation 3          |    |
|  +--------------------------+    |
+----------------------------------+

Example:

Consider a "Bank Account" object:

• Hidden Data: balance, accountNumber, transactionHistory
• Public Operations: deposit(), withdraw(), getBalance()

Users cannot directly change the balance; they must use deposit() or withdraw() methods.

3.2 Operations on Objects

Detailed Explanation:

Operations define what actions can be performed on an object. They form the bridge between external users and internal data.

Types of Operations:

Object Operations Flow:

         Create Object
              |
              v
    +------------------+
    |    OBJECT        |<---- Retrieve data
    |                  |<---- Update state
    +------------------+<---- Query information
              |
              v
        Destroy Object

Example:

For a "Book" object in a library database:

• createBook(title, author, ISBN): Creates a new book record
• deleteBook(): Removes the book from database
• borrowBook(memberID): Updates status to "borrowed"
• returnBook(): Updates status to "available"
• getInfo(): Returns book details

3.3 Signature and Methods

Detailed Explanation:

Understanding the difference between signature and method is important for understanding encapsulation:

Signature:

• The public interface of an operation
• Defines the operation name
• Defines the parameters (arguments) the operation accepts
• Defines the return type
• External users only see the signature

Method:

• The actual implementation code
• Contains the logic that performs the operation
• Hidden from external users
• Invoked when a message is sent to the object

Signature vs Method:

+------------------------------------------+
|              OPERATION                    |
|                                          |
|  Signature (Public Interface):            |
|  +------------------------------------+  |
|  | deposit(amount: money) : boolean   |  |
|  +------------------------------------+  |
|                                          |
|  Method (Hidden Implementation):         |
|  +------------------------------------+  |
|  | if amount > 0 then                 |  |
|  |   balance = balance + amount       |  |
|  |   return true                      |  |
|  | else                               |  |
|  |   return false                     |  |
|  +------------------------------------+  |
+------------------------------------------+

Example:

For a "Student" object:

Message Passing:

To execute a method, you send a message to the object:

• Message includes: operation name and arguments
• Object receives the message and executes the corresponding method

3.4 Visible and Hidden Attributes

Detailed Explanation:

In pure object-oriented programming, all data is completely encapsulated. However, for database applications, this is often too restrictive. Therefore, OODB systems divide object attributes into two categories:

Visible Attributes:

• Can be directly accessed for reading
• Accessible by external operators
• Can be queried using high-level query languages
• Similar to public fields in some programming languages

Hidden Attributes:

• Completely encapsulated
• Can only be accessed through predefined operations
• Protected from direct external access
• Provides security for sensitive data

Object with Visible and Hidden Attributes:

+------------------------------------------+
|          EMPLOYEE OBJECT                  |
|                                          |
|  Visible Attributes:                      |
|  +------------------------------------+  |
|  | name: "Aster"         (Read OK)    |  |
|  | department: "Finance"  (Read OK)   |  |
|  | position: "Manager"    (Read OK)   |  |
|  +------------------------------------+  |
|                                          |
|  Hidden Attributes:                       |
|  +------------------------------------+  |
|  | salary: 50000         (Read via    |  |
|  | bonus: 10000            methods    |  |
|  | password: "***"         only)      |  |
|  +------------------------------------+  |
+------------------------------------------+

Access Rules:
- name --> Direct read allowed
- salary --> Must use getSalary() method
- password --> Must use verifyPassword() method

Example:

In a "Patient" object for a hospital database:

• Visible: name, age, bloodType (doctors need quick access)
• Hidden: medicalHistory, insuranceDetails (sensitive information)

4. Type and Class Hierarchies and Inheritance

4.1 Understanding Inheritance

Detailed Explanation:

Inheritance is one of the most powerful concepts in object-oriented programming and databases. It allows you to create new classes based on existing ones, inheriting their properties and methods.

Key Concepts of Inheritance:

1. Code Reusability: Write code once, use it in multiple places
2. Hierarchical Organization: Organize classes in a logical hierarchy
3. Shared Behavior: Parent classes share their features with children
4. Extension: Child classes can add new features

Basic Inheritance Structure:

        +----------------+
        |    Animal      |
        |  - head        |
        |  - body        |
        |  + feed()      |
        +----------------+
              /   \
             /     \
    +--------+     +--------+
    | Mammal |     |  Fish  |
    | + legs |     | + fins |
    | + sit()|     | +swim()|
    +--------+     +--------+

Mammal inherits: head, body, feed() from Animal
Mammal adds: legs, sit()

Fish inherits: head, body, feed() from Animal
Fish adds: fins, swim()

Example:

Consider a university database:

• Person class: name, address, dateOfBirth, getAge()
• Student class (inherits Person): studentID, courses, calculateGPA()
• Employee class (inherits Person): employeeID, salary, calculateTax()

Student and Employee both inherit name, address, and getAge() from Person, but add their own unique attributes and methods.

4.2 Superclass and Subclass

Detailed Explanation:

Understanding the relationship between superclass and subclass is fundamental to inheritance:

Superclass:

• Also called parent class or base class
• Contains common/general properties and methods
• Located at the top or middle of the hierarchy

Subclass:

• Also called child class or derived class
• Contains specialized properties and methods
• Automatically inherits all properties from superclass
• Can add new properties not in superclass
• Can override (redefine) inherited methods

Superclass and Subclass Relationship:

        +================+
        |   VEHICLE      |  <-- SUPERCLASS
        |   (General)    |
        +================+
        | - licenseNo    |
        | - color        |
        | + start()      |
        | + stop()       |
        +================+
              /   \
             /     \
   +---------+     +-----------+
   |   CAR   |     |   BIKE    |  <-- SUBCLASSES
   |(Special)|     | (Special) |
   +---------+     +-----------+
   | + doors |     | + pedals  |
   | +drive()|     | + pedal() |
   +---------+     +-----------+

Both Car and Bike inherit:
- licenseNo, color, start(), stop()

Car adds: doors, drive()
Bike adds: pedals, pedal()

Important Rule:

If class B is a subclass of class A:

• Every instance of B is automatically an instance of A
• The reverse is NOT true - an instance of A is NOT necessarily an instance of B

Example:

• Every Car is a Vehicle (TRUE)
• Every Vehicle is a Car (FALSE - could be a Bike, Truck, etc.)

4.3 Type (Class) Hierarchy

Detailed Explanation:

Class hierarchy organizes classes in a tree-like structure based on their relationships. There are two approaches to creating this hierarchy:

1. Specialization (Top-Down Approach)

Specialization is the process of creating subclasses from a superclass:

• Start with a general superclass
• Identify specific characteristics that distinguish groups
• Create subclasses for each distinct group

Specialization Process:

Step 1: Start with Superclass
        +------------+
        |   PERSON   |
        +------------+

Step 2: Identify Distinct Groups
        - Some are students
        - Some are employees

Step 3: Create Subclasses
        +------------+
        |   PERSON   |
        +------------+
           /      \
    +--------+  +----------+
    |STUDENT |  | EMPLOYEE |
    +--------+  +----------+

Direction: Top → Down (Superclass to Subclasses)

Example:

Starting with "Account" class:

• Identify: Some accounts are Savings, some are Checking
• Create: SavingsAccount and CheckingAccount as subclasses

2. Generalization (Bottom-Up Approach)

Generalization is the reverse process - creating a superclass from existing classes:

• Start with multiple similar classes
• Identify common properties
• Create a superclass with the common properties

Generalization Process:

Step 1: Start with Separate Classes
        +--------+     +----------+
        |  CAR   |     |   BIKE   |
        +--------+     +----------+
        Both have: licenseNo, color, start()

Step 2: Identify Common Properties
        Common features extracted

Step 3: Create Superclass
        +------------+
        |  VEHICLE   |
        +------------+
        | licenseNo  |
        | color      |
        | start()    |
        +------------+
           /      \
    +--------+  +----------+
    |  CAR   |  |   BIKE   |
    +--------+  +----------+

Direction: Bottom → Up (Subclasses to Superclass)

Example:

Starting with "Lion", "Tiger", "Elephant" classes:

• Identify: All have name, age, habitat, eat(), sleep()
• Create: "Animal" superclass with common properties

4.4 Practical Inheritance Examples

Detailed Explanation:

Let's look at a comprehensive example of inheritance:

Example: University System

University Class Hierarchy:

                    +---------------+
                    |    PERSON     |
                    +---------------+
                    | - name        |
                    | - address     |
                    | - dateOfBirth |
                    +---------------+
                    | + getAge()    |
                    | + getName()   |
                    +---------------+
                          /    \
           +--------------+    +---------------+
           |   STUDENT    |    |   EMPLOYEE    |
           +--------------+    +---------------+
           | - studentID  |    | - employeeID  |
           | - major      |    | - department  |
           +--------------+    | - salary      |
           | + getGPA()   |    +---------------+
           +--------------+    | + calcTax()   |
                  |            +---------------+
                  |                   |
         +--------+--------+   +------+------+
         | GRADUATE STUDENT|   |   FACULTY   |
         +-----------------+   +-------------+
         | - thesisTopic   |   | - rank      |
         +-----------------+   | - specialty |
         | + defendThesis()|   +-------------+
         +-----------------+   | + promote() |
                               +-------------+

Inheritance Chain:
Faculty → Employee → Person
GraduateStudent → Student → Person

What Each Class Inherits:

Exam Tips

Practice Challenge Questions for Exam Preparation

                    +----------------+
                    |  LibraryItem   |
                    +----------------+
                    | - itemID       |
                    | - title        |
                    | - acqDate      |
                    +----------------+
                     /      |      \
             +------+     +----+   +------+
             | Book |     |Jour|   |EBook |
             +------+     +----+   +------+
             |author|     |pub |   |format|
             |ISBN  |     |issue|  |link  |
             +------+     +----+   +------+

This completes Chapter One: Concepts for Object-Oriented Databases. Make sure to review all sections and practice the questions before your exam. Good luck!