File Processing Systems
File Processing Systems
In early processing systems, an organization's information was stored as groups of records in separate
files. These file processing systems consisted of a few data files and many application programs. Each
file, called a flat file, contained and processed information for one specific function, such as accounting or
inventory. Programmers used programming languages such as COBOL to write applications that directly
accessed flat files to perform data management services and provide information for users.
In creating the files and applications, developers focused on business processes, or how business was
transacted, and their interactions. However, business processes are dynamic, requiring continuous
changes in files and applications. In addition, early programmers focused on physical implementation and
access procedures when designing a database. These physical procedures were written into database
applications; therefore, physical changes resulted in intensive rework on the part of the programmer. As
systems became more complex, file processing systems offered little flexibility, presented many
limitations, and were difficult to maintain.
Data redundancy
Often, the same information was stored in more than one file. In addition to taking up more file space
on the system, this replication of data caused loss of data integrity. For instance, if a customer's
address was stored in four different files, an address change would have to be updated in each file
separately. If a user was not consistent in updating all files, no one would know which information
was correct.
Data inflexibility.
Program-data interdependency and data isolation limited the flexibility of file processing systems in
providing users with ad hoc information requests. Because designing applications was so
programming-intensive, information requests usually were restricted by MIS department staff.
Therefore, users often resorted to manual methods to obtain needed information.
A DBMS is best described as a collection of programs that manages the database structure and
that control shared access to the data in the database. Current DBMSes also store the
relationships between the database components; they also take care of defining the required
access paths to those components. The functions of a current- generation DBMS may be
summarized as follows:
1. stores the definitions of data and their relationships (metadata) in a data dictionary; any
changes made are automatically recorded in the data dictionary.
2. Creates the complex structures required for data storage.
3. Transforms entered data to conform to the data structures in item 2.
4. Creates a security system and enforces security within that system.
5. Creates complex structures that allow multiple user access to the data.
6. performs backup and data recovery procedures to ensure data safety.
7. Promotes and enforces integrity rules to eliminate data integrity problems.
8. Provides access to the data via utility programs and from programming languages
interfaces.
9. Provides end-user access to data within a computer network environment.
Data independence exists when data access programs are not subject to change when any of the
file's data characteristics change. Data independence is important because it substantially
decreases programming effort and program maintenance costs.
Mapping
The three levels of abstraction in the database do not exist independently of each other. There
must be some correspondence, or mapping, between the levels. There are actually two mappings:
the Conceptual/Internal mapping and the External/Conceptual mapping.
The Conceptual/Internal mapping lies between the conceptual and internal levels, and defines
the correspondence between the records and the fields of the conceptual view and the files and
data structure of the internal view. If the structure of the stored database is changed, then the
Conceptual/Internal mapping must also be changed accordingly so that the view from the
conceptual level remains constant. It is this mapping that provides physical data independence
for the database.
The External/Conceptual view lies between the external and conceptual levels, and defines the
correspondence between a particular external view and the conceptual view. Although these two
levels are similar, some elements found in a particular external view may be different from the
conceptual view.
For example, several fields can be combined into a single (virtual) field, which can also have
different names from the original fields. If the structure of the database at the conceptual level is
changed, then the external/conceptual mapping must change according so the view from the
external level remains constant. It is this mapping that provides logical data independence for the
database.