DATABSE MANAGEMENT SYSTEM CHEATSHEET BY TECHIE CODEBUDDY

(This Cheatsheet is free, don’t pay any money for it)

### What is a Database?

Definition:
A database is a systematic collection of data that is stored and accessed
electronically from a computer system. It is designed to manage and organize
large amounts of information efficiently.
Key Features:
- Structured Storage: Data is organized into tables, records, and fields.
- Accessibility: Users can easily retrieve, update, and manage data.
- Consistency: Ensures data accuracy and integrity through constraints and
rules.
- Scalability: Can handle large volumes of data and grow with the needs of the
organization.

Real-World Example:
Think of a library catalog. Instead of keeping book information on individual cards
or pieces of paper, all details (title, author, genre, availability) are stored in a
structured, organized system. This system helps librarians quickly find and
manage books, and it makes it easy for users to search for specific titles or
authors.

### Evaluation of Database Models (In Short)

1. Hierarchical Model:
- Structure: Data is organized in a tree-like structure with a parent-child
relationship.
- Pros: Easy to understand and implement.
- Cons: Rigid structure and not flexible for complex queries.
Example: A company's organizational chart where each manager has a list of
employees reporting to them.

2. Network Model:
- Structure: Data is organized in a graph structure with nodes representing
entities and edges representing relationships.
- Pros: More flexible than hierarchical models; supports many-to-many
relationships.
- Cons: Complex to design and manage.
Example: A social network where users are connected to other users, and
connections can have multiple types (friends, colleagues).

3. Relational Model:
- Structure: Data is organized into tables (relations) with rows and columns.
Tables can be linked using primary and foreign keys.
- Pros: Easy to use, flexible, and supports complex queries. It is the most widely
used model.
- Cons: Can become complex with very large datasets.
Example: A database for an online store with tables for customers, products,
and orders. Relationships between these tables (e.g., customers placing orders)
are managed using keys.

4. Object-Oriented Model:
- Structure: Data is represented as objects, similar to object-oriented
programming concepts. Each object contains data and methods.
- Pros: Aligns well with object-oriented programming, supports complex data
types.
- Cons: Less mature compared to relational models; can be more complex to
design.

Example: A database for a graphics application where shapes and their

properties are represented as objects.

5. NoSQL Model:
- Structure: Non-relational databases that use various data models (document,
key-value, column-family, graph).
- Pros: Highly scalable and flexible; suitable for unstructured or semi-structured
data.
- Cons: May lack support for complex queries and transactions.
Example: A document store like MongoDB where each document (e.g., a user
profile) can have different structures.
Each database model has its strengths and is suited for different types of
applications and data requirements.
### Types of Databases
1. Centralized Database
- Definition:
A centralized database is stored, managed, and maintained in a single location
or server. All data operations are performed on this central system.

- Advantages:
- Simplified Management: Easier to manage and maintain because everything is
in one place.
- Consistency: Ensures data consistency since there is only one copy of the
data.
- Security: Easier to implement security measures since there is a single point of
access.

Disadvantages:
- Single Point of Failure: If the central server fails, the entire system is affected.
- Scalability Issues: Can become a bottleneck as the number of users or volume
of data grows.
- Use Case/Example:
A company's internal HR system where all employee records, payroll data, and
performance evaluations are stored on a single central server.

2. Distributed Database
- Definition:
A distributed database is spread across multiple locations, servers, or nodes.
The data is distributed to provide better performance and reliability.
Advantages:
- Scalability: Can handle a large number of transactions and data volumes by
distributing the load.
- Fault Tolerance: Reduces risk of a single point of failure as data is replicated
across multiple sites.

Disadvantages:
- Complex Management: More complex to manage and synchronize data across
multiple locations.
- Consistency Challenges: Ensuring data consistency and synchronization can
be challenging.

Use Case/Example:
A global e-commerce platform where user data, transaction records, and
product information are stored across servers in different regions to enhance
performance and reliability.
3. Relational Database
Definition:
A relational database organizes data into tables (relations) with rows and
columns. It uses Structured Query Language (SQL) for managing and querying
data.
Advantages:
- Flexibility: Supports complex queries and relationships between tables.
- Data Integrity: Enforces data integrity through constraints and keys.
- Widely Used: Mature and widely adopted with extensive support and tools.

Disadvantages:
- Scalability Limits: Can struggle with very large datasets or high transaction
volumes.
- Complex Design: Schema design can be complex, especially for large
applications.

Use Case/Example:
A university's student information system where tables store data about
students, courses, and enrollments, and relationships between these entities are
managed using foreign keys.

4. NoSQL Database
Definition:
NoSQL databases are non-relational databases designed for unstructured or
semi-structured data. They use various models, including document, key-value,
column-family, and graph.
Advantages:
- Scalability: Highly scalable and can handle large volumes of diverse data
types.
- Flexibility: Allows for a flexible schema and supports unstructured data.

Disadvantages:
- Limited Querying: May not support complex queries and transactions as well
as relational databases.
- Consistency: May trade off consistency for availability and partition tolerance
(CAP theorem).

Use Case/Example:
A content management system for a blog where articles, comments, and user
profiles are stored as documents in a document store like MongoDB.

5. Cloud Database
Definition:
A cloud database is hosted and managed by a cloud service provider. It offers
database services over the internet and is scalable on demand.
Advantages:
- Scalability: Easily scales resources up or down based on demand.
- Cost-Effective: Reduces the need for physical hardware and maintenance.
- Accessibility: Accessible from anywhere with an internet connection.

Disadvantages:
- Security Concerns: Data is stored off-site, which can raise security and privacy
concerns.
- Reliance on Internet: Requires a stable internet connection for access.

Use Case/Example:
A startup using Amazon RDS (Relational Database Service) for managing its
customer data and application transactions, benefiting from scalable resources
and reduced management overhead.

6. Object-Oriented Database
Definition:
An object-oriented database stores data as objects, similar to object-oriented
programming. Each object contains data and methods for manipulating that data.
Advantages:
- Alignment with OOP: Aligns well with object-oriented programming concepts,
making it easier to work with complex data.
- Complex Data Types: Supports complex data structures and relationships.
Disadvantages:
- Less Mature: Less mature compared to relational databases, with fewer tools
and support.
- Performance: Can have performance issues with certain types of queries.

Use Case/Example:
A CAD (Computer-Aided Design) application where design objects like shapes,
lines, and colors are stored as objects with methods for rendering and
manipulating them.
7. Hierarchical Database
Definition:
A hierarchical database organizes data in a tree-like structure, where each record
has a single parent and possibly multiple children.

Advantages:
- Simplicity: Easy to understand and implement for simple data relationships.
- Performance: Efficient for hierarchical data retrieval.

Disadvantages:
- Rigid Structure: Not flexible for complex queries or relationships.
- Redundancy: Can lead to data redundancy and difficulty in managing many-to-
many relationships.
Use Case/Example:
An organizational chart where each department has sub-departments and
employees, with a clear parent-child relationship.

8. Network Database
- Definition:
A network database uses a graph structure where entities are represented as
nodes and relationships are represented as edges, allowing multiple relationships
between nodes.

- Advantages:
- Flexibility: Supports many-to-many relationships and complex data models.
- Performance: Efficient for complex queries with multiple relationships.

- Disadvantages:
- Complexity: More complex to design and manage compared to hierarchical
databases.
- Maintenance: Harder to maintain and update due to intricate relationships.

- Use Case/Example:
A telecommunications network where connections between different network
nodes (switches, routers) need to be modeled and managed.

9. Personal Database
Definition:
A personal database is designed for individual use, often for personal projects or
small-scale applications. It is typically lightweight and user-friendly.
Advantages:
- Ease of Use: Simple to set up and use without requiring extensive knowledge.
- Cost-Effective: Often free or inexpensive and does not require large-scale
resources.
Disadvantages:
- Limited Scalability: Not suitable for large-scale or enterprise applications.
- Limited Features: May lack advanced features and support.
Use Case/Example:
A personal budget management system where an individual tracks their income,
expenses, and savings using a desktop database application like Microsoft
Access.

### What is RDBMS (Relational Database Management System)?

Definition:
A Relational Database Management System (RDBMS) is a type of database
management system that stores data in a structured format, using rows and
columns. It organizes data into tables (also called relations) that can be linked—
or related—based on data common to each. RDBMS uses Structured Query
Language (SQL) for querying and managing data
Key Features:

1. Tables:
- Data is stored in tables, which consist of rows and columns.
- Each table represents an entity, and columns represent attributes of that entity.

2. Relationships:
- Tables can be related to each other through primary and foreign keys.
- Primary Key: A unique identifier for a record in a table.
- Foreign Key: A field in one table that links to the primary key in another table.

3. SQL Support:
- SQL is used to perform various operations like querying, updating, inserting,
and deleting data.
- SQL commands include `SELECT`, `INSERT`, `UPDATE`, `DELETE`, `JOIN`,
etc.

4. Normalization:
- The process of organizing data to reduce redundancy and improve data
integrity.
- Involves dividing a database into two or more tables and defining relationships
between them.

5. Data Integrity:
- Enforces rules and constraints to ensure the accuracy and consistency of data.
- Examples include unique constraints, foreign key constraints, and check
constraints.
6. ACID Properties:
- Atomicity: Ensures that all parts of a transaction are completed successfully
or none are.
- Consistency: Ensures that a transaction brings the database from one valid
state to another.
- Isolation: Ensures that transactions are executed independently and
transparently.
- Durability: Ensures that once a transaction is committed, it remains in the
database even if there is a system failure.

Advantages:
1. Data Integrity and Accuracy:
- Ensures data accuracy through constraints and relationships between tables.

2. Flexibility:
- Allows complex queries and operations to be performed using SQL.

3. Data Security:
- Provides robust security features to control access and protect data.

4. Scalability:
- Can handle large volumes of data and multiple users efficiently.

5. Ease of Maintenance:
- Provides tools and interfaces for managing and maintaining the database
easily.

Disadvantages:
1. Complexity:
- Can be complex to design, especially for large systems with many tables and
relationships.
2. Performance:
- Performance can be affected as data volume and transaction complexity
increase.

3. Cost:
- Licensing costs for commercial RDBMS software can be high.

Real-World Example:
1. Online Retail Store:
- An e-commerce website uses an RDBMS to manage various data aspects,
including customer information, product details, and order records.
- Tables:
- `Customers` table: Stores customer information like customer_id (Primary
Key), name, email, etc.
- `Products` table: Stores product details like product_id (Primary Key), name,
price, etc.
- `Orders` table: Stores order details like order_id (Primary Key), customer_id
(Foreign Key), product_id (Foreign Key), order_date, etc.
- Relationships:
- The `Orders` table links to the `Customers` and `Products` tables through
foreign keys, allowing the system to track which customer placed which order and
what products were included in each order.

2. Banking System:
- A banking application uses an RDBMS to handle transactions, account
management, and customer information.
- Tables:
- `Accounts` table: Stores account details such as account_id (Primary Key),
account_type, balance, etc.
 - `Transactions` table: Records transaction details such as transaction_id
(Primary Key), account_id (Foreign Key), amount, transaction_date, etc.
- Relationships:
- The `Transactions` table links to the `Accounts` table through a foreign key,
allowing the system to associate each transaction with a specific account and
maintain accurate financial records.

RDBMS is foundational in modern data management and remains widely used

across various applications due to its structured approach and robustness.

Differences between DBMS and RDBMS:

### DBMS Architecture
Database Management System (DBMS) architectures describe the way database
systems are structured and how they interact with users and applications. There
are three primary types of DBMS architecture: 1-Tier, 2-Tier, and 3-Tier.

1. 1-Tier Architecture
Definition:
In a 1-Tier architecture, also known as a single-tier or standalone architecture,
the database system and the application run on the same machine. There is no
distinction between the user interface, application logic, and database.
Components:
- Database: Directly managed and accessed by the application.
- Application: The application and database management system are integrated
into a single layer.

Advantages:
- Simplicity: Easy to set up and use since everything is contained in one layer.
- No Network Latency: No network delays as everything runs on a single
machine.
Disadvantages:
- Scalability: Limited scalability as the system depends on the capabilities of a
single machine.
- Data Management: All data operations are handled by the local machine,
which can be inefficient for larger applications.

- Use Case/Example:
A desktop application like Microsoft Access where the database and application
are both installed on a user’s personal computer.

2. 2-Tier Architecture
Definition:
In a 2-Tier architecture, the system is divided into two layers: the client layer and
the server layer. The client layer interacts directly with the database server.
Components:
- Client Layer: The application or user interface that interacts with the database.
- Server Layer: The database server that manages and stores the data.
Advantages:
- Separation of Concerns: The application and database are separated, making
it easier to manage and scale.
- Improved Performance: Direct communication between the client and server
can reduce latency.
Disadvantages:
- Limited Scalability: While it improves over 1-Tier, scaling can still be
challenging for large numbers of users or complex applications.
- Network Dependency: Performance depends on network reliability and
bandwidth.

Use Case/Example:
A client-server application where a business application installed on users'
machines directly interacts with a central database server. For example, a sales
application accessing a central database for customer information and sales
records.

3. 3-Tier Architecture
Definition:
In a 3-Tier architecture, the system is divided into three layers: the presentation
layer, the application layer, and the database layer. Each layer is responsible for
different aspects of the application.
Components:
- Presentation Layer: The user interface that interacts with the user. It handles
the display of data and user input.
- Application Layer (Business Logic Layer): The middle layer that processes user
requests, applies business logic, and communicates with the database layer.
- Database Layer: The layer that manages and stores the data.
Advantages:
- Scalability: Easier to scale each layer independently. For instance, you can
scale the application server or database server as needed.
- Maintainability: Changes in one layer (e.g., user interface) do not directly
impact the other layers.
- Flexibility: Allows for different technologies to be used in each layer (e.g.,
different programming languages for business logic and database management).

Disadvantages:
- Complexity: More complex architecture, requiring careful design and
integration.
- Performance Overhead: Additional layers can introduce latency due to the
multiple steps involved in processing a request.
Use Case/Example:
A web application where:
- Presentation Layer: The web browser or web application that users interact
with.
- Application Layer: The web server (e.g., Apache, Nginx) that processes
business logic and requests.
- Database Layer: The database server (e.g., MySQL, PostgreSQL) that stores
and manages data.
### Summary
1-Tier Architecture: All-in-one system; simple but limited in scalability.
2-Tier Architecture: Client-server model; better scalability than 1-Tier but still
limited.
3-Tier Architecture: Separation of presentation, business logic, and data; highly
scalable and maintainable.

Each architecture has its own use cases and is chosen based on factors like
application complexity, scalability needs, and maintainability requirements.

### Three-Schema Architecture

The Three-Schema Architecture is a framework used in database management
systems to separate the database system's structure into three different levels.
This architecture is designed to provide a clear separation between different
aspects of the database system, facilitating data management and ensuring data
abstraction.
The three levels are:
1. Internal Schema (Physical Level)
2. Conceptual Schema (Logical Level)
3. External Schema (View Level)

1. Internal Schema (Physical Level)

- Definition:
The internal schema describes the physical storage of data in the database. It
defines how data is stored on the hardware, including data structures, file
organization, and indexing.

- Key Aspects:
- Data Storage: Details how data is stored on disk.
- Access Methods: Specifies how data is retrieved and manipulated efficiently.
- File Organization: Describes how data files are organized, such as through
sequential or indexed file structures.

- Advantages:
- Efficiency: Optimizes data storage and retrieval operations.
- Flexibility: Allows changes in storage structures without affecting the higher
levels.

- Example:
In a relational database, the internal schema might specify that tables are stored
in indexed files, with data organized in B-trees for quick retrieval.
2. Conceptual Schema (Logical Level)
- Definition:
The conceptual schema provides a unified view of the entire database, focusing
on the logical structure of the data without considering how it is physically stored.
It describes the data model, entities, relationships, constraints, and schema
design.

- Key Aspects:
- Data Model: Defines the overall structure of the database, including tables,
relationships, and constraints.
- Entity-Relationship Model: Represents entities (e.g., customers, products) and
their relationships (e.g., orders placed by customers).
- Constraints: Enforces rules such as primary keys, foreign keys, and unique
constraints.

- Advantages:
- Consistency: Provides a clear and consistent view of the data structure.
- Abstraction: Separates the logical design from physical implementation,
making it easier to manage and design the database.

- Example:
The conceptual schema of a university database might define tables for
`Students`, `Courses`, and `Enrollments`, and specify how these tables are
related (e.g., students enroll in courses).
3. External Schema (View Level)
- Definition:
The external schema, or view level, represents the user views of the database. It
defines how different users or applications interact with the database, including
what data is visible and how it is presented.
Key Aspects:
- User Views: Provides customized views for different users based on their
needs and roles.
- Access Control: Determines which parts of the database users can access and
modify.
- Data Presentation: Defines how data is formatted and presented to users.

Advantages:
- User Specific: Tailors the data presentation to different user requirements.
- Security: Restricts access to sensitive data based on user roles and
permissions.
Example:
In a company database, the external schema might include different views for
employees, managers, and HR personnel. Employees might see only their own
data, while managers might have access to team data, and HR might have access
to all employee records.

### Summary
- Internal Schema (Physical Level): Focuses on how data is physically stored.
- Conceptual Schema (Logical Level): Defines the logical structure and
relationships of data.
- External Schema (View Level): Provides tailored views of data for different
users or applications.
### Data Models
Data models define the structure, organization, and relationships of data in a
database. They provide a conceptual framework for understanding and managing
data. Here are explanations of different types of data models:

1. Relational Data Model

- Definition:
The Relational Data Model organizes data into tables (relations) that are linked by
common attributes. Each table consists of rows (records) and columns
(attributes).
- Key Components:
- Tables: Represent entities (e.g., `Customers`, `Orders`).
- Rows: Each row is a record or instance of the entity.
- Columns: Each column represents an attribute or field of the entity.
- Primary Key: A unique identifier for each row in a table.
- Foreign Key: An attribute that creates a link between two tables by referencing
the primary key of another table.

- Advantages:
- Simplicity: Easy to understand and use.
- Flexibility: Supports complex queries using SQL.
- Data Integrity: Enforces constraints like primary and foreign keys to ensure
accuracy.
2. Entity-Relationship (ER) Data Model
- Definition:
The Entity-Relationship (ER) Data Model is a conceptual framework that
describes the data using entities, attributes, and relationships. It is often used to
design the database schema.
- Key Components:
- Entities: Objects or concepts (e.g., `Student`, `Course`) that have data
stored about them.
- Attributes: Properties or characteristics of entities (e.g., `StudentID`,
`StudentName`).
- Relationships: Associations between entities (e.g., `Enrollment` relationship
between `Student` and `Course`).

- Advantages:
- Conceptual Clarity: Provides a high-level view of the database structure.
- Design Tool: Useful for designing and visualizing the database schema before
implementation.

3. Object-Based Data Model

- Definition:
The Object-Based Data Model combines database capabilities with object-
oriented programming concepts. It represents data as objects, similar to objects
in programming languages like Java or C++.
- Key Components:
- Objects: Instances of classes, representing both data and methods (e.g.,
`Customer` object with methods to update customer information).
- Classes: Templates for creating objects, defining properties and methods.
- Inheritance: Ability to create new classes based on existing ones, inheriting
attributes and behaviors.

- Advantages:
- Rich Data Representation: Supports complex data types and relationships.
- Integration: Aligns well with object-oriented programming languages, enabling
easier integration.

4. Semi-Structured Data Model

Definition:
The Semi-Structured Data Model represents data that does not conform to a rigid
schema but still includes some organizational structure. It is used to handle data
that is partially structured, such as documents or web data.
- Key Components:
- Tags or Markup: Used to annotate data with metadata (e.g., XML or JSON tags).
- Hierarchical Structure: Data is often organized in a tree-like structure but is
flexible in terms of schema.
- Advantages:
- Flexibility: Accommodates data with varying structures.
- Scalability: Suitable for handling large amounts of diverse data types.
### Summary
- Relational Data Model: Uses tables to represent data and relationships; ideal
for structured data and complex queries.
- ER Data Model: Provides a conceptual design of the database using entities
and relationships; useful for database design.
- Object-Based Data Model: Represents data as objects, integrating with object-
oriented programming; supports complex data structures.
- Semi-Structured Data Model: Handles data with flexible structure, using tags
or markup; suitable for diverse and unstructured data types.

Each data model has its own use cases and is chosen based on the requirements
of the application and the nature of the data being managed.

### DBMS Languages

Database Management Systems (DBMS) use various languages to interact with
and manage data. These languages can be broadly categorized into three types:
Data Definition Language (DDL), Data Manipulation Language (DML), and Data
Control Language (DCL). Here’s a detailed overview:
1. Data Definition Language (DDL)
- Definition:
DDL is used to define and manage the structure of the database schema. It
includes commands that create, modify, and delete database objects such as
tables, indexes, and schemas.

- Use Case:
When setting up a new database or changing the structure of existing tables, you
use DDL commands to define or adjust the schema.

2. Data Manipulation Language (DML)

Definition:
DML is used for querying and manipulating data within the database. It includes
commands to insert, update, delete, and retrieve data.
- Use Case:
When interacting with the database to manage or retrieve data, DML commands
are used for everyday operations such as querying data or updating records.

3. Data Control Language (DCL)

Definition:
DCL is used to control access to data within the database. It includes commands
to grant or revoke permissions to users.

- Use Case:
When managing user permissions and access control, DCL commands are used
to specify who can access or modify the data in the database.
### Summary
- DDL (Data Definition Language): Manages the structure of database objects
(e.g., `CREATE`, `ALTER`, `DROP`).
- DML (Data Manipulation Language): Handles the manipulation and retrieval of
data (e.g., `SELECT`, `INSERT`, `UPDATE`, `DELETE`).
- DCL (Data Control Language): Controls user access and permissions (e.g.,
`GRANT`, `REVOKE`).

These languages are essential for managing and interacting with databases, each
serving a specific purpose in the database management process.

### ACID Properties

(Click here for more detailed Explanation with Diagrams)
ACID properties are a set of principles that ensure reliable processing of database
transactions. They are crucial for maintaining data integrity and consistency in a
database system. ACID stands for Atomicity, Consistency, Isolation, and
Durability.

1. Atomicity
- Definition:
Atomicity ensures that a transaction is treated as a single, indivisible unit of
work. Either all the operations within the transaction are completed successfully,
or none are applied.

- Key Points:
- All-or-Nothing: If any part of the transaction fails, the entire transaction is
rolled back, and no changes are applied.
- Rollback: If a transaction encounters an error, any changes made are undone.
- Example:
In a bank transfer, if a transaction involves transferring money from one account
to another, atomicity ensures that either both the debit from one account and the
credit to another account are completed successfully, or neither is done. If an
error occurs during the process, both operations are rolled back.

2. Consistency
- Definition:
Consistency ensures that a transaction brings the database from one valid state
to another valid state, maintaining all defined rules and constraints.

- Key Points:
- Data Integrity: The database must adhere to all constraints, rules, and
relationships after a transaction.
- Integrity Constraints: Ensures that the database remains in a consistent state
before and after the transaction.

- Example:
In an online store, if a transaction involves adding a new order, consistency
ensures that the database will reflect the new order accurately and that inventory
levels are updated accordingly. For instance, if a product's stock is reduced by
one when an order is placed, consistency ensures that no negative stock values
are recorded.

3. Isolation
- Definition:
Isolation ensures that concurrent transactions do not interfere with each other.
Each transaction is executed in isolation from others, so its operations are not
visible to other transactions until it is complete.
- Key Points:
- Concurrency Control: Prevents data corruption caused by concurrent
transactions.
- Isolation Levels: Different isolation levels (e.g., Read Uncommitted, Read
Committed, Repeatable Read, Serializable) determine the degree of visibility and
interaction between transactions.
Example:
If two transactions are concurrently updating the balance of the same bank
account, isolation ensures that each transaction's operations do not affect the
other's intermediate results. For instance, if one transaction is updating the
balance while another is reading it, isolation ensures that the read operation will
not see an inconsistent or intermediate state.

4. Durability
Definition:
Durability ensures that once a transaction has been committed, its changes are
permanent and will survive any subsequent system failures or crashes.

- Key Points:
- Persistence: Changes made by a committed transaction are stored in non-
volatile storage and are not lost even if there is a system failure.
- Recovery: The database can recover committed transactions after a crash or
failure.

- Example:
After a transaction that updates a user's profile information is committed,
durability ensures that the updated profile will remain in the database even if the
system crashes immediately after the commit.
### Summary
- Atomicity: Ensures transactions are all-or-nothing.
- Consistency: Ensures transactions bring the database from one valid state to
another.
- Isolation: Ensures concurrent transactions do not interfere with each other.
- Durability: Ensures committed transactions are permanently recorded and
survive system failures.

The ACID properties collectively ensure that database transactions are processed
reliably and that data integrity is maintained, providing a robust framework for
transaction management in database systems.

### Data Modeling and ER Model

Data Modeling is the process of creating a visual representation of a system’s
data and its relationships. It helps in understanding and organizing the data
requirements for a system. The Entity-Relationship (ER) Model is one of the most
widely used approaches in data modeling for designing databases.
### Data Modeling
Definition:
Data Modeling involves creating diagrams and documentation that define the
structure, relationships, and constraints of data within a system. It is used to
design and analyze the data needs of an organization or system.
Purpose:
- Understand Requirements: Helps in capturing the data requirements of the
system.
- Design Database Schema: Provides a blueprint for creating the database
structure.
- Facilitate Communication: Offers a clear representation of data to
stakeholders and developers.
Components:
- Entities: Objects or concepts about which data is stored (e.g., `Customer`,
`Order`).
- Attributes: Properties or characteristics of entities (e.g., `CustomerID`,
`OrderDate`).
- Relationships: Connections between entities that define how data is related
(e.g., `Customer places Order`).

### Entity-Relationship (ER) Model

Definition:
The ER Model is a high-level conceptual data model that visually represents the
data, its entities, attributes, and relationships. It is used for database design and
helps in understanding the data requirements and structure of a database.
Key Components:
1. Entities:
- Definition: Objects or things in the domain that have a distinct existence.
Entities can be physical objects or abstract concepts.
- Example: `Employee`, `Department`, `Product`.

2. Attributes:
- Definition: Characteristics or properties of an entity. Attributes provide more
information about an entity.
- Types:
- Simple Attribute: Cannot be divided further (e.g., `Name`).
- Composite Attribute: Can be divided into smaller attributes (e.g., `Address`
divided into `Street`, `City`, `ZipCode`).
- Derived Attribute: Can be derived from other attributes (e.g., `Age` derived
from `DateOfBirth`).
 - Multivalued Attribute: Can have multiple values (e.g., `PhoneNumbers`).

3. Relationships:
- Definition: Associations between entities that describe how they interact with
each other.
- Types:
- One-to-One (1:1): One entity instance relates to one instance of another
entity (e.g., `Person` has one `Passport`).
- One-to-Many (1:N): One entity instance relates to multiple instances of
another entity (e.g., `Customer` places multiple `Orders`).
- Many-to-Many (M:N): Multiple instances of one entity relate to multiple
instances of another entity (e.g., `Student` enrolls in multiple `Courses`, and
`Course` has multiple `Students`).

4. ER Diagram (ERD):
- Definition: A visual representation of the ER Model that shows entities,
attributes, and relationships.
- Components:
- Rectangles: Represent entities.
- Ellipses: Represent attributes.
- Diamonds: Represent relationships.
- Lines: Connect entities to relationships and attributes.

Example ER Diagram:
Consider a simple example of an ER Diagram for a university database:

- Entities: `Student`, `Course`

- Attributes:
 - `Student` has `StudentID`, `Name`, `Email`
- `Course` has `CourseID`, `CourseName`, `Credits`
- Relationships: `Enrolls` (a student enrolls in multiple courses)
- ER Diagram:
- Draw `Student` and `Course` as rectangles.
- Draw `Enrolls` as a diamond connecting `Student` and `Course`.
- Add attributes to `Student` and `Course` using ellipses connected to the
respective entities.

### Summary
Data Modeling: A method to design and represent data requirements and
structures.
ER Model: A conceptual framework for designing databases using entities,
attributes, and relationships, often visualized through an ER Diagram.
Purpose of ER Model:
- Design Database Schema: Provides a blueprint for creating and structuring the
database.
- Understand Data Relationships: Helps in visualizing how different data
elements are related.

The ER Model is a fundamental tool in database design, offering a clear and

structured approach to defining and organizing data.

### DBMS Keys

Keys are fundamental concepts in relational databases used to uniquely identify
records and establish relationships between tables. They play a crucial role in
ensuring data integrity and efficient data retrieval. Here are the main types of keys
in DBMS:
1. Primary Key
- Definition:
A primary key is a unique identifier for a record in a table. It ensures that each
record is uniquely identifiable and that no two records have the same primary key
value.
- Characteristics:
- Uniqueness: Each value of the primary key must be unique.
- Non-null: A primary key cannot contain null values.

- Example:
In a `Students` table, `StudentID` can be used as the primary key to uniquely
identify each student.

- Use Case:
The primary key ensures that each student can be uniquely identified and
retrieved from the `Students` table.

2. Foreign Key
- Definition:
A foreign key is an attribute in one table that refers to the primary key of another
table. It establishes a link between the two tables, enforcing referential integrity.
Characteristics:
- Referential Integrity: Ensures that the value in the foreign key column matches
a value in the primary key column of the referenced table.
 - Optional Nulls: Foreign key columns can contain null values if the relationship
is optional.

- Example:
In an `Orders` table, `CustomerID` can be a foreign key that references the
`CustomerID` in the `Customers` table.

- Use Case:
The foreign key ensures that each order in the `Orders` table is associated with a
valid customer in the `Customers` table.

3. Candidate Key
- Definition:
A candidate key is an attribute or a set of attributes that can uniquely identify a
record in a table. Each table can have multiple candidate keys, but one is selected
as the primary key.

- Characteristics:
- Uniqueness: Each candidate key value must be unique.
- Minimality: It should not contain any unnecessary attributes; removing any
attribute should make it no longer a candidate key.
- Example:
In a `Users` table, both `Username` and `Email` might be candidate keys if
they are both unique.

- Use Case:
Candidate keys offer alternative ways to uniquely identify records. You can
choose any candidate key as the primary key based on requirements.

4. Alternate Key
- Definition:
An alternate key is any candidate key that is not selected as the primary key. It
still uniquely identifies records but is not used as the primary key.

- Characteristics:
- Uniqueness: Must be unique, like the primary key.
- Alternative Identification: Provides an alternative way to identify records.

- Example:
In the `Users` table mentioned earlier, if `Username` is chosen as the primary
key, then `Email` is an alternate key.

- Use Case:
 Alternate keys are used when a table needs multiple unique identifiers, offering
flexibility in data retrieval.

5. Composite Key
- Definition:
A composite key is a primary key that consists of two or more attributes that
together uniquely identify a record.
- Characteristics:
- Combination: The combination of the attributes must be unique across all
records.
- Multi-Attribute: Involves more than one attribute to ensure uniqueness.

- Example:
In a `CourseEnrollments` table, a composite key could be a combination of
`StudentID` and `CourseID`.

- Use Case:
Composite keys are useful in many-to-many relationships where a single
attribute is not sufficient to uniquely identify records.
6. Super Key
- Definition:
A super key is a set of one or more attributes that can uniquely identify a record
in a table. It includes the primary key as well as any additional attributes that may
be included.
- Characteristics:
- Uniqueness: Ensures uniqueness of records.
- Superset: Includes primary key and additional attributes.

- Example:
In a `Employees` table, `EmployeeID` alone could be a super key, but
`EmployeeID` combined with `Email` is also a super key.

- Use Case:
Super keys are used to identify records uniquely, but only one super key is
usually chosen as the primary key.

### Summary
- Primary Key: Uniquely identifies each record in a table. Cannot be null.
- Foreign Key: Establishes relationships between tables. Refers to the primary
key of another table.
- Candidate Key: A set of attributes that can uniquely identify records. Includes
the primary key.
- Alternate Key: Candidate keys not selected as the primary key.
- Composite Key: A primary key composed of multiple attributes.
- Super Key: A set of attributes that uniquely identifies records, including the
primary key and additional attributes.

Understanding these keys is essential for designing and managing relational

databases effectively, ensuring data integrity, and establishing meaningful
relationships between tables.

### Generalization, Specialization, and Aggregation

These concepts are part of the Entity-Relationship (ER) Model and are used to
handle hierarchical relationships and abstraction in database design.
1. Generalization
- Definition:
Generalization is a process of extracting common characteristics from multiple
entities to create a generalized entity. It is the opposite of specialization and is
used to create a higher-level entity that abstracts common properties and
relationships.

- Characteristics:
- Abstraction: Combines several lower-level entities into a higher-level entity
based on shared attributes.
- Hierarchical: Helps in organizing data into a hierarchy where a generalized
entity encompasses multiple specialized entities.
- Use Case:
Generalization is useful when you have multiple entities that share common
attributes or behaviors, and you want to reduce redundancy by combining them
into a single generalized entity.

2. Specialization
- Definition:
Specialization is the process of creating new entities from an existing,
generalized entity by adding more specific attributes or relationships. It involves
breaking down a generalized entity into more specific sub-entities.

- Characteristics:
- Detailing: Adds more detail and specificity to a generalized entity.
- Hierarchical: Creates a hierarchy where specialized entities inherit common
attributes from a generalized entity but also have their own distinct attributes.
- Use Case:
Specialization is used when you need to represent entities with more detailed or
specific attributes that differ from the generalized entity, providing a clear
distinction between various roles or types.

3. Aggregation
- Definition:
Aggregation is a concept used to express a relationship between a whole and its
parts or between a complex entity and its components. It represents a higher-
level abstraction that groups together entities and their relationships into a single
higher-level entity.
Characteristics:
- Composite Relationships: Allows for complex relationships to be treated as a
single entity.
- Hierarchical: Aggregates multiple entities and relationships into a higher-level
entity, often to simplify the ER diagram.
- Use Case:
Aggregation is useful when you need to simplify complex relationships or
represent a composite entity that groups together multiple entities and their
relationships.

### Summary
- Generalization: Combines multiple lower-level entities into a higher-level entity
based on shared attributes.
- Specialization: Breaks down a generalized entity into more specific entities
with additional attributes.
- Aggregation: Groups together entities and their relationships into a single
higher-level entity for simplification.

These concepts help in organizing and abstracting data efficiently in database

design, making the structure more manageable and comprehensible.
### Normalization, Types of Normal Forms, and Anomalies
Normalization is a process in database design used to minimize redundancy and
dependency by organizing data into related tables. The goal is to ensure data
integrity and reduce anomalies that can occur when modifying the data.
Normalization involves dividing a database into two or more tables and defining
relationships between them.

### Normalization
Definition:
Normalization is the process of structuring a database to reduce redundancy and
improve data integrity by organizing data into tables and establishing
relationships between them.
Purpose:
- Eliminate Redundancy: Avoid storing the same data in multiple places.
- Improve Data Integrity: Ensure data is consistent and accurate.
- Simplify Queries: Make it easier to query and update data.

Process:
Normalization is achieved through a series of stages called normal forms, each
addressing different types of redundancy and dependency.

### Types of Normal Forms

1. First Normal Form (1NF) (Click to read JavaTpoint Arcticle)
- Definition: A table is in 1NF if it only contains atomic (indivisible) values and
each column contains only a single value. Each column must have a unique
name, and the order in which data is stored does not matter.
Characteristics:
- Atomicity: Ensures that each field contains only one value.
- Uniqueness: No repeating groups or arrays in a column.
2. Second Normal Form (2NF) (Click to read JavaTpoint Article)
Definition: A table is in 2NF if it is in 1NF and all non-key attributes are fully
functionally dependent on the primary key. It eliminates partial dependency,
where a non-key attribute is dependent on part of a composite key.

- Characteristics:
- Full Functional Dependency: Ensures that all attributes depend on the entire
primary key, not just part of it.
3. Third Normal Form (3NF)
- Definition: A table is in 3NF if it is in 2NF and all attributes are functionally
dependent only on the primary key, eliminating transitive dependency (where
non-key attributes depend on other non-key attributes).

Characteristics:
- No Transitive Dependency: Ensures that non-key attributes are not
dependent on other non-key attributes.
4. Boyce-Codd Normal Form (BCNF)

- Definition: A table is in BCNF if it is in 3NF and every determinant is a

candidate key. BCNF addresses situations where 3NF does not handle certain
types of redundancy.
- Characteristics:
- Stricter Form of 3NF: Ensures that every determinant in the table is a
candidate key.

Example:
If a table with attributes `A`, `B`, and `C` has functional dependencies such
that `A` and `B` determine `C`, and `A` is not a candidate key, it violates BCNF.

5. Fourth Normal Form (4NF)

- Definition: A table is in 4NF if it is in BCNF and has no multi-valued
dependencies (where one attribute can have multiple values independent of
other attributes).
- Characteristics:
- Eliminates Multi-Valued Dependencies: Ensures that no attribute has
multiple independent values.

- Example:
A table storing information about a student and their hobbies, where each
student can have multiple hobbies and each hobby can belong to multiple
students, should be decomposed to satisfy 4NF.
6. Fifth Normal Form (5NF)
Definition: A table is in 5NF if it is in 4NF and all join dependencies are implied by
candidate keys. It deals with cases where information can be reconstructed
without any loss of information.
Characteristics:
- Join Dependency: Ensures that all relationships can be restored by joining
tables based on candidate keys.

- Example:
A table with attributes `A`, `B`, `C`, and `D` that satisfies 5NF would ensure
that any complex relationships are decomposed such that they can be
reassembled without loss of information.

### Anomalies
1. Insertion Anomaly
- Definition: Occurs when certain data cannot be inserted into a database
without the presence of other data. This often happens when a table design is not
normalized.
- Example:
If you cannot add a new `Course` unless there is an associated `Student`, this
indicates an insertion anomaly.

2. Deletion Anomaly
- Definition: Occurs when the deletion of data results in the loss of additional
data that should be retained.
- Example:
If deleting an `Employee` record also unintentionally deletes the `Department`
record, this is a deletion anomaly.
3. Update Anomaly
- Definition: Occurs when changes to data in one place must be repeated in
multiple places, leading to inconsistencies.
Example:
If an employee's department name needs to be updated in several records, and
the update is not performed everywhere, this causes an update anomaly.

### Summary
- Normalization: The process of organizing data to reduce redundancy and
improve integrity through normal forms.
- Normal Forms: Include 1NF, 2NF, 3NF, BCNF, 4NF, and 5NF, each addressing
different types of data anomalies and dependencies.
- Anomalies: Include insertion, deletion, and update anomalies, which occur
when data is not properly normalized.
Normalization is crucial for designing efficient and reliable databases that
maintain data integrity and support consistent operations.

### Advantages and Disadvantages of Normalization

Normalization is a critical aspect of database design that helps ensure data
integrity and minimize redundancy. However, it comes with both benefits and
potential drawbacks. Here’s a detailed look at the advantages and disadvantages
of normalization:
### Advantages of Normalization
1. Reduces Data Redundancy
- Explanation: By organizing data into related tables and eliminating duplicate
data, normalization minimizes the repetition of data.
- Example: In a normalized database, a customer’s address information is
stored in a separate table rather than repeating the address in multiple tables.
2. Improves Data Integrity
- Explanation: Normalization ensures that data is consistent and accurate by
enforcing rules that prevent anomalies.
- Example: A normalized database prevents the creation of inconsistent or
contradictory data entries, such as multiple records for the same customer with
different addresses.

3. Facilitates Efficient Data Modification

- Explanation: Changes to data need to be made in only one place, reducing the
risk of inconsistencies.
- Example: Updating a customer’s phone number in a normalized database
requires changing it in only the `Customers` table, rather than in several places.

4. Enhances Query Performance

- Explanation: Although normalization might initially seem to complicate
queries, it often improves performance by reducing the amount of redundant
data.
- Example: Queries that join normalized tables can be more efficient because
they avoid the overhead associated with redundant data.

5. Simplifies Database Maintenance

- Explanation: Maintaining a normalized database is easier because updates,
deletions, and insertions are handled in a structured manner.
- Example: Adding a new product category only requires inserting it into the
`Categories` table without affecting other tables.

6. Promotes Data Consistency

- Explanation: With normalized tables, data is stored in a consistent manner,
which helps in maintaining data accuracy and consistency.
 - Example: Consistent data formats and relationships are maintained across
different tables.

### Disadvantages of Normalization

1. Increased Complexity
Explanation: Normalizing a database can make the schema more complex, with
many tables and relationships, which might be harder to understand and manage.
- Example: A highly normalized schema might involve numerous tables and
complex joins, making it challenging for users to write and understand queries.

2. Performance Overhead
- Explanation: While normalization can improve data integrity, it might introduce
performance overhead due to the need for multiple joins in queries.
- Example: Retrieving information from multiple normalized tables often
requires complex joins, which can impact query performance, especially with
large datasets.

3. Potential for Increased Joins

- Explanation: Normalized databases often require multiple joins to retrieve
related data, which can lead to slower query performance.
- Example: To get a complete picture of a customer’s order history, you might
need to join several tables, potentially slowing down query execution.

4. Complexity in Data Retrieval

- Explanation: Querying normalized databases can be more complex and
require more sophisticated SQL queries.
- Example: Retrieving detailed reports from a highly normalized database might
require multiple subqueries or complex joins.
5. Overhead in Database Design
- Explanation: The process of designing a normalized database can be time-
consuming and requires careful planning and analysis.
- Example: Ensuring that all normalization rules are followed and balancing the
need for normalization with performance considerations can be challenging.

6. Possible Redundancy Trade-offs

- Explanation: Sometimes, denormalization (introducing some redundancy)
might be used deliberately to improve performance for certain queries, leading to
a trade-off between normalization and efficiency.
- Example: Adding redundant data for performance reasons, such as storing
aggregated values, might reduce the strict adherence to normalization.

### Summary
Advantages:
• Reduces data redundancy.
• Improves data integrity.
• Facilitates efficient data modification.
• Enhances query performance.
• Simplifies database maintenance.
• Promotes data consistency.

Disadvantages:
• Increased complexity.
• Performance overhead due to joins.
• Potential for increased joins.
• Complexity in data retrieval.
• Overhead in database design.
• Possible trade-offs with denormalization for performance.
### Transaction Processing
Transaction Processing is a crucial concept in database management systems
(DBMS) and is essential for ensuring the integrity and consistency of data. It
involves managing and executing transactions in a way that ensures data remains
accurate and reliable, even in the face of system failures or concurrent
operations.

### Definition of a Transaction

Transaction:
A transaction is a sequence of one or more operations (such as read, write,
update, or delete) that are executed as a single unit of work. A transaction must
either be fully completed or fully rolled back to maintain data integrity.

Properties of a Transaction (ACID):

1. Atomicity:
- Definition: Ensures that a transaction is an indivisible unit of work. Either all
operations within the transaction are completed successfully, or none are
applied.
- Example: In a bank transfer, both the debit from one account and the credit to
another must succeed or fail together.

2. Consistency:
- Definition: Ensures that a transaction brings the database from one consistent
state to another. The database must adhere to all predefined rules and
constraints.
- Example: After a successful bank transfer, the total amount of money in the
system remains the same, preserving financial consistency.
3. Isolation:
- Definition: Ensures that transactions executed concurrently do not affect each
other. Each transaction should be executed as if it were the only transaction in the
system.
- Example: If two transactions are transferring money between accounts
simultaneously, the system should handle them without causing data
inconsistencies.

4. Durability:
- Definition: Ensures that once a transaction is committed, its changes are
permanent, even in the case of system failures.
- Example: After a successful bank transfer, the updated account balances
must be preserved even if the system crashes immediately afterward.

### Transaction Processing Phases

1. Begin Transaction:
- The start of a transaction is marked, indicating the beginning of a unit of work.

2. Execute Operations:
- Operations such as insertions, updates, or deletions are performed within the
transaction.

3. Commit Transaction:
- If all operations are successfully executed and validated, the transaction is
committed, making all changes permanent.

4. Rollback Transaction:
- If any operation fails or an error occurs, the transaction is rolled back to its
initial state, undoing all changes to maintain consistency.
### Transaction Management Techniques
1. Locking:
- Definition: Mechanism to control access to data items to prevent conflicts in
concurrent transactions.
- Types:
- Exclusive Locks: Prevents other transactions from accessing the locked data.
- Shared Locks: Allows other transactions to read but not modify the data.

2. Concurrency Control:
- Definition: Techniques used to manage the execution of concurrent
transactions to ensure isolation and avoid anomalies.
- Techniques:
- Two-Phase Locking (2PL): Ensures transactions acquire locks in a way that
avoids conflicts.
- Optimistic Concurrency Control: Allows transactions to execute without
immediate locking but validates before committing.

3. Transaction Logs:
- Definition: Records of all transactions and their operations, used to ensure
durability and support recovery in case of failures.
- Example: A transaction log stores information about all changes made during
a transaction, which can be used to redo or undo changes if needed.
4. Recovery Techniques:
- Definition: Methods used to restore the database to a consistent state after a
failure.
- Techniques:
- Checkpointing: Periodically saving the state of the database to reduce
recovery time.
- Redo/Undo Operations: Applying or reversing changes recorded in
transaction logs to restore consistency.
### Example Scenario
Consider an online banking application where a customer transfers money from
their savings account to their checking account.

- Begin Transaction: The transfer process starts.

- Execute Operations:
1. Debit the savings account.
2. Credit the checking account.
- Commit Transaction: If both operations succeed, the transaction is committed.
- Rollback Transaction: If any operation fails (e.g., insufficient funds), the
transaction is rolled back, and no changes are applied.

By ensuring that transactions adhere to the ACID properties and using appropriate
transaction management techniques, a DBMS can maintain the reliability and
consistency of data even in complex and concurrent environments.

### Summary
- Transaction: A sequence of operations executed as a single unit.
- ACID Properties: Atomicity, Consistency, Isolation, Durability.
- Transaction Processing Phases: Begin, Execute, Commit, Rollback.
- Management Techniques: Locking, Concurrency Control, Transaction Logs,
Recovery Techniques.

Transaction processing is fundamental for maintaining data integrity and

consistency in database systems, ensuring reliable and accurate data
management.
### Joins in SQL
Joins are used in SQL to combine rows from two or more tables based on a
related column between them. They are essential for retrieving data from multiple
tables in a single query.
### Types of Joins
1. INNER JOIN

- Definition: Returns rows when there is a match between columns in both

tables involved in the join. Only the rows with matching values in both tables are
included in the result set.

This query retrieves employee IDs and names along with their department names
where there is a matching department ID in both tables.
2. LEFT JOIN (or LEFT OUTER JOIN)
Definition: Returns all rows from the left table and the matched rows from the
right table. If there is no match, the result is NULL for columns from the right
table.

This query retrieves all employees and their department names, including those
employees who do not belong to any department (with NULL for department
names).

3. RIGHT JOIN (or RIGHT OUTER JOIN)

- Definition: Returns all rows from the right table and the matched rows from
the left table. If there is no match, the result is NULL for columns from the left
table.
 This query retrieves all departments and their employees, including
departments that have no employees (with NULL for employee details).

4. FULL OUTER JOIN

Definition: Returns all rows when there is a match in one of the tables. It
combines the results of both LEFT JOIN and RIGHT JOIN, with NULLs in places
where there is no match.
This query retrieves all employees and all departments, including employees who
are not in any department and departments that have no employees (with NULLs
where there are no matches).

### Using Aliases in Joins

Aliases are used to create temporary names for tables or columns in SQL queries,
which can simplify complex queries and improve readability.
Definition: An alias is a temporary name given to a table or column in a SQL
query.
### Summary
• INNER JOIN: Returns only matching rows between tables.
• LEFT JOIN: Returns all rows from the left table and matching rows from the
right table.
• RIGHT JOIN: Returns all rows from the right table and matching rows from
the left table.
• FULL OUTER JOIN: Returns all rows when there is a match in either table.
• Aliases: Simplify and improve readability of SQL queries by providing
temporary names for tables or columns.

Joins and aliases are powerful tools in SQL for combining and simplifying data
retrieval from multiple tables.
Advanced SQL
#### Subqueries and Nested Queries
Subqueries:
A subquery is a query nested inside another query. It can be used in `SELECT`,
`INSERT`, `UPDATE`, and `DELETE` statements to provide results for the outer
query.
Types of Subqueries:
#### GROUP BY and HAVING
#### Aggregate Functions
Quick Revision in Short
Here's a quick revision guide covering the key concepts for each of the topics:
### 1. Data Models
Relational Data Model:
- Definition: Represents data in tables (relations) with rows and columns.
- Key Concepts: Tables, rows, columns, primary keys, foreign keys.
- Example: An `Employees` table with columns for `EmployeeID`,
`EmployeeName`, `DeptID`.

ER Data Model:
- Definition: Uses entities and relationships to represent data.
- Key Concepts: Entities, attributes, relationships, ER diagrams.
- Example: An `Employee` entity with attributes like `EmployeeID` and
`EmployeeName`, related to a `Department` entity.

Object-Based Data Model:

- Definition: Represents data as objects, similar to object-oriented programming.
- Key Concepts: Classes, objects, inheritance.
- Example: An `Employee` class with methods and attributes.

Semi-Structured Data Model:

- Definition: Represents data without a fixed schema, often used in XML/JSON.
- Key Concepts: Tags, attributes, nested structures.
- Example: JSON object representing employee details.
### 2. DBMS Architecture and Components

1-Tier Architecture:
- Definition: Database and application reside on the same machine.
- Use Case: Single-user applications.

2-Tier Architecture:
- Definition: Client and database server are separate, connected directly.
- Use Case: Desktop applications with a centralized database.

3-Tier Architecture:
- Definition: Includes a client, application server, and database server.
- Use Case: Web applications with scalability and separation of concerns.

Components:
- Database Engine: Handles data storage and retrieval.
- Database Schema: Defines database structure.
- Query Processor: Executes SQL queries.
- Transaction Manager: Manages database transactions.

### 3. SQL Queries

Basic Queries:
- SELECT: Retrieve data.
```sql
SELECT column1, column2 FROM table_name;
```
Filtering and Sorting:
- WHERE: Filter records.
```sql
SELECT * FROM table_name WHERE condition;
```
- ORDER BY: Sort results.
```sql
SELECT * FROM table_name ORDER BY column_name;
```

Aggregation:
- COUNT, SUM, AVG, MAX, MIN: Perform calculations.
```sql
SELECT COUNT(*) FROM table_name;
```

### 4. ER Diagrams
Components:
- Entities: Objects or things in the database.
- Attributes: Properties of entities.
- Relationships: Associations between entities.
- Cardinality: Specifies the number of instances.

Example:
- Entity: `Employee`
- Attributes: `EmployeeID`, `Name`, `DeptID`
- Relationship: `Works_In` between `Employee` and `Department`

### 5. Normal Forms

1NF (First Normal Form):

- Definition: Ensure that all columns contain atomic values.
- Example: No repeating groups in rows.

2NF (Second Normal Form):

- Definition: Achieve 1NF and remove partial dependencies.
- Example: No partial dependencies on a composite key.

3NF (Third Normal Form):

- Definition: Achieve 2NF and remove transitive dependencies.
- Example: No non-key attributes dependent on other non-key attributes.

Boyce-Codd Normal Form (BCNF):

- Definition: Achieve 3NF and ensure every determinant is a candidate key.

### 6. Joins

INNER JOIN:
- Definition: Returns rows with matching values in both tables.
- Example:
```sql
SELECT * FROM table1 INNER JOIN table2 ON table1.id = table2.id;
```

LEFT JOIN:
- Definition: Returns all rows from the left table and matched rows from the right
table.
- Example:
```sql
SELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id;
```

RIGHT JOIN:
- Definition: Returns all rows from the right table and matched rows from the left
table.
- Example:
```sql
SELECT * FROM table1 RIGHT JOIN table2 ON table1.id = table2.id;
```

FULL OUTER JOIN:

- Definition: Returns all rows when there is a match in one of the tables.
- Example:
```sql
SELECT * FROM table1 FULL OUTER JOIN table2 ON table1.id = table2.id;
```

### 7. Keys
Primary Key:
- Definition: Unique identifier for a record in a table.
- Example:
```sql
CREATE TABLE table_name (
id INT PRIMARY KEY,
name VARCHAR(100)
);
```

Foreign Key:
- Definition: A key used to link two tables together.
- Example:
```sql
ALTER TABLE table1
ADD CONSTRAINT fk_table2
FOREIGN KEY (table2_id)
REFERENCES table2(id);
```

Unique Key:
- Definition: Ensures all values in a column are unique.
- Example:
```sql
ALTER TABLE table_name
ADD CONSTRAINT unique_column UNIQUE (column_name);
```

### 8. Constraints

NOT NULL:
- Definition: Ensures that a column cannot have NULL values.
- Example:
```sql
CREATE TABLE table_name (
column_name INT NOT NULL
);
```

CHECK:
- Definition: Ensures that all values in a column satisfy a specific condition.
- Example:
```sql
CREATE TABLE table_name (
age INT CHECK (age >= 18)
);
```

DEFAULT:
- Definition: Provides a default value for a column.
- Example:
```sql
CREATE TABLE table_name (
status VARCHAR(10) DEFAULT 'active'
);
```

### 9. Transactions and Concurrency Control

Transactions:
- Definition: A sequence of operations performed as a single unit of work.
- Commands: `BEGIN`, `COMMIT`, `ROLLBACK`.
- Example:
```sql
BEGIN;
UPDATE table_name SET column_name = value;
COMMIT;
```

Concurrency Control:
- Definition: Manages simultaneous transactions to ensure data consistency.
- Techniques:
- Locking: Prevents other transactions from accessing the same data.
- Isolation Levels: Defines the visibility of changes made by a transaction.

### 10. Query Optimization

Indexing:
- Definition: Creates a data structure to improve query performance.
- Types: Primary index, secondary index.
- Example:
```sql
CREATE INDEX idx_name ON table_name (column_name);
```

Optimization Techniques:
- Use of Indexes: Index columns frequently used in queries.
- Avoiding Subqueries: Use joins where possible.
- Analyzing Query Execution Plans: Use tools like `EXPLAIN`.

### 11. Integrity Rules

Entity Integrity:
- Definition: Ensures that each table has a primary key and that the key is unique
and not NULL.

Referential Integrity:
- Definition: Ensures that foreign key values in a table match primary key values
in another table.

Domain Integrity:
- Definition: Ensures that values in a column fall within a specified range or set of
values.
User-Defined Integrity:
- Definition: Business rules that define constraints beyond standard integrity
rules.

---

This guide provides a brief overview of the essential concepts and SQL syntax for
each topic.