Lesson 9

This module introduced you to the structure of a relational database and some of the terminology used to describe it.
You learned that the structure of a relational database is based on the relational model.
You also learned that the largest structure in a relational database is a table, which contains fields, records, and a primary key. You discovered that using the primary-key field to link tables allows data to be accessed in a relational database.
Finally, you learned that Structured Query Language (SQL) is the programming language used to create relational databases, and that a relational database management system (RDBMS) is a software package used to manage relational databases.

• Learning Objectives Now that you have completed the lessons in this module, you should be able to:
  1. Describe the relational database model
  2. Describe the structure of a relational database
  3. Explain how relational database tables are linked to access data
  4. Explain why SQL is the lingua franca of relational databases
  5. Describe the functions of a relational database management system
• Formal Structure: Each database model provides a unique formal structure for its database type. As you might expect, there are advantages and disadvantages to each formal structure. The structure of a relational database was briefly discussed in this module. It is beyond our scope to compare and contrast the relational model with the other three. Both the hierarchical and network models are used in many legacy database systems. However, you will rarely find new databases created from these two older models. The object-oriented model, on the other hand, is relatively new. It caught on in the mid-90s and continues to gain in popularity. In fact, some relational databases such as Oracle incorporate elements from the object-oriented model. Suffice to say that the advantages of the relational model outweigh its disadvantages; of the four 1)relational, 2)Object-oriented, 3)hierarchical, 4)network, it is the model of choice for most businesses.

Object-oriented database models (OODBMS) are designed to handle data as objects, which makes them highly suitable for certain use cases where traditional relational databases may struggle. Here are some key use cases for implementing object-oriented database models:

1. Complex Data and Relationships
   • Use Case: In applications that manage complex data structures or data with intricate relationships (like CAD/CAM systems, multimedia databases, or simulations), an OODBMS is more natural than a relational model.
   • Example: Computer-aided design (CAD) systems, which store geometric objects and models, benefit from object-oriented databases because they can represent objects (e.g., points, lines, curves) directly and manage their relationships effectively.
2. Object-Oriented Programming (OOP) Integration
   • Use Case: When the application is written using an object-oriented programming language (like Java, C++, or Python), an OODBMS allows seamless integration between the database and the application, avoiding the complexity of mapping objects to relational tables (ORM).
   • Example: In enterprise applications where business logic is modeled as objects, OODBMS allows developers to persist objects directly without transforming them into a relational format, simplifying the development process.
3. Real-Time Systems
   • Use Case: Real-time applications often require fast access to complex data structures, and object-oriented databases provide direct retrieval and manipulation of objects, which can optimize performance.
   • Example: Real-time financial systems that process live transactions, where performance is critical and the data models involve complex entities like accounts, portfolios, and transactions.
4. Hierarchical Data Representation
   • Use Case: Applications that naturally model data hierarchically or as parent-child relationships (such as organizational structures, taxonomies, or file systems) benefit from an object-oriented model.
   • Example: Content management systems (CMS) that need to store and manage nested elements like sections, articles, and media in a structured manner can leverage OODBMS to represent these hierarchies natively.
5. Versioning and Complex Object Management
   • Use Case: In domains where data versioning, object inheritance, and complex data structures are essential, OODBMS offers native support for object hierarchies, versions, and polymorphism.
   • Example: Scientific databases or product lifecycle management (PLM) systems, which handle different versions of objects and need to track changes, benefit from the versioning capabilities of OODBMS.
6. Persistence of Complex Objects
   • Use Case: Applications that handle large and complex objects (e.g., documents, multimedia files, or graphics) require database systems that can efficiently store and retrieve these complex structures.
   • Example: Video games or virtual reality environments that manage 3D objects and real-time simulations, where objects have multiple attributes like position, state, and appearance.
7. Artificial Intelligence and Machine Learning
   • Use Case: In AI and machine learning applications, where the data consists of complex objects (e.g., neural networks, trees, or graphs), OODBMS can represent these complex structures directly, making it easier to query and manipulate them.
   • Example: An AI model management system that stores models, training datasets, and results as complex objects, allowing for efficient updates and queries.
8. Multimedia and Graphical Data
   • Use Case: Applications that need to store and retrieve multimedia data, such as audio, video, images, or graphical models, can benefit from object-oriented databases because they handle complex, unstructured data better than relational models.
   • Example: Digital libraries or video editing systems where the data is not easily normalized into tables but fits naturally as complex objects.
9. Engineering and Simulation Systems
   • Use Case: Object-oriented databases are well-suited for engineering applications, where components and systems are represented as objects with multiple attributes and behaviors.
   • Example: A simulation system for aerospace engineering, which needs to store detailed models of parts, materials, and configurations as objects, allowing for detailed tracking and manipulation during simulations.
10. E-Commerce and Product Catalogs
    • Use Case: In e-commerce applications, where products have many attributes and relationships (e.g., variations, categories, reviews), an object-oriented database can efficiently handle the complex data structure.
    • Example: An e-commerce platform managing a product catalog where products can inherit properties from parent categories and have many-to-many relationships with tags, reviews, and recommendations.
11. Big Data and Internet of Things (IoT)
    • Use Case: IoT systems that collect vast amounts of structured and unstructured data from various sensors and devices may find it easier to manage the data as objects, rather than breaking it down into relational rows and columns.
    • Example: A smart city application that integrates data from traffic sensors, weather stations, and public transportation systems, each represented as objects with complex relationships and behaviors.

Benefits of Object-Oriented Databases:

• Natural Mapping to OOP Languages: It eliminates the need for object-relational mapping (ORM), reducing complexity and improving developer productivity.
• Encapsulation and Inheritance: Object-oriented databases natively support inheritance and polymorphism, which can simplify complex data models.
• Handling Complex Data Types: They are ideal for applications dealing with complex data types (e.g., images, video, graphs) and relationships between data.
• Performance for Certain Use Cases: Direct storage and retrieval of objects can lead to performance benefits in use cases involving large, nested, or interconnected data structures.

These factors make OODBMS ideal for domains where object manipulation, inheritance, and complex data relationships are central to the business logic.

This module introduced you to the following terms:

1. data: The "raw facts" stored in a database.
2. data definition language (DDL): A collection of programming statements that describe and define data and data relationships in a database.
3. data integrity: A term used to describe the quality (in terms of accuracy, consistency, and validity) of data in a database, in the sense that values required to enforce data relationships actually exist. Problems with data integrity occur when a value in one table that’s supposed to relate to a value in another can’t, because the second value either has been deleted or was never entered.
4. data manipulation language (DML): A collection of programming statements used to manipulate a database.
5. database model: A formal structure for organizing and linking data in a database.
6. field: The smallest structure in a table; contains data describing the subject of a table.
7. foreign key: A field (or combination of fields) used to link tables; a corresponding primary key field occurs in the same database.
8. hierarchical model: A database model that organizes data in a top-down (inverted tree) structure.
9. information: A collection of "raw facts" (data) organized in such a way that they have value beyond the value of the facts themselves.
10. network model: An extension of the hierarchical model. (See hierarchical model.)
11. oject-oriented model: When database capabilities are combined with object programming language capabilities, the result is an object database management system (ODBMS).
12. primary key: A field (or combination of fields) that uniquely identifies a record in a table.
13. query: (v) To extract data from a database; (n.) a set of SQL statements for extracting particular data from a database.
14. record: A particular instance of the subject of a table.
15. relational database: A relational database is a database that conforms to the relational model, and refers to the data and schema of the database.
16. Relational Database Management System (RDBMS): A software package that manages and provides access to a database. These packages follow Codd’s 12 rules of relational databases and normally use SQL to access data.
17. relational model: A formal structure that organizes data into relations (i.e., tables).
18. table: A collection of data arranged in rows and columns. A table is the largest structure in a relational database.
19. user views: Saved queries created with SQL. User views specify which users are permitted access to what data in a database.

In the next module, database design strategy and design tools will be discussed.

Before moving on to the next module, click the Quiz link below to check your knowledge of relational database structure and terminology.
Relational Database - Quiz