MySQL Database Terminology

One of the freely available, reliable and popular databases is MySQL and we will be studying more about same in this
series.

Before we proceed to explain the MySQL database system, let us have a look at few definitions related to the
database which are in general applicable to any other relational databases as well.

1. Database - A database is a collection of tables, with related data.

2. Table - A table is a matrix with data. A table in a database looks like a simple spreadsheet.

3. Column - One column (data element) contains data of one and the same kind, for example, the column
postcode.

4. Row - A row (= tuple, entry or record) is a group of related data, for example, the data of one subscription.

5. Redundancy - Storing data twice in more than one tables, redundantly to make the system faster.

6. Primary Key - A primary key is unique. A key value can not occur twice in one table. With a key, you can only
find one row. A table will have only one Primary Key

7. Unique Key - A unique key is a combination of one or more columns which can uniquely identify a row in the
table. That combination cannot occur more than once in one table excluding rows having NULL values in key
columns. A table can have more than one unique key.

8. Compound Key - A compound key (composite key) is a key that consists of multiple columns because one
column is not sufficiently unique. Another term for the unique key which has more than one column.

9. Foreign Key - A foreign key is a linking pin between two tables.

10. Index - An index in a database resembles an index at the back of a book.

11. Referential Integrity - Referential Integrity makes sure that a foreign key value always points to an existing
row.

Unit III Notes: Database Management

Here’s a comprehensive overview of the key concepts covered in the CBSE Class 12th CS Unit 3 notes:

 Database concepts: introduction to database concepts and its need

 Relational data model: relation, attribute, tuple, domain, degree, cardinality, keys (candidate key, primary
key, alternate key, foreign key)

 Structured Query Language: introduction, Data Definition Language and Data Manipulation Language, data
type (char(n), varchar(n), int, float, date), constraints (not null, unique, primary key), create database, use
database, show databases, drop database, show tables, create table, describe table, alter table (add and
remove an attribute, add and remove primary key), drop table, insert, delete, select, operators
(mathematical, relational and logical), aliasing, distinct clause, where clause, in, between, order by, meaning
of null, is null, is not null, like, update command, delete command, aggregate functions (max, min, avg, sum,
count), group by, having clause, joins: cartesian product on two tables, equi-join and natural join

 Interface of python with an SQL database: connecting SQL with Python, performing insert, update, delete
queries using cursor, display data by using connect(), cursor(), execute(), commit(), fetchone(), fetchall(),
rowcount, creating database connectivity applications, use of %s format specifier or format() to perform
queries.

Table of Content

 Database Concepts

 Relational Data Model

  Keys (candidate key, primary key, alternate key, foreign key)

 Structured Query Language

 Interface of Python with an SQL Database

 CBSE Class 12th Computer Science Unit III Notes: Marks Distribution

Database Concepts

Introduction to Database Concepts and Their Need

Databases are essential components of modern computing that store, manage, and retrieve data efficiently. Here’s
an overview of what databases are, their key concepts, and why they are important.

What is a Database?

Definition: A database is an organized collection of data stored electronically. It allows for easy access, management,
and updating of data. Databases can range from simple lists to complex systems handling large volumes of
information.

Components:

 Tables: The basic building blocks where data is stored. Each table consists of rows (records) and columns
(fields).

 Records: Individual entries in a table, representing a specific data instance (e.g., a single customer’s details).

 Fields: The columns in a table, defining the type of data stored (e.g., name, email, address).

Key Database Concepts

Database Management System (DBMS):

 Definition: Software that manages and controls access to databases. It allows users to create, update, and
query databases.

 Examples: MySQL, PostgreSQL, Oracle, Microsoft SQL Server.

Schema:

 Definition: The structure or blueprint of a database, defining how data is organized and how relationships
between data are handled. It includes definitions of tables, fields, and their relationships.

 Example: A schema might define tables for customers, orders, and products, and specify how these tables
are related.
Architecture of DBMS

Query Language:

 Definition: A language used to interact with a database, primarily to retrieve, update, or manipulate data.

 Examples: SQL (Structured Query Language) is the most common language used for querying databases.

Normalization:

 Definition: The process of organizing data in a database to reduce redundancy and improve data integrity. It
involves dividing large tables into smaller, related tables.

 Example: Separating customer information from order details to avoid duplication of customer data.

Indexing:

 Definition: A technique used to speed up data retrieval operations by creating indexes on database columns.

 Example: Creating an index on the “email” column in a customer table to quickly find records by email
address.

Need for Databases

Efficient Data Management:

 Need: Organizes large amounts of data systematically, making it easier to retrieve, update, and manage
information.
  Benefit: Reduces time and effort required to handle and process data.

Data Integrity:

 Need: Ensures that data is accurate, consistent, and reliable.

 Benefit: Minimizes errors and maintains the quality of data over time.

Data Security:

 Need: Protects sensitive data from unauthorized access and breaches.

 Benefit: Safeguards confidential information and complies with legal and regulatory requirements.

Concurrent Access:

 Need: Allows multiple users to access and work with the database simultaneously without conflicts.

 Benefit: Facilitates teamwork and collaboration in real-time.

Scalability:

 Need: Supports the growth of data and the increasing complexity of data management needs.

 Benefit: Ensures that the database can handle expanding amounts of information and user demands.

Relational Data Model

Relational Data Model

The relational data model is a way of structuring data using relations (tables). It is fundamental to relational
databases and organizes data into tables with rows and columns. Here’s a breakdown of key concepts in the
relational data model:

1. Relation

 Definition: A relation, or table, is a collection of tuples (rows) that share the same attributes (columns). It
represents a specific type of entity or relationship in the database.

 Example: A table called Students that includes information about students, where each row represents a
student.

2. Attribute

 Definition: An attribute is a column in a table that represents a specific property or characteristic of the
entity described by the table. Each attribute has a name and a data type.

 Example: In the Students table, attributes might include StudentID, Name, and DateOfBirth.

3. Tuple

 Definition: A tuple is a single row in a table. It represents a specific instance of the entity or relationship
described by the table.

 Example: In the Students table, a tuple might be (123, ‘Alice Smith’, ‘2005-05-15’), representing a specific
student.
Relational Data Model

4. Domain

 Definition: A domain is the set of permissible values that an attribute can take. It defines the type of data
that can be stored in a column, such as integer, string, or date.

 Example: For the attribute DateOfBirth, the domain might be all valid date values.

5. Degree

 Definition: The degree of a relation (table) is the number of attributes (columns) it has. It indicates the
number of different pieces of information stored for each tuple.

 Example: If the Students table has three attributes (StudentID, Name, DateOfBirth), its degree is 3.

6. Cardinality

 Definition: The cardinality of a relation (table) is the number of tuples (rows) it contains. It represents the
size of the table and the number of instances of the entity.

 Example: If the Students table has 100 rows, its cardinality is 100.

Keys (candidate key, primary key, alternate key, foreign key)

Keys in Relational Databases

Keys are fundamental to relational databases as they uniquely identify rows within a table and establish relationships
between tables. Here’s an overview of different types of keys:

1. Candidate Key

Definition: A candidate key is an attribute or a set of attributes that can uniquely identify each tuple (row) in a table.
A table can have multiple candidate keys, but each one is a potential primary key.

Characteristics:

 Must be unique for each row.

 Cannot contain null values.

Example: In a Student table, StudentID and Email might both be candidate keys if each is unique for every student.

2. Primary Key

Definition: The primary key is a specific candidate key chosen to uniquely identify each tuple in a table. It ensures
that each row is unique and not null.

Characteristics:

 Uniquely identifies each record in the table.

 Cannot have null values.

 Each table can have only one primary key.

Example: In the Students table, StudentID might be selected as the primary key.

Relation between Primary Key, Candidate Key, and Super Key

3. Alternate Key

Definition: An alternate key is any candidate key that is not chosen as the primary key. It is still a unique identifier for
tuples but is not used as the main key for the table.

Characteristics:

 Each alternate key could potentially serve as a primary key.

 Used for ensuring uniqueness in case the primary key is not suitable.

Example: If StudentID is chosen as the primary key, then Email (if unique) becomes an alternate key.

4. Foreign Key

Definition: A foreign key is an attribute or a set of attributes in one table that refers to the primary key of another
table. It establishes and enforces a link between the data in the two tables.

Characteristics:

 Ensures referential integrity by enforcing that the value in the foreign key column matches a value in the
primary key column of the related table.

 Can contain duplicate values and nulls if allowed.

Example: In an Enrollments table, StudentID might be a foreign key that refers to the StudentID primary key in the
Students table.

Structured Query Language

Introduction to SQL

Structured Query Language (SQL) is a standardized programming language used for managing and manipulating
relational databases. SQL allows users to create, modify, and query databases effectively. It provides a way to interact
with data stored in relational database management systems (RDBMS).

 Purpose: SQL is designed to handle tasks such as querying data, updating records, and managing database
structures. It provides a straightforward syntax for interacting with relational databases.

 Components: SQL is divided into several categories based on the type of operations it supports.

Data Definition Language (DDL)

Data Definition Language (DDL) is a subset of SQL used for defining and managing database structures. It includes
commands that define, alter, and drop database objects such as tables, indexes, and schemas.

Common DDL Commands:

 CREATE: Used to create new database objects, such as tables, indexes, and views

o Example: CREATE TABLE Students (StudentID INT PRIMARY KEY, Name VARCHAR(50), DateOfBirth
DATE)

 ALTER: Used to modify existing database objects, such as adding or deleting columns in a table.

o Example: ALTER TABLE Students ADD Email VARCHAR(100)

 DROP: Used to delete database objects, such as tables or indexes.

o Example: DROP TABLE Students

 TRUNCATE: Used to remove all records from a table without deleting the table structure.

o Example: TRUNCATE TABLE Students;

Data Manipulation Language (DML)

Data Manipulation Language (DML) is a subset of SQL used for manipulating and querying the data stored in the
database. It includes commands to insert, update, delete, and retrieve data.

Common DML Commands:

 SELECT: Retrieves data from one or more tables. It can include conditions, sorting, and grouping

o Example: SELECT Name, DateOfBirth FROM Students WHERE StudentID = 1

 INSERT: Adds new records to a table.

o Example: INSERT INTO Students (StudentID, Name, DateOfBirth) VALUES (1, ‘Alice Smith’, ‘2005-05-
15’)

 UPDATE: Modifies existing records in a table.

o Example: UPDATE Students SET Email = ‘alice@example.com’ WHERE StudentID = 1

 DELETE: Removes records from a table based on specified conditions.

o Example: DELETE FROM Students WHERE StudentID = 1

Summary
  SQL: A language used to interact with relational databases, allowing for the creation, modification, and
querying of database structures and data.

 Data Definition Language (DDL): Includes commands for defining and managing database objects (CREATE,
ALTER, DROP, TRUNCATE).

 Data Manipulation Language (DML): Includes commands for manipulating and querying data (SELECT,
INSERT, UPDATE, DELETE).

Data Type (char(n), varchar(n), int, float, date), constraints (not null, unique, primary key)

SQL Data Types and Constraints

SQL data types define the kind of data that can be stored in a database column. Constraints are rules applied to
columns to ensure data integrity and enforce specific data conditions.

Data Types

CHAR(n)

 Definition: A fixed-length character string. If the data stored is shorter than n characters, it is padded with
spaces.

 Usage: Useful for storing data with a consistent length, such as country codes or status codes.

 Example: CHAR(10) will store exactly 10 characters; “ABC” becomes “ABC ” (with padding).

VARCHAR(n)

 Definition: A variable-length character string. Only the actual number of characters is stored, up to n
characters.

 Usage: Ideal for storing text data of varying lengths, such as names or addresses.

 Example: VARCHAR(50) will store up to 50 characters. “John” will use only 4 characters of space.

INT

 Definition: A whole number. It can store both positive and negative integers.

 Usage: Commonly used for numerical data like IDs or counts.

 Example: INT can store values like 1, -42, or 1000.

FLOAT

 Definition: A floating-point number, which can store decimal values. It’s used for precise calculations and
measurements.

 Usage: Suitable for storing values with decimals, such as prices or scientific measurements.

 Example: FLOAT can store values like 3.14 or -0.001.

DATE

 Definition: A date value in the format YYYY-MM-DD. It stores calendar dates.

 Usage: Used for storing dates of events, birthdays, or deadlines.

 Example: DATE can store values like 2024-08-01.

Constraints

Constraints are the rules that we can apply on the type of data in a table. That is, we can specify the limit on the type
of data that can be stored in a particular column in a table using constraints.
We can specify constraints at the time of creating the table using CREATE TABLE statement. We can also specify the
constraints after creating a table using ALTER TABLE statement.

Syntax:
Below is the syntax to create constraints using CREATE TABLE statement at the time of creating the table.

CREATE TABLE sample_table

(
column1 data_type(size) constraint_name,
column2 data_type(size) constraint_name,
column3 data_type(size) constraint_name,
....
);

sample_table: Name of the table to be created.

data_type: Type of data that can be stored in the field.
constraint_name: Name of the constraint. for example- NOT NULL, UNIQUE, PRIMARY KEY etc.

NOT NULL

 Definition: Ensures that a column cannot have null (empty) values. Every record must have a value for this
column.

 Usage: Used when a field is required for every record, such as a user’s email address.

 Example: Email VARCHAR(100) NOT NULL means every student must have an email address.

CREATE TABLE Student

(
ID int(6) NOT NULL,
NAME varchar(10) NOT NULL,
ADDRESS varchar(20)
);

UNIQUE

 Definition: Ensures that all values in a column are distinct. No two records can have the same value for this
column.

 Usage: Used to enforce uniqueness, like in a column for social security numbers or usernames.

 Example: Username VARCHAR(50) UNIQUE ensures no two users can have the same username.

CREATE TABLE Student

(
ID int(6) NOT NULL UNIQUE,
NAME varchar(10),
ADDRESS varchar(20)
);

PRIMARY KEY

 Definition: A combination of NOT NULL and UNIQUE. It uniquely identifies each row in a table and cannot be
null.

 Usage: Used to uniquely identify records, such as in an ID column or a student number.

 Example: StudentID INT PRIMARY KEY means each student will have a unique StudentID that cannot be
duplicated or null.
CREATE TABLE Student
(
ID int(6) NOT NULL UNIQUE,
NAME varchar(10),
ADDRESS varchar(20),
PRIMARY KEY(ID)
);

Summary

Data Types:

 CHAR(n): Fixed-length text.

 VARCHAR(n): Variable-length text.

 INT: Whole numbers.

 FLOAT: Decimal numbers.

 DATE: Calendar dates.

Constraints:

 NOT NULL: Column must have a value.

 UNIQUE: Values in the column must be distinct.

 PRIMARY KEY: Unique identifier for each row, combining NOT NULL and UNIQUE.

Create Database, Use Database, Show Databases, Drop Database

SQL Commands for Database Management

Managing databases involves creating, selecting, and deleting databases. Here are the essential SQL commands for
these tasks:

1. CREATE DATABASE

 Definition: Creates a new database. This command sets up a new database environment where tables, views,
and other objects can be created.

Syntax:
sql
CREATE DATABASE database_name;

Example: To create a database named SchoolDB, you would use:

sql
CREATE DATABASE GeeksForGeeks;

Output:

Creating a new database

2. USE DATABASE
  Definition: Select the database to use for subsequent SQL commands. Once a database is selected, any
operations (such as creating tables or querying data) will be performed on that database.

Syntax:
sql
USE database_name;

Example: To switch to the SchoolDB database, you would use:

sql
USE SchoolDB;

3. SHOW DATABASES

 Definition: Lists all databases available in the database management system (DBMS). This command helps
you view all existing databases and check their names.

Syntax:
sql
SHOW DATABASES;

Example: Running this command will display a list of all databases, including SchoolDB, if it exists.

Database successfully created

4. DROP DATABASE

 Definition: Deletes an existing database and all of its contents, including tables, data, and other objects. This
command is irreversible, so be cautious when using it.

Syntax:
sql
DROP DATABASE database_name;

Example: To delete the SchoolDB database, you would use:

sql
DROP DATABASE SchoolDB;

Show Tables, Create Table, Describe Table, Alter Table (add and remove an attribute, add and remove primary key),
Drop Table, Insert, Delete

SQL Commands for Table Management

Managing tables involves creating, modifying, and deleting tables, as well as inserting and deleting data. Here’s a
guide to essential SQL commands for these tasks:

1. SHOW TABLES

 Definition: Lists all the tables in the currently selected database. Useful for viewing existing tables and
verifying their names.

Syntax:
sql
SHOW TABLES;

 Example: Running this command will display a list of tables in the selected database.

2. CREATE TABLE

 Definition: Creates a new table in the database with specified columns and their data types.

Syntax:
sql
CREATE TABLE table_name ( column1 datatype constraints, column2 datatype constraints, ...);

Example: To create a table named Students with columns StudentID, Name, and DateOfBirth:

sql
CREATE TABLE Students ( StudentID INT PRIMARY KEY, Name VARCHAR(50) NOT NULL, DateOfBirth DATE);

3. DESCRIBE TABLE

 Definition: Displays the structure of a table, including column names, data types, and constraints.

Syntax:
sql
DESCRIBE table_name;

Example: To view the structure of the Students table:

sql
DESCRIBE Students;

4. ALTER TABLE

 Definition: Modifies the structure of an existing table, such as adding or removing columns and constraints.

 Add an Attribute:

Syntax:
sql
ALTER TABLE table_name
ADD column_name datatype constraints;

Example: To add an Email column to the Students table:

sq
ALTER TABLE Students
ADD Email VARCHAR(100);

 Remove an Attribute:

Syntax:
sql
ALTER TABLE table_name
DROP COLUMN column_name;
Example: To remove the Email column from the Students table:
sql
ALTER TABLE Students
DROP COLUMN Email;

 Add a Primary Key:

Syntax:
sql
ALTER TABLE table_name
ADD PRIMARY KEY (column_name);

Example: To add a primary key constraint to the StudentID column:

sql
ALTER TABLE Students
ADD PRIMARY KEY (StudentID);

 Remove a Primary Key:

Syntax:
sql
ALTER TABLE table_name
DROP PRIMARY KEY;

Example: To remove the primary key constraint:

sq
ALTER TABLE Students
DROP PRIMARY KEY;

5. DROP TABLE

 Definition: Deletes an existing table and all of its data. This action is irreversible.

Syntax:
sql
DROP TABLE table_name;

Example: To delete the Students table:

sql
DROP TABLE Students;

6. INSERT

 Definition: Adds new rows of data into a table.

Syntax:
sql
INSERT INTO table_name (column1, column2, ...)VALUES (value1, value2, ...);

Example: To insert a new student into the Students table:

sql
INSERT INTO Students (StudentID, Name, DateOfBirth)VALUES (1, 'Alice Smith', '2005-05-15');

7. DELETE

 Definition: Removes existing rows from a table based on a specified condition.

Syntax:
sql
DELETE FROM table_name
WHERE condition;Example: To delete a student with StudentID 1 from the Students table:
sql
DELETE FROM Students
WHERE StudentID = 1;

Select, Operators (mathematical, relational, Check and logical)

SQL SELECT and Operators

1. SELECT Statement

The SELECT statement is used to query and retrieve data from a database. It is one of the most commonly used SQL
commands.

Basic Syntax:
sql
SELECT column1, column2, …

FROM table_name

WHERE condition;

Example: To retrieve the Name and DateOfBirth of students from the Students table:

sql
SELECT Name, DateOfBirth
FROM Students;

 Select All Columns: Use * to select all columns.

In this example, we will retrieve all records from the “employee” table where the “emp_city” column does not start
with the letter ‘A’.

Query:

sql
SELECT * FROM employee WHERE emp_city NOT LIKE ‘A%’;

Output:

SELECT Statement

 With Conditions: Use the WHERE clause to filter records.

In this example, we will retrieve all records from the “MATHS” table where the value in the “MARKS” column is equal
to 50.

Query:

sql
SELECT * FROM MATHS WHERE MARKS=50;

Output:
 SELECT Statement With Conditions

2. Operators in SQL

SQL operators are used to perform operations on data in queries. They can be categorized into mathematical,
relational, and logical operators.

Mathematical Operators

Definition: Used to perform arithmetic operations.

Common Operators:

 Addition (+): Adds two values.

o Example: SELECT Price + Tax AS Total FROM Products

 Subtraction (-): Subtracts one value from another.

o Example: SELECT Price – Discount AS FinalPrice FROM Products

 Multiplication (*): Multiplies two values.

o Example: SELECT Quantity * Price AS TotalCost FROM Orders

 Division (/): Divides one value by another.

o Example: SELECT TotalAmount / NumberOfItems AS AveragePrice FROM Orders

Relational Operators

Definition: Used to compare values and return a boolean result.

Common Operators:

 Equal To (=): Checks if two values are equal.

o Example: SELECT * FROM Students WHERE StudentID = 1

 Not Equal To (<> or !=): Checks if two values are not equal.

o Example: SELECT * FROM Students WHERE Status <> ‘Inactive’

 Greater Than (>): Checks if a value is greater than another.

o Example: SELECT * FROM Products WHERE Price > 100

 Less Than (<): Check if a value is less than another.

o Example: SELECT * FROM Products WHERE Price < 50

  Greater Than or Equal To (>=): Checks if a value is greater than or equal to another.

o Example: SELECT * FROM Products WHERE Price >= 100

 Less Than or Equal To (<=): Check if a value is less than or equal to another.

o Example: SELECT * FROM Products WHERE Price <= 50

Logical Operators

Definition: Used to combine multiple conditions in queries.

Common Operators:

 AND: Returns true if both conditions are true.

o Example: SELECT * FROM Students WHERE Grade = ‘A’ AND Age > 18

 OR: Returns true if at least one of the conditions is true.

o Example: SELECT * FROM Students WHERE Grade = ‘A’ OR Grade = ‘B’

 NOT: Returns true if the condition is false.

o Example: SELECT * FROM Students WHERE NOT Grade = ‘F’

 BETWEEN: Checks if a value is within a range.

o Example: SELECT * FROM Products WHERE Price BETWEEN 10 AND 50

 LIKE: Searches for a specified pattern.

o Example: SELECT * FROM Customers WHERE Name LIKE ‘J%’; (Finds names starting with ‘J’)

 IN: Checks if a value matches any value in a list.

o Example: SELECT * FROM Students WHERE Grade IN (‘A’, ‘B’)

SQL Logical Operators Example

In this example, retrieve all records from the “employee” table where the “emp_city” column is equal to ‘Allahabad’
and the “emp_country” column is equal to ‘India’.

SELECT * FROM employee

WHERE emp_city = 'Allahabad'
AND emp_country = 'India';

Output:

Use of Logical Operator

Aliasing, Distinct Clause, where Clause, in, Between, Order by

SQL Query Enhancements

1. Aliasing

 Definition: Aliasing is used to create temporary names for tables or columns in a query to make them more
readable or to simplify complex queries.
Syntax:
sql
SELECT column_name AS alias_name

FROM table_name AS alias_name;

Example: To create a shorter name for the Students table and a column alias for DateOfBirth:
sql
SELECT Name AS StudentName, DateOfBirth AS DOB
FROM Students AS S;

2. DISTINCT Clause

Definition: The DISTINCT clause removes duplicate rows from the result set, showing only unique values.

Syntax:
sql
SELECT DISTINCT column_name

FROM table_name;

Example: To find unique Grade values in the Students table:

sql
SELECT DISTINCT Grade
FROM Students;

3. WHERE Clause

Definition: The WHERE clause filters records to include only those that meet a specified condition.

Syntax:
sql
SELECT column1, column2, …

FROM table_name

WHERE condition;

Example: To select students older than 18:

sql
SELECT Name, Age
FROM Students
WHERE Age > 18;

4. IN Operator

Definition: The IN operator checks if a value matches any value in a specified list.

Syntax:
sql
SELECT column_name

FROM table_name

WHERE column_name IN (value1, value2, …);

Example: To select students with grades 'A' or 'B':

sql
SELECT Name
FROM Students
WHERE Grade IN ('A', 'B');
5. BETWEEN Operator

Definition: The BETWEEN operator filters records within a specified range (inclusive).

Syntax:
sql
SELECT column_name

FROM table_name

WHERE column_name BETWEEN value1 AND value2;

Example: To find products with prices between 10 and 50:

sql
SELECT ProductName
FROM Products
WHERE Price BETWEEN 10 AND 50;

6. ORDER BY Clause

Definition: The ORDER BY clause sorts the result set by one or more columns. You can sort in ascending (default) or
descending order.

Syntax:
sql
SELECT column1, column2, …

FROM table_name

ORDER BY column_name [ASC|DESC];

Example: To select students and sort them by age in ascending order:

sql
SELECT Name, Age
FROM Students
ORDER BY Age ASC;

Example: To sort products by price in descending order:

sql
SELECT ProductName, Price
FROM Products
ORDER BY Price DESC;

Meaning of null, is null, is not null, like, update command, delete command

Principles of NULL values

 Setting a NULL value is appropriate when the actual value is unknown, or when a value is not meaningful.

 A NULL value is not equivalent to a value of ZERO if the data type is a number and is not equivalent to spaces
if the data type is a character.

 A NULL value can be inserted into columns of any data type.

 A NULL value will evaluate NULL in any expression.

 Suppose if any column has a NULL value, then UNIQUE, FOREIGN key, and CHECK constraints will ignore by
SQL.
 Use of AND Logical Expression

Use of OR Logical Expression

In general, each NULL value is considered to be different from every other NULL in the database. When a NULL is
involved in a comparison operation, the result is considered to be UNKNOWN. Hence, SQL uses a three-valued logic
with values True, False, and Unknown. It is, therefore, necessary to define the results of three-valued logical
expressions when the logical connectives AND, OR, and NOT are used.

SQL Null Values and Common Commands

1. Meaning of NULL

 Definition: NULL represents the absence of a value or unknown data in a database. It is not the same as an
empty string or zero. It signifies that the value is missing or not applicable.

 Example: In a Students table, a Graduation Date column might be NULL if the student hasn’t graduated yet.

2. IS NULL

 Definition: The IS NULL condition is used to check if a column contains a NULL value.

Syntax:
sql
SELECT column_name

FROM table_name

WHERE column_name IS NULL;

Example: To find students without a specified GraduationDate:

sql
SELECT NameFROM Students
WHERE GraduationDate IS NULL;

3. IS NOT NULL

Definition: The IS NOT NULL condition is used to check if a column does not contain a NULL value.

Syntax:
sql
SELECT column_name

FROM table_name

WHERE column_name IS NOT NULL;

Example: To find students with a specified GraduationDate:

sql
SELECT NameFROM Students
WHERE GraduationDate IS NOT NULL;

4. LIKE Operator

Definition: The LIKE operator is used for pattern matching in a WHERE clause. It allows you to search for a specified
pattern in a column.

Syntax:
sql
SELECT column_name

FROM table_name

WHERE column_name LIKE pattern;

Pattern Matching:

 %: Represents zero or more characters.

 _: Represents a single character.

Examples:

To find names starting with 'J':

sql
SELECT NameFROM Students
WHERE Name LIKE 'J%';

To find names with exactly 4 characters:

sql
SELECT NameFROM Students
WHERE Name LIKE '____';

5. UPDATE Command

Definition: The UPDATE command is used to modify existing records in a table.

Syntax:
sql
UPDATE table_name

SET column1 = value1, column2 = value2, …

WHERE condition;

Example: To update the Grade of a student with StudentID 1:

sql
UPDATE StudentsSET Grade = 'A'
WHERE StudentID = 1;

6. DELETE Command

Definition: The DELETE command removes existing records from a table based on a specified condition.

Syntax:
sql
DELETE FROM table_name

WHERE condition;

Example: To delete a student with StudentID 1:

sql
DELETE FROM Students
WHERE StudentID = 1;

Aggregate Functions (max, min, avg, sum, count), group by, having clause

SQL Aggregate Functions and Grouping

1. Aggregate Functions

Aggregate functions perform calculations on a set of values and return a single result. They are often used with the
GROUP BY clause to summarize data.

 MAX(): Returns the maximum value in a set.

Syntax:
sql
SELECT MAX(column_name)

FROM table_name;

Example: To find the highest price in the Products table:

sql
Copy code
SELECT MAX(Price) AS MaxPrice
FROM Products;

 MIN(): Returns the minimum value in a set.

Syntax:
sql
SELECT MIN(column_name)

FROM table_name;

Example: To find the lowest price in the Products table:

sql
SELECT MIN(Price) AS MinPrice
FROM Products;

 AVG(): Returns the average value of a set.

Syntax:
sql
SELECT AVG(column_name)

FROM table_name;

Example: To find the average price of products:

sql
SELECT AVG(Price) AS AveragePrice
FROM Products;

 SUM(): Returns the total sum of a set of values.

Syntax:
sql
SELECT SUM(column_name)

FROM table_name;

Example: To calculate the total sales amount:

sql
SELECT SUM(SalesAmount) AS TotalSales
FROM Sales;

 COUNT(): Returns the number of rows in a set.

Syntax:
sql
SELECT COUNT(column_name)

FROM table_name;

Example: To count the number of students:

sql
SELECT COUNT(StudentID) AS NumberOfStudents
FROM Students;

2. GROUP BY Clause

 Definition: The GROUP BY clause groups rows that have the same values into summary rows. It is commonly
used with aggregate functions to perform operations on each group.

Syntax:
sql
SELECT column_name, aggregate_function(column_name)

FROM table_name

GROUP BY column_name;

Example: To find the average price of products for each category:

sql
SELECT Category, AVG(Price) AS AveragePrice
FROM Products
GROUP BY Category;

3. HAVING Clause

 Definition: The HAVING clause filters groups of rows based on a specified condition, similar to the WHERE
clause but used for groups.

Syntax:
sql
SELECT column_name, aggregate_function(column_name)

FROM table_name

GROUP BY column_name

HAVING condition;

Example: To find categories where the average price is more than 50:
sql
SELECT Category, AVG(Price) AS AveragePrice
FROM Products
GROUP BY Category
HAVING AVG(Price) > 50;

Joins: Cartesian Product on two tables, equi-join and natural join

SQL Joins
Joins are used to combine rows from two or more tables based on a related column. SQL JOIN clause is used to query
and access data from multiple tables by establishing logical relationships between them. It can access data from
multiple tables simultaneously using common key values shared across different tables.

We can use SQL JOIN with multiple tables. It can also be paired with other clauses, the most popular use will be using
JOIN with WHERE clause to filter data retrieval.

SQL JOIN Example

Consider the two tables below as follows:

Student:

Student
Table

Student Course:

Student Course Table

Both these tables are connected by one common key (column) i.e ROLL_NO.

We can perform a JOIN operation using the given SQL query:

SELECT s.roll_no, s.name, s.address, s.phone, s.age, sc.course_id
FROM Student s
JOIN StudentCourse sc ON s.roll_no = sc.roll_no;

Output:

ROLL_NO NAME ADDRESS PHONE AGE COURSE_ID

1 HARSH DELHI XXXXXXXXXX 18 1

2 PRATIK BIHAR XXXXXXXXXX 19 2

3 RIYANKA SILGURI XXXXXXXXXX 20 2

4 DEEP RAMNAGAR XXXXXXXXXX 18 3

5 SAPTARHI KOLKATA XXXXXXXXXX 19 1

Here’s a breakdown of different types of joins:

1. Cartesian Product

 Definition: The Cartesian product (also known as a cross join) returns all possible combinations of rows from
two tables. Each row from the first table is paired with every row from the second table.

Syntax:
sql
SELECT *

FROM table1, table2;

Example: If Students has 3 rows and Courses has 4 rows, the Cartesian product will produce 12 rows.
sql
SELECT *FROM Students, Courses;

 Note: Cartesian products can generate a large number of rows, so use them with caution.

2. Equi-Join

 Definition: An equi-join (also known as an inner join) combines rows from two tables based on matching
values in specified columns. It retrieves rows where the specified columns have equal values.

Syntax:
sql
SELECT table1.column1, table2.column2, …

FROM table1

INNER JOIN table2

ON table1.common_column = table2.common_column;
Example: To find students and their enrolled courses:
sql
SELECT Students.Name, Courses.CourseName

FROM Students

INNER JOIN Enrollments

ON Students.StudentID = Enrollments.StudentID

INNER JOIN Courses

ON Enrollments.CourseID = Courses.CourseID;

3. Natural Join

 Definition: A natural join automatically joins tables based on columns with the same name and data type in
both tables. It selects rows where the values in these common columns are equal.

Syntax:
sql
SELECT *

FROM table1

NATURAL JOIN table2;

Example: To automatically join Students and Enrollments on the common column StudentID:
sql
SELECT *FROM Students
NATURAL JOIN Enrollments;

 Note: Be careful with natural joins, as they rely on column names and types being identical in both tables,
which might lead to unintended results if there are columns with the same names but different meanings.

Summary

 Cartesian Product: Produces all possible combinations of rows from two tables. (SELECT * FROM table1,
table2;)

 Equi-Join: Combines rows based on matching column values (INNER JOIN … ON …).

 Natural Join: Joins tables based on columns with the same names and data types (NATURAL JOIN).

Interface of Python with an SQL Database

Connecting Python with an SQL Database

To interact with an SQL database from Python, you typically use libraries that provide database connectivity and
operations. Here’s a guide on how to connect Python with an SQL database, specifically focusing on popular libraries
like sqlite3, mysql-connector-python, and psycopg2.
 SQL
connection with Python

1. Using sqlite3 for SQLite

SQLite is a lightweight, disk-based database that’s built into Python’s standard library. It’s great for small to medium-
sized applications.

Steps:

 Import the library.

 Create a connection to the SQLite database.

 Create a cursor to execute SQL commands.

 Execute SQL commands.

 Commit the transaction (if making changes).

 Close the connection.

Example:
python
import sqlite3

# Connect to the database (or create it if it doesn’t exist)

conn = sqlite3.connect(‘example.db’)

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute(”’CREATE TABLE IF NOT EXISTS students

(id INTEGER PRIMARY KEY, name TEXT, age INTEGER)”’)

# Insert a record

cursor.execute(“INSERT INTO students (name, age) VALUES (‘Alice’, 21)”)

# Commit the changes

conn.commit()

# Query the database

cursor.execute(“SELECT * FROM students”)

rows = cursor.fetchall()

for row in rows:

print(row)

# Close the connection

conn.close()

2. Using mysql-connector-python for MySQL

To connect to a MySQL database, you can use the mysql-connector-python library. You need to install it via pip if you
haven’t already.

Installation:
bash
pip install mysql-connector-python

Example:
python
import mysql.connector

# Connect to the MySQL database

conn = mysql.connector.connect(

host=”localhost”,

user=”yourusername”,

password=”yourpassword”,

database=”yourdatabase”

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute(”’CREATE TABLE IF NOT EXISTS students

(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), age INT)”’)

# Insert a record

cursor.execute(“INSERT INTO students (name, age) VALUES (%s, %s)”, (‘Bob’, 22))

# Commit the changes

conn.commit()
# Query the database

cursor.execute(“SELECT * FROM students”)

rows = cursor.fetchall()

for row in rows:

print(row)

# Close the connection

conn.close()

3. Using psycopg2 for PostgreSQL

To connect to a PostgreSQL database, you can use the psycopg2 library. Install it via pip if needed.

Installation:
bash
pip install psycopg2

Example:
python
import psycopg2

# Connect to the PostgreSQL database

conn = psycopg2.connect(

dbname=”yourdatabase”,

user=”yourusername”,

password=”yourpassword”,

host=”localhost”

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute(”’CREATE TABLE IF NOT EXISTS students

(id SERIAL PRIMARY KEY, name VARCHAR(100), age INTEGER)”’)

# Insert a record

cursor.execute(“INSERT INTO students (name, age) VALUES (%s, %s)”, (‘Charlie’, 23))

# Commit the changes

conn.commit()

# Query the database

cursor.execute(“SELECT * FROM students”)

rows = cursor.fetchall()

for row in rows:

print(row)
# Close the connection

conn.close()

Performing Insert, Update, Delete Queries Using Cursor

Performing SQL Operations with Python’s Cursor

Using a cursor object, you can execute SQL queries to perform operations like inserting, updating, and deleting data
in a database. Here’s how to use the cursor for these operations in Python, with examples for SQLite, MySQL,
and PostgreSQL.

1. Inserting Data

 Definition: Insert new records into a table.

Example:
python
import sqlite3

#Connect to the database

conn = sqlite3.connect(‘example.db’)

cursor = conn.cursor()

# Insert a record

cursor.execute(“INSERT INTO students (name, age) VALUES (?, ?)”, (‘John Doe’, 25))

# Commit the changes

conn.commit()

# Close the connection

conn.close()

2. Updating Data

 Definition: Modify existing records in a table.

Example:
python
import mysql.connector

# Connect to the database

conn = mysql.connector.connect(

host=”localhost”,

user=”yourusername”,

password=”yourpassword”,

database=”yourdatabase”

cursor = conn.cursor()

# Update a record

cursor.execute(“UPDATE students SET age = %s WHERE name = %s”, (26, ‘John Doe’))
# Commit the changes

conn.commit()

# Close the connection

conn.close()

3. Deleting Data

 Definition: Remove records from a table.

Example:
python
import psycopg2

# Connect to the database

conn = psycopg2.connect(

dbname=”yourdatabase”,

user=”yourusername”,

password=”yourpassword”,

host=”localhost”

cursor = conn.cursor()

# Delete a record

cursor.execute(“DELETE FROM students WHERE name = %s”, (‘John Doe’,))

# Commit the changes

conn.commit()

# Close the connection

conn.close()
CBSE Class 12th Computer Science Unit 3 Notes: Database Management

Display Data by using connect(), cursor(), execute(), commit(), fetchone(), fetchall(), rowcount

Displaying Data with Python’s SQL Libraries

When working with SQL databases in Python, you typically use methods like connect(), cursor(), execute(), commit(),
fetchone(), fetchall(), and rowcount to interact with and display data. Here’s how you can use these methods
effectively with examples.

1. Connect to the Database

Definition: Establish a connection to the SQL database using connect().

Example:
import sqlite3

# Connect to the SQLite database

conn = sqlite3.connect(‘example.db’)

2. Create a Cursor Object

Definition: Create a cursor object using cursor(). The cursor allows you to execute SQL commands.

Example:
cursor = conn.cursor()

3. Execute SQL Queries

Definition: Use execute() to run SQL commands.

Example:
cursor.execute("SELECT * FROM students")

4. Fetch Data

Definition: Retrieve data from the executed query.

Methods:

 fetchone(): Fetches the next row of a query result set, returning a single sequence or None.

Example:
row = cursor.fetchone()
print(row)

 fetchall(): Fetches all (remaining) rows of a query result, returning a list of tuples.

Example:
rows = cursor.fetchall()for row in rows:
print(row)

5. Get the Number of Affected Rows

 Definition: Use rowcount to get the number of rows affected by the last operation.

Example:
Python
cursor.execute("DELETE FROM students WHERE age < 20")
print(f"Number of rows deleted: {cursor.rowcount}")

6. Commit the Transaction

 Definition: Use commit() to save changes made during the transaction.

Example:
python
conn.commit()

7. Close the Connection

 Definition: Use close() to close the cursor and database connection.

Example:
python
cursor.close()
conn.close()

Complete Example

Here’s a complete example that demonstrates connecting to a SQLite database, executing a query, fetching data, and
displaying it:

python

import sqlite3

# Connect to the SQLite database

conn = sqlite3.connect(‘example.db’)

# Create a cursor object

cursor = conn.cursor()

# Execute a query

cursor.execute(“SELECT * FROM students”)

# Fetch all rows from the result of the query

rows = cursor.fetchall()

# Display each row

for row in rows:

print(row)

# Fetch the number of rows returned

print(f”Number of rows fetched: {len(rows)}”)

# Close the cursor and connection

cursor.close()

conn.close()

Creating database connectivity applications

Creating database connectivity applications in Python involves several key steps. Here’s a comprehensive guide to
help you build applications that connect to, query, and manipulate databases using popular SQL libraries.

1. Setting Up Your Environment

 Install Required Libraries: Depending on the database you’re working with, you may need to install
specific Python libraries. Here’s how to install some of the most commonly used libraries:

 SQLite (comes with Python, no installation needed)

MySQL:
bash
pip install mysql-connector-python

PostgreSQL:
bash
pip install psycopg2

2. Connecting to the Database

Establishing a connection is the first step in database connectivity. Below are examples for SQLite, MySQL, and
PostgreSQL.

SQLite

import sqlite3

# Connect to an SQLite database (or create it if it doesn’t exist)

conn = sqlite3.connect(‘mydatabase.db’)

MySQL

import mysql.connector

# Connect to a MySQL database

conn = mysql.connector.connect(
 host=”localhost”,

user=”yourusername”,

password=”yourpassword”,

database=”yourdatabase”

PostgreSQL

import psycopg2

# Connect to a PostgreSQL database

conn = psycopg2.connect(

dbname=”yourdatabase”,

user=”yourusername”,

password=”yourpassword”,

host=”localhost”

3. Creating a Cursor Object

The cursor object allows you to execute SQL queries and fetch results.

python
cursor = conn.cursor()

4. Executing SQL Queries

You can execute various SQL queries such as creating tables, inserting data, updating records, and more.

Create Table

python

cursor.execute(”’CREATE TABLE IF NOT EXISTS students

(id INTEGER PRIMARY KEY, name TEXT, age INTEGER)”’)

Insert Data

python

cursor.execute(“INSERT INTO students (name, age) VALUES (?, ?)”, (‘Alice’, 22))

Update Data

python

cursor.execute(“UPDATE students SET age = ? WHERE name = ?”, (23, ‘Alice’))

Delete Data

python

cursor.execute(“DELETE FROM students WHERE name = ?”, (‘Alice’,))

5. Fetching Data
Retrieve data from the database using methods like fetchone(), fetchall(), or fetchmany(size).

Fetch All Data

cursor.execute(“SELECT * FROM students”)

rows = cursor.fetchall()

for row in rows:

print(row)

Fetch One Row

cursor.execute(“SELECT * FROM students LIMIT 1”)

row = cursor.fetchone()

print(row)

6. Committing Transactions

For operations that modify the database, use commit() to save changes.

python

conn.commit()

7. Closing the Connection

Always close the cursor and connection to free up resources.

python

cursor.close()

conn.close()

Complete Example Application

Here’s a complete example that demonstrates a simple Python application with database connectivity. This example
uses SQLite for simplicity, but the approach is similar for MySQL and PostgreSQL.

python

import sqlite3

def create_table(conn):

cursor = conn.cursor()

cursor.execute(”’CREATE TABLE IF NOT EXISTS students

(id INTEGER PRIMARY KEY, name TEXT, age INTEGER)”’)

conn.commit()

def insert_student(conn, name, age):

cursor = conn.cursor()

cursor.execute(“INSERT INTO students (name, age) VALUES (?, ?)”, (name, age))

conn.commit()

def fetch_students(conn):
 cursor = conn.cursor()

cursor.execute(“SELECT * FROM students”)

rows = cursor.fetchall()

for row in rows:

print(row)

def main():

# Connect to the SQLite database

conn = sqlite3.connect(‘mydatabase.db’)

# Create table

create_table(conn)

# Insert a new student

insert_student(conn, ‘John Doe’, 21)

# Fetch and display all students

fetch_students(conn)

# Close the connection

conn.close()

if __name__ == “__main__”:

main()

Using %s Format Specifier and format() to Perform SQL Queries in Python

When executing SQL queries in Python, you often need to pass parameters to queries. There are different ways to do
this, such as using the %s format specifier or the format() method. It’s important to use the correct approach to
ensure that your queries are both functional and secure.

1. Using %s Format Specifier

The %s format specifier is commonly used with libraries like sqlite3, mysql-connector-python, and psycopg2. This
method is generally preferred because it helps prevent SQL injection attacks by automatically escaping special
characters.

Example with SQLite

python

import sqlite3

# Connect to the database

conn = sqlite3.connect(‘example.db’)

cursor = conn.cursor()

# Use %s format specifier for parameterized queries

cursor.execute(“INSERT INTO students (name, age) VALUES (?, ?)”, (‘John Doe’, 25))

conn.commit()

# Fetch and display data

cursor.execute(“SELECT * FROM students WHERE name = ?”, (‘John Doe’,))

print(cursor.fetchone())

# Close the connection

cursor.close()

conn.close()

Example with MySQL

python

import mysql.connector

# Connect to the database

conn = mysql.connector.connect(

host=”localhost”,

user=”yourusername”,

password=”yourpassword”,

database=”yourdatabase”

cursor = conn.cursor()

# Use %s format specifier for parameterized queries

cursor.execute(“INSERT INTO students (name, age) VALUES (%s, %s)”, (‘Jane Smith’, 30))

conn.commit()

# Fetch and display data

cursor.execute(“SELECT * FROM students WHERE name = %s”, (‘Jane Smith’,))

print(cursor.fetchone())

# Close the connection

cursor.close()

conn.close()

Example with PostgreSQL

python

import psycopg2

# Connect to the database

conn = psycopg2.connect(

dbname=”yourdatabase”,

user=”yourusername”,

password=”yourpassword”,

host=”localhost”
)

cursor = conn.cursor()

# Use %s format specifier for parameterized queries

cursor.execute(“INSERT INTO students (name, age) VALUES (%s, %s)”, (‘Alice Johnson’, 28))

conn.commit()

# Fetch and display data

cursor.execute(“SELECT * FROM students WHERE name = %s”, (‘Alice Johnson’,))

print(cursor.fetchone())

# Close the connection

cursor.close()

conn.close()

2. Using format() Method

While you can use the format() method to construct queries, it is generally not recommended due to security
concerns like SQL injection. Direct string interpolation should be avoided in favor of parameterized queries.

Example (Not Recommended for Security Reasons)

python

import sqlite3

# Connect to the database

conn = sqlite3.connect(‘example.db’)

cursor = conn.cursor()

# Unsafe way: using format() for query construction

name = ‘John Doe’

age = 25

cursor.execute(“INSERT INTO students (name, age) VALUES (‘{}’, {})”.format(name, age))

conn.commit()

# Fetch and display data

cursor.execute(“SELECT * FROM students WHERE name = ‘{}'”.format(name))

print(cursor.fetchone())

# Close the connection

cursor.close()

conn.close()

Summary

 %s Format Specifier: Preferred method for parameterized queries. It ensures proper escaping of parameters,
thus helping to prevent SQL injection. Use ? for SQLite and %s for MySQL and PostgreSQL.
 format() Method: While possible, it is not recommended for constructing SQL queries due to security risks.
Directly inserting user inputs into queries can make your application vulnerable to SQL injection attacks.