SQL(Structured Query Language) is a standard language for storing,

manipulating and retrieving data in databases.

-> DDL (Data Definition Language)

-> DML (Data Manipulation Language)

-> TCL (Transaction Control Language)

-> DCL (Data Control Language)

-> SQL Query Concepts

-> Indexing

-> Constraints

Data Definition Language (DDL) in SQL

Data Definition Language (DDL) commands are a subset of SQL commands used to define,
modify, and manage the structure of database objects. Unlike DML (Data Manipulation
Language) commands, DDL commands do not manipulate the data within the database
but rather focus on the schema. The key DDL commands include CREATE, ALTER, DROP,
TRUNCATE, RENAME, and COMMENT.
1. CREATE Command

The CREATE command is used to create new objects in the database, such as databases,
tables, indexes, views, and more. This command defines the schema for new database
objects.

Usage and Syntax

Create Database: Creates a new database.

Create Table: Defines a new table with specified columns and their data types,
constraints, etc.

Create Index: Creates an index on a table, which improves the speed of data
retrieval.
 Create View: Creates a virtual table (view) based on the result set of a query.

Show Databases/tables: Shows the databases and tables which we created as a

schematic outine. (With or without data)
2. ALTER Command

The ALTER command modifies the structure of an existing database object, such as adding
or dropping columns from a table, changing data types, renaming columns, etc.

Usage and Syntax

Add Column: Adds a new column to an existing table.

Drop Column: Removes a column from a table.

Modify Column: Changes the data type or other attributes of an existing column.
Rename Table: Changes the name of a table.

EXEC sp_rename 'Customers', 'Clients';

Considerations

• Altering a table's structure might require permissions and could affect application
functionality if not handled properly.
• Dropping a column will remove all data in that column, and this action is
irreversible.

Data Control Language (DCL) in SQL is used to control access to data in a database. DCL
commands primarily deal with rights, permissions, and other controls of the database
system. They are crucial for managing security, ensuring that only authorized users can
access or manipulate the data within a database. The two primary DCL commands are
GRANT and REVOKE.
Data Control Language (DCL) in SQL

DCL commands are essential for managing database security by defining who can do what
in the database environment. These commands help database administrators (DBAs)
assign or remove privileges on database objects like tables, views, and procedures to
users or roles.

1. GRANT Command

The GRANT command is used to provide users with access privileges to the database
objects. This command allows you to specify what actions a user or role can perform on
database objects.

Usage and Syntax

• Basic Syntax:

GRANT privilege_type ON object_name TO user_or_role [WITH GRANT OPTION];

1. Granting Privileges to a User:

 Granting All Privileges on a Table, Granting Privileges with the Ability to Grant
Further, Granting Privileges to a Role:

Considerations

• Privileges Types: Common privilege types include SELECT, INSERT, UPDATE,

DELETE, EXECUTE (for procedures), and ALL PRIVILEGES.
• Scope of Privileges: Privileges can be granted on various objects such as tables,
views, procedures, and the entire database.
• WITH GRANT OPTION: Allows the grantee to further delegate the privileges to other
users or roles. This option should be used cautiously to avoid unauthorized privilege
escalation.
• Roles: Privileges can be granted to roles, which are then assigned to users,
simplifying the management of permissions for multiple users.
2. REVOKE Command

The REVOKE command is used to remove access rights or privileges that were previously
granted to users or roles. This command helps in maintaining and updating security by
ensuring that users no longer have access when they no longer need it.

Usage and Syntax

• Basic Syntax:

REVOKE privilege_type ON object_name FROM user_or_role;

Revoking Privileges from a User:

Revoking All Privileges on a Table, Revoking Privileges from a Role, Revoking System
Privileges Can also be done.

Considerations

• Cascading Effects: Revoking privileges from a user who has granted those
privileges to others (using WITH GRANT OPTION) can cause cascading revocations,
removing those privileges from subsequent grantees.
• System vs. Object Privileges: System privileges (like CREATE SESSION) control
user access to the database, whereas object privileges control access to specific
database objects.
• Effect on Roles: Revoking a privilege from a role removes that access for all users
who have been assigned that role.

Key Concepts in DCL

1. Privileges:
o System Privileges: Allow users to perform administrative actions such as
creating tables, views, or managing sessions.
o Object Privileges: Allow users to perform actions on specific database
objects like tables, views, or stored procedures.
2. Roles:
 o Roles are named groups of related privileges that can be granted to users or
other roles. This simplifies the management of user permissions, especially
in large databases.
o Roles can be created, altered, and dropped using CREATE ROLE, ALTER
ROLE, and DROP ROLE commands.

Example of Role Creation:

CREATE ROLE manager_role;

GRANT SELECT, INSERT ON employees TO manager_role;

GRANT manager_role TO user1, user2;

3. Security Considerations:

• Use the principle of least privilege, granting users only the permissions they need to
perform their job functions.
• Regularly audit privileges and roles to ensure that users do not have unnecessary or
outdated permissions.
• Avoid using WITH GRANT OPTION unless absolutely necessary to minimize the risk
of privilege misuse or unauthorized access.

4. Audit and Compliance:

• Implement auditing to track GRANT and REVOKE commands, ensuring that changes
to permissions are logged for security and compliance purposes.
• Many databases offer built-in audit trails or allow triggers to be set up to monitor
DCL operations.

5. Grant and Revoke Best Practices:

• Always specify explicit privileges rather than using ALL PRIVILEGES, to avoid
granting unnecessary permissions.
 • Regularly review and clean up roles and privileges, especially when employees
change roles or leave the organization.
• Use roles to manage permissions for groups of users instead of assigning privileges
individually.

Transaction Control Language (TCL) in SQL is used to manage transactions in a

database. A transaction is a sequence of one or more SQL operations (such as INSERT,
UPDATE, or DELETE) that are executed as a single unit of work. Transactions are essential
for maintaining the integrity and consistency of data in a database, especially in multi-user
environments where simultaneous operations could potentially lead to conflicts or
inconsistencies.

TCL commands are used to ensure that transactions are processed reliably and that the
database remains in a consistent state even in the event of system failures or errors. The
primary TCL commands are COMMIT, ROLLBACK, SAVEPOINT, and SET TRANSACTION.

Transaction Control Language (TCL) in SQL

TCL commands allow you to control the execution of transactions, ensuring that either all
operations within a transaction are completed successfully or none are. This helps
maintain the ACID (Atomicity, Consistency, Isolation, Durability) properties of database
transactions.

1. COMMIT Command

The COMMIT command is used to save all changes made by the current transaction to the
database permanently. Once a transaction is committed, the changes cannot be undone.

Usage and Syntax

• Basic Syntax:

COMMIT;
Considerations

• Permanent Changes: Once COMMIT is executed, changes are saved permanently,

and the transaction cannot be rolled back.
• Concurrency Control: Committing a transaction releases any locks held by the
transaction, allowing other transactions to access the changed data.
• Implicit Commit: Certain SQL operations (like DDL commands CREATE, ALTER,
DROP) automatically commit transactions.

2. ROLLBACK Command

The ROLLBACK command is used to undo changes made by the current transaction,
reverting the database to its previous state. This command is crucial for error recovery,
allowing you to discard partial changes in the event of an error or a specific condition.

Usage and Syntax

• Basic Syntax:

ROLLBACK;
Considerations

• Partial Rollback: A ROLLBACK reverts the entire transaction unless SAVEPOINTS are
used (described below).
• Error Handling: Commonly used in exception handling blocks within stored
procedures or scripts to maintain data integrity in case of errors.

3. SAVEPOINT Command

The SAVEPOINT command sets a point within a transaction to which you can later roll
back. This allows partial rollbacks within a transaction, giving more control over which
changes to discard without affecting the entire transaction.

Usage and Syntax

• Basic Syntax:

SAVEPOINT savepoint_name;

Rolling Back to a Savepoint:

ROLLBACK TO savepoint_name;

Considerations

• Multiple Savepoints: You can create multiple savepoints within a transaction and
roll back to any of them as needed.
 • Releasing Savepoints: Some database systems allow you to release savepoints to
free resources, though not all support this feature.
• Scope: Savepoints are only valid within the current transaction; committing or
rolling back the entire transaction will release all savepoints.

4. SET TRANSACTION Command

The SET TRANSACTION command is used to define the properties of the current
transaction, such as isolation level, access mode (read-only or read-write), and other
parameters that control transaction behavior.

Usage and Syntax

• Basic Syntax:

SET TRANSACTION [READ ONLY | READ WRITE];

SET TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ

COMMITTED | REPEATABLE READ | SERIALIZABLE};

SET TRANSACTION in SQL

The SET TRANSACTION command in SQL is used to define the properties of the current
transaction in terms of isolation level and access mode. It allows you to control how your
transaction behaves when interacting with the database, which can help manage
concurrency and consistency of data.

Key Concepts of SET TRANSACTION

2. Isolation Levels: Isolation levels define the degree to which the operations in
one transaction are isolated from the operations in other transactions. The most
common isolation levels are:
o READ UNCOMMITTED: Allows dirty reads; transactions can see uncommitted
changes made by other transactions.
o READ COMMITTED: Default level; transactions cannot read data that is being
modified by another transaction until the modification is committed.
o REPEATABLE READ: Ensures that if a row is read twice in the same
transaction, it will remain unchanged.
 o SERIALIZABLE: The highest level; transactions are completely isolated from
each other.
3. Access Modes:
o READ ONLY: Indicates that the transaction will not modify data in the
database.
o READ WRITE: The default mode; allows the transaction to perform both read
and write operations.

Considerations

• Isolation Levels: Control the visibility of changes made by other transactions.

Higher isolation levels (like SERIALIZABLE) provide more consistency but can
reduce concurrency and performance.
• Read-Only Transactions: Useful for reporting or analytics scenarios where data
consistency is important, and no modifications are required.
• Performance: Adjusting transaction settings can impact performance and
concurrency, so these settings should be chosen carefully based on the specific
use case.

ACID Properties of Transactions

To ensure reliable transactions, databases adhere to the ACID properties:

Atomicity: Ensures that all operations within a transaction are completed; if any
operation fails, the entire transaction is rolled back.

Consistency: Ensures that a transaction takes the database from one valid state to
another, maintaining all defined rules (like constraints).

Isolation: Ensures that the operations of one transaction are isolated from others,
preventing data inconsistency due to concurrent transactions.

Durability: Ensures that once a transaction is committed, its changes are

permanent, even in the event of a system failure.
Transaction Control Best Practices

• Keep Transactions Short: Long-running transactions can lead to locks that block
other users, degrading performance.
• Proper Error Handling: Use TRY...CATCH blocks (or equivalent mechanisms) to
catch errors and perform appropriate rollbacks to maintain data integrity.
• Consistent Use of Savepoints: Savepoints can provide a fine-grained control over
rollbacks, but overuse can lead to complexity.
• Choose the Right Isolation Level: Balance between data consistency and system
performance; higher isolation levels reduce concurrency.
• Monitor and Log Transactions: Keep track of transaction performance and failures
to identify potential issues and optimize system performance.

Summary

TCL commands (COMMIT, ROLLBACK, SAVEPOINT, and SET TRANSACTION) are essential
tools for managing transactions in SQL databases. They provide mechanisms to ensure
that changes to data are executed reliably and consistently, maintaining the integrity of the
database. By understanding and effectively using TCL commands, database
administrators and developers can control transaction behavior, handle errors gracefully,
and optimize database performance in multi-user environments.
3. DROP Command

The DROP command is used to delete existing database objects, such as tables, views,
indexes, or databases. This command removes the object and its data permanently.

Usage and Syntax

• Drop Database: Deletes a database and all its objects.

• Drop Table: Deletes a table and all of its data.
• Drop Index: Removes an index from a table.
• Drop View: Deletes a view from the database.

Considerations

• The DROP command is irreversible and will permanently delete the object along with
its data.
• It is advisable to back up data before dropping tables or databases.
4. TRUNCATE Command

The TRUNCATE command removes all rows from a table without logging individual row
deletions, making it faster than the DELETE command. It retains the table structure for
future use.
Considerations

• Unlike DROP, TRUNCATE does not remove the table itself; it only removes data.
• TRUNCATE cannot be rolled back if used within a transaction in some databases.
 • It is typically faster and uses fewer system resources compared to the DELETE
command.

5. RENAME Command

The RENAME command changes the name of existing database objects like tables. This
command is particularly useful for correcting naming conventions or reorganizing
database structures.

Considerations

• Renaming tables or other objects can affect existing queries, stored procedures, or
applications that reference the old name.
• Permissions to rename objects are required.
6. COMMENT Command

The COMMENT command is used to add or modify comments on database objects.

Comments help document the purpose and details of tables, columns, indexes, and other
objects, improving readability and maintainability.

Usage and Syntax

• Add a Comment to a Table:

• Add a Comment to a Column:

Considerations

• Comments do not affect the functionality of the database but are important for
documentation and understanding the schema.
• They can be viewed through database management tools or queries.

Key Points to Remember

• Transaction Handling: DDL commands generally cause an implicit commit of the

current transaction. Once a DDL command is executed, it cannot be rolled back.
• Performance: Operations like CREATE and ALTER may lock the table or database
structure, affecting performance temporarily during execution.
• Security: Permissions are required to execute DDL commands. Unauthorized
changes to the schema can lead to security vulnerabilities or data loss.
• Best Practices: Always back up the database before making structural changes
with DDL commands. Test changes in a development environment before applying
them to production.
Data Manipulation Language (DML) commands in SQL are used to interact with the data
within database objects. Unlike DDL commands, which manage the structure and schema
of database objects, DML commands are focused on manipulating the data itself—adding,
modifying, deleting, and retrieving records from tables. Below is an in-depth explanation of
the primary DML commands: SELECT, INSERT, UPDATE, and DELETE.

Data Manipulation Language (DML) in SQL

DML is a subset of SQL used for managing data within the tables of a database. These
commands enable users to perform operations on the data, ensuring that it can be
effectively utilized, analyzed, and maintained. The primary DML commands are:

1. SELECT Command

The SELECT command is used to query and retrieve data from one or more tables. It is the
most commonly used DML command and provides extensive functionality for filtering,
sorting, grouping, and aggregating data.

Usage and Syntax

• Basic Syntax:

SELECT column1, column2, ...

FROM table_name

WHERE condition;

Selecting All Columns: Select * From Table_Name

Filtering Rows with WHERE Clause:

Sorting Results with ORDER BY:

Grouping Data with GROUP BY and Aggregating with Functions:

Having clause:
Between Clause:

Considerations

• Use the WHERE clause to filter rows based on specific conditions.

• Functions like SUM(), AVG(), COUNT(), MIN(), and MAX() are used for aggregation.
• Use aliases (AS) to rename columns or tables for clarity in output.
 • Joins (INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL JOIN) are used to combine
data from multiple tables based on a related column.

2. INSERT Command

The INSERT command is used to add new rows of data into a table. It allows inserting
values directly into all or specified columns.

Usage and Syntax

• Basic Syntax:

INSERT INTO table_name (column1, column2, ...)

VALUES (value1, value2, ...);

Inserting into All Columns:

Inserting into Specific Columns:
Inserting Multiple Rows:

Considerations
• Ensure that data types match the column definitions in the table.
 • Primary keys must be unique; inserting duplicate values into a primary key column
will result in an error.
• When inserting values into all columns, the order of the values must match the
table’s column order.
• Use DEFAULT keyword to insert default values specified in table schema.

3. UPDATE Command

The UPDATE command is used to modify existing records in a table. This command can
update one or more rows and one or more columns based on specified conditions.

Usage and Syntax

• Basic Syntax:
UPDATE table_name

SET column1 = value1, column2 = value2, ...

WHERE condition;

Updating a Single Row:

Updating Multiple Rows:

Updating Based on Another Table:
Considerations

• The WHERE clause is crucial in the UPDATE statement to specify which rows should
be modified; omitting it will update all rows in the table.
• Use subqueries in the SET clause to update values based on data from other tables.
• Care should be taken to avoid unintentional updates, as these can affect multiple
rows if not properly filtered.

4. DELETE Command

The DELETE command is used to remove one or more rows from a table based on
conditions specified in the WHERE clause.

Usage and Syntax

• Basic Syntax:

DELETE FROM table_name

WHERE condition;

Deleting Specific Rows:

 We can also delete alll Rows without dropping the table.

Deleting Rows Based on a Subquery:

Considerations

• The WHERE clause specifies which rows to delete; omitting it will remove all rows
from the table.
• Deleting rows is a permanent operation and cannot be undone unless wrapped in a
transaction with rollback capabilities.
• Foreign key constraints may prevent deletion if related records exist in other tables.

Key Points to Remember

• Transaction Control: DML commands are often used within transactions (BEGIN,
COMMIT, ROLLBACK) to ensure data integrity. This allows for grouping multiple
operations into a single transaction, which can be rolled back if an error occurs.
• Performance Considerations: Large-scale INSERT, UPDATE, or DELETE operations
can impact performance. Techniques such as indexing, batching, and using the
WHERE clause effectively can help mitigate performance issues.
 • Error Handling: Use error handling mechanisms within your SQL environment (like
TRY...CATCH blocks in some RDBMS) to manage potential issues arising from DML
operations.
• Security: Permissions are required to perform DML operations. Ensuring proper
access controls helps prevent unauthorized data manipulation.
• ACID Properties: DML commands should adhere to ACID (Atomicity, Consistency,
Isolation, Durability) principles to ensure reliable transaction processing.
• Data Integrity: Use constraints (PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK) to
maintain data integrity and consistency when performing DML operations.

The MERGE command in SQL is a powerful DML operation that allows you to perform
INSERT, UPDATE, and DELETE actions in a single statement based on conditions. It is
commonly used to synchronize two tables by comparing their data and taking appropriate
actions (inserting new rows, updating existing ones, or deleting rows that are no longer
needed).

The MERGE statement is particularly useful for handling scenarios where you need to
update a target table with data from a source table while simultaneously managing records
that do not match between the tables.

MERGE Command in SQL

The MERGE command, also known as an "upsert" operation, merges data from a source
table into a target table based on a specified condition. It allows you to:
 • Insert new records into the target table if they do not exist.
• Update existing records in the target table if they match with records in the source
table.
• Delete records from the target table if they are no longer present in the source table
(optional).

Basic Syntax:

MERGE INTO target_table AS target

USING source_table AS source
ON target.matching_column = source.matching_column
WHEN MATCHED THEN
UPDATE SET target.column1 = source.column1, target.column2 =source.column2
WHEN NOT MATCHED THEN
INSERT (column1, column2, ...)
VALUES (source.column1, source.column2, ...);
• BookUpdates is a table with recent updates for books.
• If a book in BookUpdates matches a book in Books by BookID, we update the
existing record.
• If a book in BookUpdates does not exist in Books, we insert it.
• If a book exists in Books but not in BookUpdates, we delete it from Books.
Detailed Explanation of Clauses

1. MERGE INTO target_table: Specifies the target table into which data will be
merged.
2. USING source_table: Specifies the source table from which data will be merged
into the target table.
3. ON: Defines the condition for matching rows between the source and target tables
(e.g., a matching key or common column).
4. WHEN MATCHED: Specifies the action to take when rows from the source and target
tables match the condition. Typically used for updating records.
5. WHEN NOT MATCHED: Specifies the action to take when rows from the source table
do not match any rows in the target table. Typically used for inserting new records.
6. WHEN MATCHED AND (additional_condition) THEN DELETE: Optionally
specifies conditions under which matching rows should be deleted from the target
table.

Indexing in SQL

Indexing in SQL is a technique used to optimize the performance of database queries by

reducing the amount of time required to retrieve data. An index is a data structure that
allows the database to find and access rows in a table more quickly, much like an index in
a book helps you locate information faster.

Indexes are created on columns in a table and can greatly improve the speed of SELECT
queries that search, filter, or sort data. However, indexes also have some trade-offs, such
as increased storage requirements and slower INSERT, UPDATE, or DELETE operations
because the index must be updated each time the data changes.

Types of Indexes

1. Single-Column Index: An index created on a single column of a table.

2. Composite Index: An index created on two or more columns of a table.
 3. Unique Index: Ensures that all values in the indexed column are unique.
4. Full-Text Index: Optimizes text-based searches.
5. Clustered Index: Sorts and stores the data rows of the table based on the
indexed column (only one clustered index per table).
6. Non-Clustered Index: Contains a sorted list of values pointing to the physical
data rows (multiple non-clustered indexes are allowed per table).

Creating Indexes

1. CREATE INDEX

The CREATE INDEX statement is used to create a non-unique index on one or more
columns of a table. This type of index speeds up query performance but does not enforce
uniqueness.

Syntax:

CREATE INDEX index_name ON table_name (column1 [ASC|DESC], column2

[ASC|DESC], ...);

• index_name: The name of the index.

• table_name: The name of the table on which the index is created.
• column1, column2, ...: The columns on which the index is created.
• ASC or DESC: Specifies the sort order of the index (ascending or descending).
Considerations:

• Performance Improvement: Indexes can greatly improve the performance of

SELECT queries that filter, sort, or join on indexed columns.
• Maintenance Overhead: Indexes need to be updated whenever data is modified
(inserted, updated, or deleted), which can impact performance.
• Storage: Indexes require additional disk space.

2. CREATE UNIQUE INDEX

The CREATE UNIQUE INDEX statement creates an index that enforces the uniqueness of
the indexed columns. This means that no two rows can have the same value in the indexed
columns.

Syntax:

CREATE UNIQUE INDEX index_name ON table_name (column1 [ASC|DESC],

column2 [ASC|DESC], ...);
This syntax is similar to CREATE INDEX, with the addition of the UNIQUE keyword to enforce
unique values in the indexed columns.

-- Create a unique index on the combination of ArtistID and AlbumID

CREATE UNIQUE INDEX idx_ArtistAlbumUnique
ON Songs (ArtistID, AlbumID);

Explanation:

• The CREATE UNIQUE INDEX statement creates an index named

idx_ArtistAlbumUnique on the combination of ArtistID and AlbumID.
• This ensures that there are no duplicate entries for the same artist and album
combination, preventing the same song from being entered multiple times under
the same album for the same artist.

Considerations:

• Uniqueness Enforcement: Unique indexes prevent duplicate values in the indexed

columns, which is useful for enforcing data integrity.
• Error Handling: If you attempt to insert or update a row with a duplicate value in the
indexed columns, the database will raise an error.
• Performance Impact: Similar to regular indexes, unique indexes speed up queries
but can slow down data modification operations.

Benefits of Indexing

• Faster Query Execution: Indexes allow the database to locate and access data
without scanning the entire table, significantly speeding up queries.
• Efficient Sorting and Filtering: Indexes can optimize ORDER BY and WHERE clauses,
making sorting and filtering operations more efficient.
• Improved Join Performance: Indexes can speed up join operations by quickly
locating matching rows in related tables.
Drawbacks of Indexing

• Increased Storage Usage: Indexes require additional disk space to store the index
data.
• Slower Data Modification: INSERT, UPDATE, and DELETE operations can be slower
because the index must be updated each time the data changes.
• Complex Maintenance: Managing and maintaining indexes can add complexity to
database administration.

Best Practices for Indexing

1. Index Selective Columns: Index columns that are frequently used in WHERE,
ORDER BY, or JOIN clauses. Columns with high cardinality (many unique values)
benefit more from indexing.
2. Avoid Indexing Every Column: Over-indexing can lead to increased storage
requirements and slower data modification operations. Index only the
necessary columns.
3. Use Composite Indexes Wisely: Composite indexes can be useful for queries
that filter on multiple columns, but they should be carefully designed to match
the query patterns.
4. Monitor and Optimize Index Usage: Regularly review index performance and
usage. Remove or rebuild indexes that are not used or are fragmented.
5. Consider Index Maintenance: Plan for index maintenance tasks like rebuilding
or reorganizing indexes to keep them efficient.

Summary

Indexing is a powerful feature in SQL that can significantly improve the performance of
database queries by creating data structures that allow for faster data retrieval. The
CREATE INDEX and CREATE UNIQUE INDEX commands provide ways to create standard
and unique indexes on one or more columns of a table. While indexes can greatly speed up
data access, they also come with trade-offs, such as increased storage usage and
potential slowdowns in data modification operations. By understanding and applying
indexing best practices, you can effectively balance the performance benefits with the
maintenance overhead of indexes in your database.

Constraints in SQL are rules applied to columns in a table to enforce data integrity,
consistency, and accuracy. They ensure that the data in the database adheres to certain
criteria, which helps maintain the reliability and correctness of the database. Constraints
can be applied at the column level (to individual columns) or at the table level (affecting
multiple columns).

Types of Constraints in SQL

PRIMARY KEY Constraint

FOREIGN KEY Constraint
UNIQUE Constraint
NOT NULL Constraint
CHECK Constraint
DEFAULT Constraint

1. PRIMARY KEY Constraint

The PRIMARY KEY constraint uniquely identifies each record in a table. A table can have
only one primary key, which can consist of one or more columns (composite key). The
primary key enforces uniqueness and does not allow NULL values.

Usage and Syntax:

• Column Level:

CREATE TABLE employees (

employee_id INT PRIMARY KEY,
first_name VARCHAR(50),
last_name VARCHAR(50)
);
Considerations:

• Enforces uniqueness and disallows NULL values.

• A table can only have one primary key.
• Often used as a reference for foreign key constraints in other tables.

2. FOREIGN KEY Constraint

The FOREIGN KEY constraint establishes a relationship between two tables by linking the
foreign key in one table to the primary key in another. It ensures referential integrity by
enforcing that the foreign key value must exist in the referenced table.

Usage and Syntax:

• Column Level:

CREATE TABLE orders (

order_id INT PRIMARY KEY,
customer_id INT,
FOREIGN KEY (customer_id) REFERENCES customers(customer_id));
Considerations:

• Ensures that data in the foreign key column matches a value in the referenced
primary key column or is NULL.
• Enforces referential integrity, preventing orphan records.
• Can be defined with ON DELETE and ON UPDATE actions (CASCADE, SET NULL, NO
ACTION).

3. UNIQUE Constraint

The UNIQUE constraint ensures that all values in a column or a group of columns are
unique across the table. Unlike the primary key, a table can have multiple unique
constraints, and unique columns can accept NULL values.

Usage and Syntax:

• Column Level:

CREATE TABLE employees (

employee_id INT PRIMARY KEY,
email VARCHAR(100) UNIQUE
);
Considerations:

• Allows NULL values unless otherwise specified.

• Multiple unique constraints can exist on a table.
• Ensures data uniqueness across rows.

4. NOT NULL Constraint

The NOT NULL constraint ensures that a column cannot contain NULL values. It is used to
enforce that all rows must have a value for that column.

Usage and Syntax:

• Column Level:

CREATE TABLE employees (

employee_id INT PRIMARY KEY,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL);
Considerations:

• Ensures that a column always has a value.

• Prevents insertion of NULL values in the specified column.
• Commonly used with primary and foreign keys.

5. CHECK Constraint

The CHECK constraint ensures that all values in a column satisfy a specific condition. This
constraint is used to enforce domain integrity by limiting the values that can be placed in a
column.

Usage and Syntax:

• Column Level:

CREATE TABLE employees (

 employee_id INT PRIMARY KEY,

salary DECIMAL(10, 2) CHECK (salary > 0));

Considerations:

• Ensures data validity according to specific business rules.

• Can reference multiple columns if defined at the table level.
• The condition must evaluate to TRUE for all rows.
6. DEFAULT Constraint

The DEFAULT constraint sets a default value for a column when no value is specified during
the INSERT operation. This ensures that a column always has a value, even if the user does
not provide one.

Usage and Syntax:

• Column Level:

CREATE TABLE employees (

employee_id INT PRIMARY KEY,
hire_date DATE DEFAULT CURRENT_DATE,
status VARCHAR(10) DEFAULT 'Active');
Considerations:

• Automatically assigns a default value if no value is specified.

• Ensures columns have sensible defaults without explicit user input.
• Useful for columns like timestamps, statuses, or counters.

Benefits of Constraints

• Data Integrity: Constraints enforce rules that ensure the validity and consistency of
the data in the database.
• Error Prevention: By enforcing rules like uniqueness or non-nullability, constraints
help prevent errors and invalid data entry.
• Data Relationships: Foreign key constraints maintain referential integrity, ensuring
relationships between tables are respected.
• Simplified Application Logic: By embedding rules within the database, constraints
reduce the need for validation logic in application code.

Considerations and Best Practices

Use Constraints to Enforce Business Rules: Constraints are powerful tools for
enforcing business rules at the database level, ensuring data integrity regardless of
the application layer.
 Balance Between Flexibility and Strictness: While constraints help maintain data
integrity, overly restrictive constraints can make data management difficult. Use
constraints thoughtfully to balance flexibility and strictness.

Regularly Review and Update Constraints: As business requirements evolve,

constraints may need to be updated to reflect new rules or remove outdated ones.

Combine Constraints for Maximum Effectiveness: Use a combination of

constraints (e.g., NOT NULL, UNIQUE, CHECK) to enforce comprehensive data
validation rules.

Joins in SQL:
1. Inner Join
2. Left Outer join
3. Right outer join
4. Full Outer join
5. Self Join
6. Natural Join
7. Cross Join

Let me use a Music streaming service use case as an example for explaining Joins
concept.
1. INNER JOIN

Description: Retrieves records that have matching values in both tables.

Use Case: When you want to fetch rows that have corresponding data in both table

Output: Displays song names, album names, artist names, duration, and genre for songs
with matching albums and artists.
2. LEFT JOIN (or LEFT OUTER JOIN)

Description: Retrieves all records from the left table and the matched records from the
right table. If there is no match, the result is NULL on the side of the right table.

Use Case: When you want to get all records from the left table and include matching
records from the right table, if they exist.

Output: Displays all albums and the songs within them. Albums without songs will show
NULL for the SongName.

3. RIGHT JOIN (or RIGHT OUTER JOIN)

Description: Retrieves all records from the right table and the matched records from the
left table. If there is no match, the result is NULL on the side of the left table.

Use Case: When you want to get all records from the right table and include matching
records from the left table, if they exist.
Output: Displays all songs and the albums they belong to. Songs without albums will show
NULL for the AlbumName.

4. FULL OUTER JOIN

Description: Retrieves records when there is a match in either left or right table. If there is
no match, the result is NULL for the non-matching side.

Use Case: When you want to get all records from both tables, showing NULL where there is
no match.
Output: Displays all albums and all songs, including albums without songs and songs
without albums.

5. CROSS JOIN

Description: Retrieves the Cartesian product of the two tables, i.e., every row from the first
table is combined with every row from the second table.

Use Case: When you need to combine every row of one table with every row of another
table. This is less common but can be useful in specific scenarios.
Output: Displays all albums and all songs, including albums without songs and songs
without albums.

6. SELF JOIN

Description: Joins a table with itself. It’s useful for finding relationships within the same
table.

Use Case: When you need to compare rows within the same table or find hierarchical
data.

A Self Join is a regular join but applied to the same table. It’s useful for comparing rows
within the same table or finding relationships between rows.

Self Join Example

In the context of the MusicDB database, let's say we want to find albums by the same
artist. Although this example might not be necessary for Albums, it will demonstrate the
concept. grSuppose we have a scenario where we need to find albums that have the same
artist. We can use a self join on the Albums table to achieve this.
SQL Server does not support NATURAL JOIN directly, but
the concept can be simulated using an INNER JOIN
based on columns with the same name.

The UNION operator in SQL is used to combine the result sets of two or more
SELECT queries into a single result set. The combined result set will contain
distinct rows, which means duplicates are removed by default. This operator
is particularly useful when you need to merge similar data from different
tables or queries.

Here are the key concepts and types of UNION operations in SQL:

1. UNION

• Purpose: Combines the result sets of two or more SELECT statements

and removes duplicate rows from the final result.
• Requirements:
o Each SELECT statement within the UNION must have the same
number of columns.
o The columns must have compatible data types.
o The order of columns should match.
Union – Check for duplicates
Union ALL – Doesnt check for duplicates