DATABASE DESIGN LIFE CYCLE, DATABASE

DESIGN, R MODEL OVERVIEW

PRESENTED BY:
Name Surname Reg Number Code
Kunashe Mwachengedza R231541E HCS
Tinotenda Dhliwayo R231563Z HCS
Tanatswa Chanaka R231553B HCS
Ropafadzo Gandari R231535Y HCS
Rumbidzai Masara R231540A HCS
DATABASE DESIGN LIFE CYCLE
• The database design life cycle refers to the series of steps involved in designing, implementing, and maintaining a database system. It encompasses all
the stages from the initial planning and analysis to the ongoing maintenance and optimization of the database. Here's an overview of the typical stages in
the database design life cycle:
• Requirement Analysis: This initial phase involves gathering and analyzing the requirements for the database system. It includes identifying stakeholders,
understanding their needs, defining the scope of the project, and documenting functional and non-functional requirements. This involves defining the
problems,how they can be fixed.
• Conceptual Design: In this phase, a high-level conceptual model of the database is created. The focus is on identifying the main entities, their attributes,
and the relationships between them. Techniques like Entity-Relationship Diagrams (ERDs) are often used to visualize the conceptual model.
• Logical Design: Once the conceptual model is established, it's translated into a logical schema that can be implemented in the chosen database
management system (DBMS). This involves defining tables, columns, data types, constraints, and relationships in a way that reflects the requirements of
the system. The logical schema describes how data will be stored and how attributes in those tables are connected.
• Normalization: Normalization is the process of organizing the data in a database to reduce redundancy and dependency. This phase typically occurs
during the logical design stage, and it involves applying normal forms like First Normal Form (1NF), Second Normal Form (2NF), Third Normal Form
(3NF), and so on.
• Physical Design: In this phase, decisions are made about how the logical database schema will be implemented on the underlying storage system. This
includes considerations such as indexing, partitioning, clustering, and denormalization to optimize performance and storage efficiency.
Implementation: With the database design finalized, the next step is to actually implement the database schema
in the chosen DBMS. This involves writing Data Definition Language (DDL) statements to create the tables,
indexes, constraints, and other database objects.
Testing and Optimization: Once the database is implemented, it needs to be tested to ensure that it meets the
requirements and performs efficiently. Testing involves both functional testing (ensuring that the database
functions as expected) and performance testing (measuring and optimizing query performance).
Deployment: After successful testing, the database is deployed into production environment where it serves the
intended users and applications. This involves setting up necessary security measures, data backups, and
monitoring mechanisms to ensure smooth operation.
Maintenance and Evolution: Database design is not a one-time activity; it's an ongoing process. As the
requirements of the system evolve over time, the database may need to be modified or extended. This requires
careful planning and coordination to ensure that the database remains consistent and efficient.
Throughout the database design life cycle, collaboration between stakeholders, database designers, developers,
and administrators is crucial to ensure that the database meets the needs of the organization and supports its
objectives effectively. Additionally, documentation at each stage is essential for understanding the design
rationale and facilitating future modifications and enhancements.
DATABASE DESIGN
Database design
- is the process of producing a detailed data model of a database. This model incorporates how data will be organized,
structured and stored within the database system,

A well designed database ensures data integrity, efficiency and scalability

Steps of Designing Database

Define the objective of your database

The first step is to determine the purpose of your database. For example, if you are running a small home-based
business, you can design a customer database that maintains a list of consumer info to generate emails and
reports. It will help you concentrate on your objectives when making important decisions.

Locate and consolidate the necessary data

The next step is to collect all kinds of information you might want to store in the database. Begin with the
existing data and think over the questions you want your database to answer. It will help you decide which data
needs to be recorded.

Distribute the data into tables

Once you have amassed all the necessary data items, the next step is to divide them into main entities or subject
areas. For example, if you are a retailer, some of your main entities could be products, customers, suppliers, and
orders. Each entity will then become a separate table.
• Database design is the process of producing a detailed data model of a database. This model incorporates how data will be organized, structured, and
stored within the database system. A well-designed database ensures data integrity, efficiency, and scalability. Here's an overview of the key steps
involved in the process of designing a database:
• Requirements Gathering: The first step in database design is to understand the requirements of the system. This involves gathering information about the
data that needs to be stored, the relationships between different entities, and the operations that will be performed on the data.
• Conceptual Design: In this phase, a high-level conceptual model of the database is created. This model typically involves identifying the main entities (or
tables) and the relationships between them. Techniques like Entity-Relationship Diagrams (ERDs) are often used to visualize the conceptual model.
• Normalization: Normalization is the process of organizing the data in a database to reduce redundancy and dependency. This helps to ensure data integrity
and minimize the chances of anomalies during data manipulation. Normal forms like First Normal Form (1NF), Second Normal Form (2NF), Third
Normal Form (3NF), and so on, are applied to achieve this.
• Logical Design: Once the conceptual design is complete, it's translated into a logical schema that can be implemented in the chosen database management
system (DBMS). This involves defining the tables, columns, data types, constraints, and relationships in a way that reflects the requirements of the
system.
• Physical Design: In the physical design phase, decisions are made about how the logical database schema will be implemented on the underlying storage
system. This includes considerations such as indexing, partitioning, clustering, and denormalization to optimize performance and storage efficiency.
• Implementation: With the database design finalized, the next step is to actually implement the database schema in the chosen DBMS. This involves
writing Data Definition Language (DDL) statements to create the tables, indexes, constraints, and other database objects.
• Testing and Optimization: Once the database is implemented, it needs to be tested to ensure that it meets the requirements and performs efficiently.
Testing involves both functional testing (ensuring that the database functions as expected) and performance testing (measuring and optimizing query
performance).
• Maintenance and Evolution: Database design is not a one-time activity; it's an ongoing process. As the requirements of the system evolve over time, the
database may need to be modified or extended. This requires careful planning and coordination to ensure that the database remains consistent and
efficient.
• Overall, effective database design is crucial for building reliable, scalable, and maintainable database systems that support the data management needs of
an organization.
Change data items into columns
Data is put into tables, such that every data item becomes a field and is shown as a column. For
instance, a customer table might include fields like name, address, email address, and city.
After determining the initial set of columns for every table, you can refine them. , you can
record customer names in two separate columns: first and last names. Likewise, you can store
the address in five distinct columns based on address, town, state, zip code, and region. It will
make it more convenient for you to filter information.
Identify primary keys
The next step to improve your database design is to select a primary key for every table. It will
allow you to identify unique rows based on the customer ID.
More than one primary key can also exist, called a composite key, including multiple columns.
For example, the primary keys in your Order Details table could be order ID and product ID.
The composite key can be made using fields with similar or varying data types.
Enhance your database design
By refining your database design while creating and populating your tables with mockup information. Experiment
with the sample data by running queries or adding new items. It will help you analyze your design for errors.
Implement the normalization rules
The last step is to implement the normalization rules for your database design. A systematic approach removes
redundancy and unwanted characteristics, such as Insertion, Update, and Deletion irregularities.
The multi-step process stores data in a tabular form, which helps eliminate redundant data from the relation tables.
R MODEL OVERVIEW
The relational model, proposed by Edgar F. Codd in 1970, revolutionized the field of database management by introducing a systematic and
mathematical approach to representing and manipulating data. Codd's relational model is based on the concept of a mathematical relation, which
is essentially a table with rows and columns. Here are the key principles of Codd's relational model:
1. Tables (Relations): The fundamental structure in the relational model is a table, also known as a relation. A table consists of rows and
columns, where each row represents a record or tuple, and each column represents an attribute or field.
2. Tuples and Attributes: A tuple is a single record or row in a table, containing data values for each attribute. Attributes are the columns of
the table, defining the properties or characteristics of the entities being represented.
3. Uniqueness and Identifiers: Each tuple in a relation is uniquely identified by a combination of values from one or more attributes, known
as a key. Keys ensure that each tuple in a relation is distinct and identifiable.
4. Data Integrity: The relational model enforces integrity constraints to maintain the accuracy and consistency of data. These constraints
include entity integrity (ensuring primary keys are unique), referential integrity (maintaining consistency between related tables), and
domain integrity (ensuring valid data values within specified domains).
5. Operations: The relational model provides a set of operations for manipulating and querying data stored in relations. These operations
include selection (filtering rows based on certain criteria), projection (selecting specific columns), join (combining data from multiple
tables), and set operations (union, intersection, difference).
6. Normalization: Codd introduced the concept of database normalization, which involves organizing data into relations to reduce
redundancy and dependency. Normalization techniques, such as First Normal Form (1NF), Second Normal Form (2NF), and Third Normal
Form (3NF), help ensure data integrity and facilitate efficient data management.
7. Structured Query Language (SQL): Codd's relational model laid the foundation for the development of the Structured Query Language
(SQL), a standardized language for querying and manipulating relational databases. SQL provides a powerful and flexible interface for
interacting with relational databases based on the principles of the relational model.
Overall, Codd's relational model has had a profound impact on database management systems (DBMS) and remains the
basis for most modern relational database systems, providing a robust framework for organizing, querying, and managing
structured data.
THANK YOU!