AIR UNIVERSITY

DEPARTMENT OF ELECTRICAL
AND COMPUTER
ENGINEERING

SUBMITTED TO:
SIR USMAN HAMMEED

SUBMITTED BY:
Muhammad Bilal (210316)
Date:
26/09/2024
 Assignment#01
Evolution of database:
The evolution of databases has been marked by innovations aimed at handling increasing
amounts of data, improving efficiency, and providing more powerful features for storage,
retrieval, and management. Here’s an overview of the key stages in the evolution of
databases:

Flat File Databases (1960s):

 Concept: Flat file databases are the earliest form of data storage, where data is
stored in plain text files or spreadsheets without any complex structure or
relationship. Each line in the file corresponds to a record, and columns are separated
by delimiters like commas.
 Challenges:
o Lack of structure, leading to redundancy.
o No support for relationships between data
o Difficult to query, search, and manage.
o No data consistency or concurrency control

Hierarchical Databases (1960s - 1970s):

 Examples: IBM’s Information Management System (IMS).
 Concept: This model organizes data in a tree-like structure, where each parent node
can have multiple child nodes, but each child node can have only one parent. Data is
stored hierarchically, which is useful for representing one-to-many relationships
(e.g., organizational charts)
 Challenges:
o Data must follow a strict hierarchy.
o Difficult to reorganize or scale
o Limited flexibility in querying.

Network Databases (1960s - 1970s):

 Examples: Integrated Data Store (IDS), Conference on Data Systems Languages
(CODASYL) database
 Concept: The network model, also known as the CODASYL model, allows each record
to have multiple parent and child records, creating a graph-like structure (many-to-
many relationships). This was an advancement over the hierarchical model by
providing more flexibility in representing complex relationships.
 Challenges:
o Complexity in managing and navigating the network of relationships.
o Still required knowledge of physical storage.
Relational Databases (1970s - Present):
 Examples: Oracle, MySQL, Microsoft SQL Server, PostgreSQL.
 Concept: Introduced by Edgar F. Codd in 1970, the relational model organizes data
into tables (relations) consisting of rows (tuples) and columns (attributes). Data in
different tables can be linked using keys (primary and foreign keys). SQL (Structured
Query Language) became the standard for managing relational databases.
 Key Features:
o Data independence and abstraction.
o Easy-to-use query language (SQL).
o Support for ACID (Atomicity, Consistency, Isolation, Durability) properties.
o Indexing, normalization, and efficient storage.
 Challenges:
o Not suited for handling large-scale distributed systems (e.g., massive web
applications).
o Performance limitations with highly complex data structures and
relationships.

Object-Oriented Databases (1980s - 1990s):

 Examples: ObjectDB, db4o.
 Concept: These databases store data in the form of objects, which is the primary
concept in object-oriented programming (OOP). It integrates database capabilities
with object programming languages, allowing objects to be stored directly without
requiring translation into tables.
 Key Features:
o Seamless integration with object-oriented languages (e.g., Java, C++).
o Support for complex data types.
 Challenges:
o Slow adoption compared to relational databases.
o Complexity in integrating with legacy systems.
NoSQL Databases (2000s - Present):
 Examples: MongoDB, Cassandra, Redis, Couchbase
 Concept: "NoSQL" (Not Only SQL) databases arose to meet the needs of modern
web applications requiring flexible, scalable, and high-performance systems. NoSQL
databases do not rely on fixed table schemas and allow for storage of various data
models (e.g., document, key-value, graph, columnar).
 Types of NoSQL Databases:
1. Document Store (e.g., MongoDB): Stores semi-structured data like JSON
or XML.
2. Key-Value Store (e.g., Redis, DynamoDB): Simple key-value pairs for fast
retrieval.
3. Column Store (e.g., Cassandra, HBase): Data stored in columns, allowing
for efficient aggregation.
4. Graph Databases (e.g., Neo4j): Focuses on representing relationships
using graph structures.
 Key Features:
o High scalability (horizontal scaling).
o Flexible schema design.
o Support for big data applications.
o Typically optimized for performance in distributed environments.
 Challenges:
o Lack of standardization.
o Limited support for complex queries.
o ACID compliance is often compromised for performance (though newer
databases are evolving in this aspect).

NewSQL Databases (2010s - Present):

 Examples: Google Spanner, CockroachDB, VoltDB
 Concept: NewSQL databases aim to combine the scalability and performance of
NoSQL systems with the consistency and ACID properties of traditional relational
databases. They support SQL queries but are designed to operate efficiently in
distributed environments.
 Key Features:
o Horizontal scalability.
o Relational model with SQL support.
o ACID compliance.
o Optimized for high-throughput, low-latency workloads.
 Challenges:
o Still an emerging technology.
o Complicated to manage and configure in some cases.
Cloud Databases (2010s - Present):
 Examples: Amazon RDS, Google Cloud Spanner, Azure SQL Database.
 Concept: Cloud databases offer databases as a service (DBaaS), where database
infrastructure is managed by cloud service providers. They can be relational, NoSQL,
or NewSQL databases, but with the added advantage of cloud computing.
 Key Features:
o Automatic scaling and management.
o High availability and disaster recovery.
o Pay-as-you-go pricing model.
o Seamless integration with other cloud services.
 Challenges:
o Vendor lock-in.
o Data security and privacy concerns in shared environments.

Distributed and Decentralized Databases (2010s -

Present):
 Examples: Apache Cassandra, Amazon DynamoDB.
 Concept: These databases distribute data across multiple nodes or locations to
ensure high availability, fault tolerance, and performance. Decentralized databases
go a step further by ensuring no single point of control, often using blockchain or
peer-to-peer networks.
 Key Features:
o Data replication across nodes.
o High availability and fault tolerance.
o Scalability across distributed environments.
 Challenges:
o Complex to manage data consistency and partitioning.
o Increased latency in some use cases.

Conclusion:
The evolution of databases reflects the increasing complexity of data storage needs and the
demand for better performance, scalability, and flexibility. From the rigid and hierarchical
models of the past to today's flexible, scalable, and cloud-based solutions, databases
continue to evolve in response to the needs of modern applications and data-driven
businesses.