Database Comparisons: An Overview
Comparison
Flat File
Hierarchical
Network
Relational
Object-Oriented
Hybrid
Timeframe
Late 1950’searly 1960’s
Mid 1960’searly 1970’s
Late 1960’smid 1970’s
Early 1970’spresent
Late 1980’spresent
Late 1960’searly 1970’s
(Nested)
Database
Evolution
Acronym
1st Generation
2nd Generation
2nd Generation
3rd Generation
4th Generation
DBF
DBMS
DBMS
RDBMS
Description
File orientation &
navigation; file
structures &
proprietary program
interfaces
Hierarchical
orientation &
navigation;
hierarchies of
related records &
standard interfaces
Network orientation
& navigation; uses
hierarchicallyarranged data with
the exception that
child tables can
have more than
one parent;
standard interfaces
Relational
orientation; data
retrieved by unique
keys; relationships
expressed through
matching keys;
physical
organization of data
managed by
RDBMS
OODBS, ODBMS
or OODBMS
Object orientation;
active, distributed
processing & more
powerful operators;
uses objectoriented
programming to
combine data
structures with
functions to create
re-usable objects
Network of
interrelated lists;
looks like several
trees that share
branches; children
have multiple
parents and
parents have
multiple children
Data is stored in
relations (tables);
relationships
maintained by
placing a key field
value of one record
as an attribute in
the related record
Physical
Structure
2/17/2016
Flat file; onedimensional;
frequently in tabular
format; oftentimes
multiple copies of
the same data were
maintained, each
copy sorted in a
different way
Tree; parent-child
relationships; single
table acts as the
“root” of the
database from
which other tables
“branch” out; child
can only have one
parent, but a parent
can have multiple
children
Modeling &
creation of data as
objects; store
objects and
operations to be
performed on data;
applications
interact with object
managers which
work through object
servers to gain
access to object
stores
Late 1990’spresent
(Object-Relational)
4th Generation
O-R, ORDB or
ORDBMS
Nested:
database/operating
system with tool for
data retrieval built
in
Object-Relational:
relational
databases that
have evolved to
add object-oriented
features
Organize
information
common to
relational tabular
structures;
subsume the
relational database
model
1
Database Comparisons: An Overview
Diagram
Programming
Languages Used
See pp. 8
Assembler, Fortran,
COBOL;
spreadsheets use
non-algorithmic
programming
language
See pp. 9
Commands
embedded in
programming
languages;
COBOL, PL1,
Fortran, ADS &
Assembler
See pp. 10
Commands
embedded in
programming
languages;
COBOL, PL1,
Fortran, ADS &
Assembler
See pp. 11
SQL, ODBC
Structural
Changes
If new fields were
added to the file,
every program that
accessed that file
had to be changed
& data files would
have to be
converted
Inflexible (once
data is organized in
a particular way,
difficult to change);
data reorganization
complicated;
requires careful
design
Inflexible (once
data is organized in
a particular way,
difficult to change);
data reorganization
complicated;
requires careful
design
Relationships
No structured
interrelationship
between its data
records
Linked lists using
pointers stored in
the parent/child
records to navigate
through the
records; pointers
could be a disk
address, the key
field, or other
random access
Uses series of
linked lists to
implement
relationships
between records;
each list has an
owner record &
possibly many
member records; a
single record can
Flexible; because
tables are subjectspecific & key fields
relate one entity to
another, both the
data & the
database structure
can be easily
modified &
manipulated;
programs
independent of
data format which
yields flexibility
when modifications
are needed
Uses key fields to
link data in many
different ways;
supports one-toone, one-to-many &
many-to-many
relationships
2/17/2016
Java, C++,
Smalltalk, Ada,
Object Pascal,
Objective
DRAGOON, BETA,
Emerald, POOL,
Eiffel, Seif, Oblog,
ESP. Loops, Visual
Basic, POLKA &
Python
Flexible; programs
are built using
chunks or modules
consisting of
preassembled code
& data which
makes
programming
easier & faster;
changes are made
in the underlying
code rather than in
the design or
structure of the
database
Relational:
SQL3, ODBC,
JDBC
Defines software
pieces, object
types,
actions/methods &
the interrelationships between
these objects;
allows objects to be
re-used for different
purposes
Primarily a
relational structure
with object-oriented
features included
Object-Oriented:
Java, C++,
Smalltalk, etc.
Cartridges,
DataBlades, &
Extenders are
modules that build
on the
object/relational
infrastructure; they
consist of types,
data structures,
functions, & data &
often include
special developer
interfaces or
prebuilt
applications
2
Database Comparisons: An Overview
technique; start at
root and work down
the tree to reach
target data;
supports one-toone & one-to-many
relationships
Advantages
2/17/2016
First method for
converting raw data
into usable
information
Easily shows oneto-one & one-tomany relationships;
More efficient than
the flat file model
b/c less need for
redundant data
either be the owner
or a member of
several lists of
various types;
supports one-toone, one-to-many,
& many-to-many
relationships
Network model
solves problem of
data redundancy by
representing
relationships in
terms of sets rather
than hierarchy;
allowed complex
data structures to
be built; very
efficient in storage
& fast; better job
with many-to-many
relationships
More easily
visualize data
organization &
relationships; ease
of design & userfriendly GUI
interfaces; modern
query tools & report
generators; ease of
data entry; tables
represent a single
subject; no
duplicate data
which reduces
errors & improves
consistency &
eases database
maintenance;
relationships
increase data
integrity; more
information from
same data due to
file integration; new
& one-time
requests easily
accommodated;
customized, menudriven interfaces
can be easily
Using OOP (objectoriented
programming),
ability to model,
store & manipulate
complex data (i.e.
multimedia);
support for special
operations common
to niche markets
not well supported
by more
mainstream
database engines
(i.e. CAD/CAM &
document
management);
supports data
structures for
arrays which are
useful for waveform
data such as EKGs
and EEGs;
persistence,
secondary storage
management;
concurrency;
recovery & ad hoc
query facilities;
when using OOP,
Supports SQL;
based on relational
model so familiar to
the user, yet
provides some
object-oriented
features & benefits
3
Database Comparisons: An Overview
developed;
concurrent access
to the data;
increased
productivity;
application code
generators;
referential integrity
controls;
transactional
integrity ensures
that incomplete
transactions do not
occur; optimization
of storage &
database operation
execution times;
database users
don’t corrupt each
other’s work;
scalable (can
spread load across
multiple CPUs or
servers); best for
data collection &
querying; allows
built-in validation;
define & store
schema (DB
structure), load
initial data, provide
a variety of access
methods, add,
modify & delete
data, provide
multiple views of
the data, provide
security features,
2/17/2016
no need to
translate into a
database sublanguage (i.e. SQL,
ODBC or JDBC)
which means 1)
writing less code
(as much as 40%
less) & 2)
performance is
faster b/c already in
the correct format &
doesn’t have to be
translated (but this
depends on
complexity of data);
best used for
information
analysis focusing
on capability to
navigate through &
analyze large
volumes of data
(i.e. production
planning, network
planning, financial
engineering);
applications are
very dynamic and
schemas very
complex; supports
diverse data types;
rather than force
fitting all
information into a
handful of
predefined data
types (as in
4
Database Comparisons: An Overview
facilitate backup
and recovery
Disadvantages
2/17/2016
Flat file
environment
created
program/data
dependence
meaning that
changes in the
format of the data
also required
changes in all the
programs that
accessed the data;
for any new
analyses of the
data in the form of
a written report,
No support for
many-to-many
relationships; user
must know how the
tree is structured to
find anything;
cannot add a
record to a child
table until it has
been incorporated
into the parent
table; still creates
data duplication
More difficult to
navigate and
visualize compared
to the hierarchical
model; model
difficult to
implement and
maintain; most
implementations
were used by
programmers
rather than endusers; had to have
an understanding
of how the
database was
Initially, had slow
performance in 70’s
& 80’s, but today’s
more powerful
machines speed up
performance; wide
price range, can be
expensive;
additional hardware
might be required
(i.e. faster CPU,
more memory and
disk space); high
impact of failure
due to
centralization and
RDBMS), object
databases allow
developers to
define & use data
types that directly
reflect the real
solution; ODBMS
figures out how to
physically configure
& store information;
today, objects &
object containers
go through a
translation known
as mapping to work
directly with SQLbased relational
databases; some
modern object
databases also
support SQL;
provides integration
Due to time and
cost involved, many
hesitate to convert
existing DBMS to
OODBMS; lack of
familiarity; most
programmers
understand
RDBMS better than
ODBMS; inertia
(easier to use what
you know);
technology &
business fear (most
ODBMS vendors
are small
O-R databases
force fits objects
into a limited
physical typing
model required by
their relational core
design; O-R
databases offer full
SQL compliance,
but limited object
capabilities
5
Database Comparisons: An Overview
new programs had
to be written or
existing programs
had to be modified
which seriously
affected
productivity for
programmers &
end-users;
record descriptions
& access methods
for each file must
be coded in every
program that
accessed the file;
heavy conversion &
enhancement
workload; flat files
need to store
excessive amounts
of redundant data;
more than one
subject; duplicate
data; validation is
manual
Examples
MS Excel; VisiCalc; Lotus 1-2-3;
VP-Planner;
Quattro;
Symphony;
MultiPlan
IMS (Information
Management
System) by IBM
Status Today
Limited usage (i.e.
Limited usage (i.e.
2/17/2016
structured in order
to retrieve, insert,
update or delete
records; required a
lot of programming
to use successfully
non-duplication of
data; sophisticated
design and
programming
required for some
products; additional
user training may
be needed due to
added system
capabilities; backup
and recovery are
more difficult due to
concurrency and
complexity; security
is more critical and
complicated due to
shared usage of
central database
Satellite
communications,
airline reservations;
IDMS (Integrated
Database
Management
System) from
Cullinet
Limited usage (i.e.
Oracle, Informix,
Ingres, Sybase,
DB2, MS Access,
FileMaker Pro,
Visual FoxPro, SQL
Server, MySQL
(free), PostgreSQL
(free)
Most popular
companies (is the
risk worth the
technological
benefits?); not
enough object
developers;
performance can
suffer when
developers use
haphazard object
design; reliability &
availability suffered
in the past due to
lack of investment
in management
tools; past objectoriented databases
did not support
SQL which was the
standard query
language of the
day; requires tightly
coupled language
interface & ability to
handle the creation
& evolution of
schema without a
lot of programmer
intervention
ObjectStore,
Versant, O2,
Gemstone,
ONTOS, POET,
Objectivity/DB,
Jasmine, Matisse
Gaining popularity;
Oracle8, IBM’s
UDB, Sybase
Appears that all
6
Database Comparisons: An Overview
spreadsheets,
address books,
bulk email used by
spammers)
2/17/2016
Windows file
structure)
still used in satellite
communications &
airline reservation
systems)
DBMS in use today
as a result of
technical
development efforts
to ensure that
advances such as
object orientation,
web serving, etc.
appear quickly &
reliably
growing at a rate of
30-40% each year;
will see mostly in
new development
relational systems
of the future will be
object-relational or
RDBMS will coexist side-by-side
ODBMS
7