Data Models
Data modeling is a foundational process in database design, involving the
creation of a structured representation of real-world data structures for a
specific problem domain. This iterative and progressive process allows
database designers to use established modeling constructs and tools to
minimize errors and create an effective blueprint for the database. Data
models serve as a crucial communication tool, bridging the varying
perspectives of applications programmers, managers, and end users.
Without a sound data model based on an appropriate level of abstraction,
it is nearly impossible to create a database that accurately reflects
business needs and ensures data integrity.
The basic building blocks of data models include entities, attributes,
relationships, and constraints. An entity is a person, place, thing, concept,
or event about which data is collected. Attributes are the characteristics of
these entities. Relationships describe associations among entities and
come in three primary types: one-to-one (1:1), one-to-many (1:M), and
many-to-many (M:N). Constraints are rules placed on data to ensure its
integrity, such as setting valid value ranges for an employee's salary or a
student's GPA.
Central to the modeling process are business rules—brief, precise, and
unambiguous descriptions of policies, procedures, or principles within an
organization. These rules, sourced from managers, policy makers, and
documentation, define the entities, attributes, relationships, and
constraints of the data environment. They standardize the company's
view of data, facilitate communication between users and designers, and
guide the creation of an accurate data model. For example, the rule "a
customer may generate many invoices" helps identify "Customer" and
"Invoice" as entities and establishes a one-to-many relationship between
them. Adopting clear naming conventions for entities and attributes, such
as prefixing an attribute with its entity name (e.g., CUS_CREDIT_LIMIT),
further enhances the model's clarity and self-documentation.
The evolution of data models reflects changing technological capabilities
and conceptual understandings of data organization. Early models
included the hierarchical model, which organized data in a tree-like
structure of parent-child segments, and the network model, which offered
a more flexible representation of complex relationships. Both introduced
enduring concepts like the schema, subschema, and data manipulation
language (DML). The relational model, founded on the mathematical
concept of a relation (implemented as tables with rows and columns),
revolutionized database management through relational database
management systems (RDBMS). It simplified the user's view to a
collection of tables while the RDBMS managed underlying complexities,
supported by the Structured Query Language (SQL) for data interaction.
To address the need for conceptual simplicity in design, the Entity
Relationship (ER) model was developed. It uses graphical Entity
Relationship Diagrams (ERDs) to visually represent entities, attributes,
and relationships, employing notations like Chen, Crow's Foot, or UML. The
object-oriented data model (OODM) later emerged, encapsulating both
data and behavior within objects, organized into classes with inheritance
hierarchies. This model's features influenced the development of the
extended relational data model (ERDM) and object/relational DBMS, which
combine relational simplicity with object-oriented capabilities.
Concurrently, the Extensible Markup Language (XML) became a standard
for exchanging structured and semi-structured data.
Modern challenges of volume, velocity, and variety—the "3 Vs" of Big Data
—have driven the emergence of new models. Technologies like Hadoop
and its distributed file system (HDFS), along with MapReduce for analytics,
address large-scale data processing. NoSQL databases, which are not
based on the relational model, support highly distributed architectures,
scalability, availability, and efficient handling of vast amounts of sparse
data, often prioritizing performance over strict transaction consistency.
Data models can be classified by their level of abstraction, as defined by
the ANSI/SPARC framework. The external model represents the end-user's
view, tailored to specific business units. The conceptual model provides a
global, hardware- and software-independent overview of the entire
database, often using an ER model. The internal model is the DBMS-
specific representation of this conceptual structure, leading to the
physical model, which details how data is stored on hardware. Achieving
logical independence (changing the internal model without affecting the
conceptual model) and physical independence (changing the physical
model without affecting the internal model) are key goals for maintaining
flexibility and reducing the impact of changes in the database system.
In summary, understanding data modeling, its building blocks, the critical
role of business rules, the historical evolution of models from hierarchical
to relational and object-oriented, and the rise of Big Data and NoSQL
systems is essential. Furthermore, categorizing models by their
abstraction level—external, conceptual, internal, and physical—provides a
structured framework for designing, implementing, and managing robust
and adaptable database systems.