A well-designed database schema forms the foundation of a
high-performing and efficient IBM Db2 database… and therefore, also serves as the basic starting point for efficient Db2 applications. The importance of optimizing
the database design cannot be overstated, as it directly impacts query
performance, data integrity, and overall system efficiency.

The Logical Data Model

The first step toward a proper database design is the creation of a logical data model. Before implementing databases
of any sort, it is imperative to first develop a sound model of the data to be used.
Novice database developers frequently begin with the quick-and-dirty approach
to database implementation. They approach database design from a programming
perspective. Because novices often lack experience with databases and data
requirements gathering, they attempt to design databases like the flat files
they are accustomed to using. This is a major mistake. Indeed, most developers
using this approach quickly discover problems after the databases and
applications become operational in a production environment. At a minimum,
performance will suffer and data may not be as readily available as required.
At worst, data integrity problems and/or performance problems
 may arise, rendering the entire application

The goal of a data model is to record the data requirements of a business process. The scope of the data model for each line of business must be comprehensive. A data model serves as lexicon for the data needs of the business… and as a blueprint for the physical implementation of the structures of the database.

A key component of building a proper data model is to ensure proper normalization. 


Normalization reduces data redundancy and inconsistencies by ensuring that the data elements are designed appropriately. A series of normalization rules are applied to the entities and data elements, each of which is called a “normal form.” If the data conforms to the first rule, the data model is said to be in “first normal form,” and so on.

A database design in First Normal Form (1NF) will have no repeating groups and each instance of an entity can be identified by a primary key. For Second Normal Form (2NF), instances of an entity must not depend on anything other than the primary key for that entity. Third Normal Form (3NF) removes data elements that do not depend on the primary key. If the contents of a group of data elements can apply to more than a single entity instance, those data elements belong in a separate entity.

This is a quick and dirty introduction to normalization, and there are further levels of normalization not discussed here in order to keep the discussion moving along. For an introductory discussion of normalization visit http://wdvl.com/Authoring/DB/Normalization.

The bottom line is that normalization reduces data
redundancy and improves data integrity by organizing data into logical entities
and minimizing data duplication. By carefully analyzing the business
requirements and applying normalization principles, database designers can
create tables that are lean, efficient, and accurately represent the data


Optimizing relationships between tables is another critical
aspect of database design. Relationships, such as primary key-foreign key
associations, define the logical connections between tables. This too, should be evident in the logical data model, which is frequently depicted as an entity/relationship diagram. 

appropriate indexing strategies, enforcing referential integrity, and carefully
considering the cardinality and selectivity of relationships are crucial steps
to ensure efficient query processing and join operations.

From Logical to Physical

Assuming you have a well-designed logical data model, the first step in moving to a physical database design is the process of transforming that logical data model into an actual physical database. The first step is to create an initial physical data model by transforming the logical data model into a physical implementation based on an understanding of the DBMS being used for deployment. To successfully create a physical database design you will need to have a good working knowledge of the features of the DBMS including:

  • In-depth knowledge of the database objects supported by the DBMS and the physical structures and files required to support those objects.

  • Details regarding the manner in which the DBMS supports indexing, referential integrity, constraints, data types, and other features that augment the functionality of database objects.

  • Detailed knowledge of new and obsolete features for particular versions or releases of the DBMS to be used.

  • Knowledge of the DBMS configuration parameters that are in place.

  • Data definition language (DDL) skills to translate the physical design into actual database objects.

Armed with the correct information, you can create an effective and efficient database from a logical data model. The first step in transforming a logical data model into a physical model is to perform a simple translation from logical terms to physical objects. Of course, this simple transformation will not result in a complete and correct physical database design – it is simply the first step. The transformation consists of the following:

  • Transforming entities into tables

  • Transforming attributes into columns

  • Transforming domains into data types and constraints

Data Types

To support the mapping of attributes to table columns you will need to map each logical domain of the attribute to a physical data type and perhaps additional constraints. In a physical database, each column must be assigned a data type. 

Selecting appropriate data types is vital for optimizing database design. Choosing the right data types can have a significant impact on storage requirements, query performance, and overall system efficiency. By selecting data types that accurately represent the data and minimize storage overhead, such as using integer types instead of character types for numeric values, assuring that date and time data use appropriate data/time data types, and choosing wisely between the various text and character data types for each column helps to improve data integrity, optimize storage utilization, and improve query execution speed.


Furthermore, you will need to implement appropriate constraints,
such as primary keys, unique constraints, and foreign keys. This enhances data
integrity and query performance. Furthermore, additional constraints such as check constraints and nullability enable the DBMS to better enforce data integrity, instead of leaving it to application code written at a later time. Constraints enforce data consistency rules,
ensure referential integrity, and provide the optimizer with valuable
information for query optimization.

An Iterative Process

It is worth mentioning that database design optimization is
an iterative process that should consider not only the current requirements but
also the future growth and scalability of the system. Regularly reviewing and
revisiting the database design as the application evolves can help identify
areas for improvement and ensure that the database remains optimized over time.


In conclusion, a well-designed database schema is
fundamental to achieving optimal performance for your database applications. By focusing on
strategies such as normalization, relationship optimization, appropriate data
types, and constraints, database designers can create a robust and efficient
database environment. Optimizing the database design not only enhances query
performance and data integrity but also lays the groundwork for scalability and
adaptability as the system evolves.