SQL is used to control all of the functions that a DBMS provides for its users, including:

1. Data definition: SQL lets a user define the structure and organization of the stored data
and relationships among the stored data items.
2. Data retrieval: SQL allows a user or an application program to retrieve stored data
from the database and use it.
3. Data manipulation: SQL allows a user or an application program to update the
database by adding new data, removing old data, and modifying previously stored data.
4. Access control: SQL can be used to restrict a user's ability to retrieve, add, and modify
data, protecting stored data against unauthorized access.
5. Data sharing: SQL is used to coordinate data sharing by concurrent users, ensuring that
they do not interfere with one another.
6. Data integrity: SQL defines integrity constraints in the database, protecting it from
corruption due to inconsistent updates or system failures.
What Can SQL do?
 SQL can execute queries against a database
 SQL can retrieve data from a database
 SQL can insert records in a database
 SQL can update records in a database
 SQL can delete records from a database
 SQL can create new databases
 SQL can create new tables in a database

SQL DML and DDL:

SQL can be divided into two parts: The Data Manipulation Language (DML) and the Data
Definition Language (DDL).
The query and update commands form the DML part of SQL:
 SELECT: - extracts data from a database
 UPDATE: - updates data in a database
 DELETE:- deletes data from a database
 INSERT INTO: - inserts new data into a database

The DDL part of SQL permits database tables to be created or deleted. It also defines indexes
(keys), specify links between tables, and impose constraints between tables.
The most important DDL statements in SQL are:
 CREATE DATABASE- creates a new database
 ALTER DATABASE- modifies a database
 CREATE TABLE- creates a new table
 ALTER TABLE- modifies a table
 DROP TABLE- deletes a table
 CREATE INDEX- creates an index (search key)
 DROP INDEX- deletes an index

Basic structure:
The basic structure of an SQL expression consists of three clauses: SELECT, FROM
and WHERE.
  The SELECT clause corresponds to the projection operation of relational algebra. It is
used to list the attributes desired in the result of a query.
 The FROM clause corresponds to the Cartesian product operation of relational algebra.
It is used to list the relations to be used in the evaluation of the expression.
 The WHERE clause corresponds to the selection predicate of relational algebra. It
consists of a predicate in the attributes of the relations that appear in the FROM clause.
A typical SQL query has the form
SELECT A1, A2, …..,An
FROM R1, R2, …… ,Rn
WHERE P
Where each Ai represents an attribute, each Ri is a relation and P is a predicate.
Its equivalent relational algebra expression is:
 A1, A2, …..,An p (R1 X R2 X ……X Rn))
The SQL SELECT Statement:
The SELECT statement is used to select data from a database. The result is stored in a result
table, called the result-set.
SQL SELECT Syntax:
SELECT column_name(s) FROM table_name
and
SELECT * FROM table_name
Note: SQL is not case sensitive. SELECT is the same as select.

An SQL SELECT Example:

Sailors (sid: integer, sname: string, rating: integer, age: real)
Boats (bid: integer, bname: string, color: string)
Reserves (sid: integer, bid: integer, day: date

Sailors Boats Reserves

Sid sname Rating Age Bid Bname Sid Bid
Color Day
1 Ajaya 12 33 11 Marine 1 Red24 2068-08-11
2 Robin 11 43 24 Clipper 1 11 2068-08-11
Blue
3 Ganga 32 28 33 Wooden 1 41 2068-08-22
Black
4 Manoj 9 31 41 Marine 2 33 2068-11-08
Green
7 Rahul 7 22 2 11 2068-08-19
9 Sanjaya 9 42 11 41 2068-09-23
11 Raju 4 19 9 24 2068-08-10
9 11 2069-08-15
9 33 2068-05-21
Now we want to select the content of the columns named "sname" and "age" from the table
Sailors. We use the following SELECT statement:
SELECT sname, age
 FROM Sailors; Sname Age
The result-set will look like this: Ajaya 33
Robin 43
Ganga 28
Manoj 31
Rahul 22
Sanjaya 42
Raju 19
SELECT * Example
Now we want to select all the columns from the ―Sailors " table. We use the following SELECT
statement:
SELECT * FROM Sailors
Tip: The asterisk (*) is a quick way of selecting all columns!
The result-set will look like this:
Sid Sname Rating Age
1 Ajaya 12 33
2 Robin 11 43
3 Ganga 32 28
4 Manoj 9 31
7 Rahul 7 22
9 Sanjaya 9 42
11 Raju 4 19

The SQL SELECT DISTINCT Statement:

In a table, some of the columns may contain duplicate values. This is not a problem; however,
sometimes you will want to list only the different (distinct) values in a table. The DISTINCT
keyword can be used to return only distinct (different) values.
SQL SELECT DISTINCT Syntax:
SELECT DISTINCT column_name(s)
FROM table_name
SELECT DISTINCT Example:
Now we want to select only the distinct values from the column named "bname" from
the table ―Boats‖. We use the following SELECT statement:
SELECT DISTINCT bname FROM Boats
The result-set will look like this:
Bname
Marine
Clipper
Wooden
The WHERE Clause:
The WHERE clause is used to extract only those records that fulfill a specified criterion.
SQL WHERE Syntax:
SELECT column_name(s)
FROM table_name
WHERE column_name operator value
WHERE Clause Example:
Now we want to select only those Sailors whose age is less than 30 from the table
Sailors above.
We use the following SELECT statement:
SELECT *
FROM Sailors
WHERE age < 30;
The result-set will look like this: Sid sname Rating Age
3 Ganga 32 28
7 Rahul 7 22
11 Raju 4 19
Quotes around Text Fields:
SQL uses single quotes around text values (most database systems will also accept double
quotes). Although, numeric values should not be enclosed in quotes.
For text values:
This is correct: SELECT *
FROM Sailors
WHERE sname='Ajaya';
This is wrong: SELECT *
FROM Sailors
WHERE sname=Ajaya;
For Numeric values:
This is correct: SELECT *
FROM Sailors
WHERE age=32
This is wrong: SELECT *
FROM Sailors
WHERE age='32'

Operators Allowed in the WHERE Clause:

With the WHERE clause, the following operators can be used:
Operator Description
= Equal
<> Not equal
> Greater than
< Less than
>= Greater than or equal
<= Less than or equal
BETWEEN Between an inclusive range
LIKE Search for a pattern
IN If you know the exact value you want
to return for at least one of the columns.
AND And
OR Or

Note: In some versions of SQL the <> operator may be written as !=

By Bhupendra Saud
The AND & OR Operators:
The AND & OR operators are used to filter records based on more than one condition.
 The AND operator displays a record if both the first condition and the second
condition is true.
 The OR operator displays a record if either the first condition or the second condition is
true.
AND Operator Example:
Suppose we want to select only the Sailors with the name equal to "Ajaya" AND the age
equal to 33: We use the following SELECT statement:
SELECT *
FROM Sailors
WHERE sname='Ajaya' AND age=33;

The result-set will look like this:

Sid sname rating Age
1 Ajaya 12 33
Example 2: Find the sids of sailors who have reserved a red boat.
SELECT R.sid
FROM Boats B, Reserves R
WHERE B.bid = R.bid AND B.color = `red'
The result-set will look like this: Sid
1
2
9
OR Operator Example:
Now we want to select only the Sailors with the first name equal to "Rahul" OR the rating equal
to 9: We use the following SELECT statement:
SELECT *
FROM Sailors
WHERE sname='Rahul' OR rating=9;
The result-set will look like this: Sid Sname Rating Age
4 Manoj 9 31
7 Rahul 7 22
9 Sanjaya 9 42
Combining AND & OR:
We can also combine AND and OR (use parenthesis to form complex expressions).
Now we want to select only the Sailors of rating equal to 9 AND the age equal to 31 OR to 42:
We use the following SELECT statement:
SELECT *
FROM Sailors
WHERE rating=9 AND (age=31 OR age=42)
The result-set will look like this:
 Sid Sname Rating Age
4 Manoj 9 31
9 Sanjaya 9 42

The ORDER BY Keyword:

The ORDER BY keyword is used to sort the result-set by a specified column. The ORDER BY
keyword sorts the records in ascending order by default. If you want to sort the records in a
descending order, you can use the DESC keyword.
SQL ORDER BY Syntax:
SELECT column_name(s)
FROM table_name
ORDER BY column_name(s) ASC | DESC
ORDER BY Example:
Now we want to select all the Sailors from the table above, however, we want to sort the
Sailors by their name. We use the following SELECT statement:
SELECT *
FROM Sailors
ORDER BY sname;
The result-set will look like this: Sid Sname Rating Age
1 Ajaya 12 33
3 Ganga 32 28
4 Manoj 9 31
7 Rahul 7 22
11 Raju 4 19
2 Robin 11 43
9 Sanjaya 9 42
ORDER BY DESC Example:
Now we want to select all the Sailors from the table above, however, we want to sort the
Sailors descending by their name. We use the following SELECT statement:
SELECT *
FROM Sailors
ORDER BY sname DESC
The result-set will look like this: Sid Sname Rating Age
9 Sanjaya 9 42
2 Robin 11 43
11 Raju 4 19
7 Rahul 7 22
4 Manoj 9 31
3 Ganga 32 28
1 Ajaya 12 33
The SQL BETWEEN Operator:
The BETWEEN operator is used to select values within a range. The values can be numbers,
text, or dates.
SQL BETWEEN Syntax:
 SELECT column_name(s)
FROM table_name
WHERE column_name BETWEEN value1 AND value2;

BETWEEN Operator Example:

The following SQL statement selects all Sailors with age BETWEEN 20 and 40:
SELECT *
FROM Sailors
WHERE age BETWEEN 20 AND 40;
The result-set will look like this:
Sid Sname Rating Age
7 Rahul 7 22
4 Manoj 9 31
3 Ganga 32 28
1 Ajaya 12 33
NOT BETWEEN Operator Example:
To display the Sailors outside the range of the previous example, use NOT BETWEEN:
SELECT *
FROM Sailors
WHERE age NOT BETWEEN 20 AND 40;
The result-set will look like this: Sid Sname Rating Age
9 Sanjaya 9 42
2 Robin 11 43
11 Raju 4 19
SQL IN Operator:
The IN operator allows us to specify multiple values in a WHERE clause.
SQL IN Syntax:
SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1, value2...);

IN Operator Example:
The following SQL statement selects all Sailors with a rating of 9 or 11:
SELECT *
FROM Sailors Its equivalent query by using OR
WHERE Rating IN (9, 11); operator is as below:
The result-set will look like this:
SELECT *
Sid sname Rating Age FROM Sailors
2 Robin 11 43 WHERE Rating=9 OR Rating=11;
4 Manoj 9 31
9 Sanjaya 9 42

NOT IN Operator Example:

The following SQL statement selects all Sailors with age not 11 or 9:
SELECT *
 FROM Sailors
WHERE rating NOT IN (11, 9);

The result-set will look like this: Sid sname Rating age
1 Ajaya 12 33
3 Ganga 32 28
7 Rahul 7 22
11 Raju 4 19

String operations:
SQL specifies strings by enclosing them in single quotes, for example ‗Pokhara‘. The most
commonly used operation on strings is pattern matching. It uses the operator LIKE. We
describe the patterns by using two special characters:
 Percent (%): The % character matches any substring, even the empty string.
 Underscore ( _ ): The underscore stands for exactly one character. It matches any
character.
To illustrate pattern matching, we consider the following examples:
 ‗A_Z‘: All string that starts with ‗A‘, another character and end with ‗Z‘. For example,
‗ABZ‘ and ‗A2Z‘ both satisfy this condition but ‗ABHZ‘ does not because between A
and Z there are two characters are present instead of one.
 ‗ABC%‘: All strings that start with ‗ABC‘.
 ‗%ABC‘: All strings that ends with ‗ABC‘.
 ‗%AN%‘: All strings that contains the pattern ‗AN‘ anywhere. For example, ‗ANGELS‘
,‘SAN‘, ‗FRANCISCO‘ etc.
 ‗_ _ _‘: matches any strings of exactly three characters.
 ‗_ _ _%‘: matches any strings of at least three characters.

Example:
SELECT * FROM Sailors
WHERE sname LIKE ‗%ya‘;
This SQL statement will match any Sailors first names that end with ‗ya‘.
The result-set will look like this:
Sid sname Rating age
1 Ajaya 12 33
9 Sanjaya 9 42
Set Operations:
Some time it is useful to combine query results from two or more queries into a single result.
SQL supports three set operators which are:
 SQL Union
 SQL Intersection and
 SQL Except (Minus)
These operators have the pattern:
<query1> <set operator> <query2>
SQL Union Operation:
In SQL the UNION clause combines the results of two SQL queries into a single table of all
matching rows. The two queries must result in the same number of columns and
compatible data types in order to unite. Any duplicate records are automatically removed
unless UNION ALL is used.
Example: Find the names of sailors who have reserved a red or a green boat.
SELECT S.sname
FROM Sailors S, Reserves R, Boats B
WHERE S.sid = R.sid AND R.bid = B.bid
AND (B.color = `red' OR B.color = `green')
This query is difficult to understand (and also quite inefficient to execute, as it turns out). A
better solution for this query is to use UNION as follows:
SELECT S.sname
FROM Sailors S, Reserves R, Boats B
WHERE S.sid = R.sid AND R.bid = B.bid AND B.color = `red'
UNION
SELECT S2.sname
FROM Sailors S2, Boats B2, Reserves R2
WHERE S2.sid = R2.sid AND R2.bid = B2.bid AND B2.color = `green' ;

The result-set will look like this: Sname

Sanjaya
Robin
Raju
Ajaya
UNION ALL gives different results, because it will not eliminate duplicates. Executing this
statement:
SELECT S.sname
FROM Sailors S, Reserves R, Boats B
WHERE S.sid = R.sid AND R.bid = B.bid AND B.color = `red'
UNION ALL
SELECT S2.sname
FROM Sailors S2, Boats B2, Reserves R2
WHERE S2.sid = R2.sid AND R2.bid = B2.bid AND B2.color = `green'
The result-set will look like this: Sname
Sanjaya
Robin
Raju
Ajaya
Ajaya
INTERSECT Operation:
The SQL INTERSECT operator takes the results of two queries and returns only rows that
appear in both result sets. The INTERSECT operator removes duplicate rows from the final
result set. The INTERSECT ALL operator does not remove duplicate rows from the final result
set.
Example: Find the names of sailors who have reserved a red and a green boat.
 SELECT S.sname
FROM Sailors S, Reserves R1, Boats B1, Reserves R2, Boats B2
WHERE S.sid = R1.sid AND R1.bid = B1.bid AND S.sid = R2.sid AND R2.bid =
B2.bid AND B.color = `red' AND B.color = `green';
This query is difficult to understand (and also quite inefficient to execute, as it turns out). A
better solution for this query is to use INTERSECT as follows:
The result-set will look like this:
SELECT S.sname
FROM Sailors S, Reserves R, Boats B
WHERE S.sid = R.sid AND R.bid = B.bid AND B.color = `red'
INTERSECT
SELECT S2.sname
FROM Sailors S2, Boats B2, Reserves R2
WHERE S2.sid = R2.sid AND R2.bid = B2.bid AND B2.color = `green';
The result-set will look like this:
Sname
Ajaya
Except Operation:
The SQL EXCEPT operator takes the distinct rows of one query and returns the rows that do
not appear in a second result set.
Example: Find the names of sailors who have reserved a red boats but not a green boat.
SELECT S.sname
FROM Sailors S, Reserves R, Boats B
WHERE S.sid = R.sid AND R.bid = B.bid AND B.color = `red'
EXCEPT
SELECT S2.sname
FROM Sailors S2, Boats B2, Reserves R2
WHERE S2.sid = R2.sid AND R2.bid = B2.bid AND B2.color = `green'
The EXCEPT operation automatically eliminate duplicates. If we want to retain all duplicates,
we must write EXCEPT ALL in place of EXCEPT.

SQL Aggregate Functions:

Aggregate functions are functions that take a collection of values as input and return a single
value.
Useful aggregate functions are:
 SUM() - Returns the sum
 AVG() - Returns the average value
 COUNT() - Returns the number of rows
 MAX() - Returns the largest value
 MIN() - Returns the smallest value
 FIRST() - Returns the first value
 LAST() - Returns the last value
Example 1: find sum of rating of all sailors.
SELECT SUM (rating)
FROM Sailors; Sum(rating)
The result-set will look like this: 85
Example 2: find average age of all sailors.
SELECT AVG (age)
FROM Sailors;
The result-set will look like this: Avg(age)
29.7143
Example 3: find average age of all sailors with a rating of 9.
SELECT AVG (age)
FROM Sailors Avg(age)
WHERE rating=9; 31.5000
The result-set will look like this:
Example 4: find name and age of oldest sailor.
SELECT sname, age
FROM Sailors
WHERE age = (SELECT MAX(age)
FROM Sailors);

The result-set will look like this: Sname max(age)

Robin 43

Example 5: count number of sailors.

SELECT COUNT(*)
FROM Sailors;
count(*)
The result-set will look like this:
7

Example 6: Find the names of sailors who are older than the oldest sailor with a rating of 9.
SELECT S.sname
FROM Sailors S
WHERE S.age > (SELECT MAX (S2.age)
FROM Sailors S2
WHERE S2.rating =9);
The result-set will look like this: Sname
Robin

Example 7: find the maximum and minimum aged sailors name.

SELECT sname
FROM Sailors
WHERE age=(SELECT max(age) FROM Sailors)
UNION
SELECT S1.sname
FROM Sailors S1
WHERE S1.age=(SELECT min(age) FROM Sailors);
The result-set will look like this:
Sname
Robin
Raju

GROUP BY Clause:
The SQL GROUP BY clause is use to divide the rows in a table into groups. The GROUP BY
statement is used along with the SQL aggregate functions. In GROUP BY clause, the tuples
with same values are placed in one group.
Example: Find the age of the youngest sailor for each rating level.
SELECT rating, MIN(age)
FROM Sailors
GROUP BY rating; Rating Min(age)
The result-set will look like this:
4 19
7 22
9 31
11 43
12 33
32 28

This table display the minimum age of each group according to their rating.
SQL HAVING Clause:
The SQL HAVING clause allows us to specify conditions on the rows for each group. It is used
instead of the WHERE clause when Aggregate Functions are used. HAVING clause should
follow the GROUP BY clause if we are using it.
Example: let‘s take an instance S3 of Sailors,

S3
Sid sname Rating age
1 Ajaya 12 33
2 Robin 11 43
3 Ganga 32 28
4 Manoj 9 31
7 Rahul 7 22
9 Sanjaya 9 42
11 Raju 4 19
22 Robin 11 54
32 Anish 7 21
Example: Find the age of the youngest sailor who is eligible to vote (i.e., is at least 18 years
old) for each rating level with at least two such sailors.
SELECT S.rating, MIN (S.age) AS minage
FROM Sailors S
WHERE S.age >= 18
GROUP BY S.rating
 HAVING COUNT (*) > 1
The result-set will look like this: Rating Minage
7 21
9 31
11 43
Example 2: Find the average age of sailors who are of voting age (i.e., at least 18 years old)
for each rating level that has at least two sailors.
SELECT S.rating, AVG ( S.age )
FROM Sailors S
WHERE S. age >= 18
GROUP BY S.rating
HAVING 1 < (SELECT COUNT (*)
FROM Sailors S2
WHERE S.rating = S2.rating );
NULL Values:
SQL allows the use of NULL values to indicate absence of information about the value of an
attribute. It has a special meaning in the database- the value of the column is not currently
known but its value may be known at a later time.
A special comparison operator IS NULL is used to test a column value for NULL. It has
following general format:
Value1 IS [NOT] NULL;
This comparison operator return true if value contains NULL, otherwise return false. The
optional NOT reverses the result.
Following syntax is illegal in SQL:
WHERE attribute=NULL;

Example: let’s take an instance S4 of Sailors,

S4
sid sname Rating Age
1 Ajaya 12 33
2 Robin 11 43
3 Ganga 32 28
4 Manoj 9 31
7 Rahul 7 22
9 Sanjaya NULL NULL
11 Raju 4 19
22 Robin NULL NULL
32 Anish NULL NULL

Find all sailors that appear in S4 relation with NULL values for rating and age:
SELECT sname
FROM S4
WHERE rating IS NULL AND age IS NULL;
The result-set will look like this: Sname
Sanjaya
Robin
Anish
Nested Sub-queries:
A nested query is a query that has another query embedded within it; the embedded query is
called a sub-query. The result of sub query is used by the main query (outer query). We can
place the sub-query in a number of SQL clauses including:
 The WHERE clause
 The HAVING clause
 The FROM clause
A common use of sub-queries is to perform tasks for set membership and make set comparison.
Set Membership:
The IN connective is used to test a set membership, where set is a collection of values produced
by SELECT clause in sub-query. The NOT IN connective is used to test for absence of set
membership.
Example1: Find the names of sailors who have reserved boat 41.
SELECT sname
FROM Sailors
WHERE sid IN ( SELECT sid
FROM Reserves Sname
WHERE bid=41); Ajaya
The result-set will look like this: Raju
Example 2: Find the names of sailors who have reserved a red boat.
SELECT sname
FROM sailors
WHERE sid IN (SELECT sid
FROM Reservs
WHERE bid IN ( SELECT bid
FROM Boats
WHERE color=’Red’));
The result-set will look like this: sname
Ajaya
Robin
Sanjaya
Example 3: Find the names of sailors who have not reserved a red boat.
SELECT sname
FROM sailors
WHERE sid NOT IN (SELECT sid
FROM Reservs
WHERE bid IN ( SELECT bid
FROM Boats
WHERE color=’Red’));
Sname
Ganga
The result-set will look like this: Manoj
Rahul
Raju
Set Comparison:
The comparison operators are used to compare sets in nested sub-query. SQL allows following
set comparisons:
< SOME, <= SOME, > SOME, >= SOME, = SOME, < > SOME
<ALL, <=ALL, >ALL, >=ALL, = ALL, < >ALL
The keyword ANY is synonymous to SOME in SQL.
Example 1: let’s take an instance S4 of Sailors as:
S4
Sid Sname Rating Age
1 Ajaya 12 33
2 Robin 11 43
3 Ganga 32 28
4 Manoj 9 31
7 Rahul 7 22
9 Sanjaya 9 42
11 Raju 4 19
8 Rahul 6 76
Find the id and names of sailors whose rating is better than some sailor called “Rahul”.
SELECT sid, sname
FROM S4
WHERE rating >ANY (SELECT rating
FROM S4
WHERE sname=’Rahul’);
The result-set will look like this:
Sid Sname
1 Ajaya
2 Robin
3 Ganga
4 Manoj
7 Rahul
9 Sanjaya

Example 2: Find the id and names of sailors whose rating is better than every sailor called
“Rahul”.
SELECT sid, sname
FROM S4
WHERE rating >ALL (SELECT rating
FROM S4
WHERE sname=’Rahul’);
The result-set will look like this:
 Sid Sname
1 Ajaya
2 Robin
3 Ganga
4 Manoj
9 Sanjaya
Example 3: Find the id and name of sailor with height rating.
SELECT sid, sname
FROM S4
WHERE rating >=ALL (SELECT rating
FROM S4);
The result-set will look like this:
Sid Sname
3 Ganga

Note: IN and NOT IN are equivalent to =ANY and < > respectively.

Views:
A database view is a logical table. It does not physically store data like tables but
represent data stored in underlying tables in different formats. A view does not require desk
space and we can use view in most places where a table can be used.
Since the views are derived from other tables thus when the data in its source tables are updated,
the view reflects the updates as well. They also can be used by DBA to enforce database
security.
Advantages of Views:
 Database security: view allows users to access only those sections of database that
directly concerns them.
 View provides data independence.
 Easier querying
 Shielding from change
 Views provide group of users to access the data according to their criteria.
 Vies allow the same data to be seen by different users in different ways at the same time.

Syntax for creating view is: Optional

CREATE VIEW <view name> <columns> AS <query expression>
Where, <query expression> is any legal query expression.
Example: Following view contains the id, name, rating+5 and age of those Sailors whose age is
greater than 30:
CREATE VIEW Sailor_view AS
SELECT sid, sname, rating+5, age
FROM Sailors
WHERE age>30;
Now by executing this query we get following view (logical table);
Sailor_view
 Sid sname Rating+5 Age
1 Ajaya 17 33
2 Robin 16 43
9 Sanjaya 14 42
8 Rahul 11 76
Now any valid database operations can be performed in this view like in that of general table.

Modification of the database:

Until now we only study about how information can be extract from the database. Now,
we show how to add, remove, or change information with SQL.
To modify database, there are mainly three operations are used:
 Insertion
 Deletion and
 Updates

1.Insertion:
To insert data into a relation, we either specify a tuple to be inserted or write a query
whose result is a set of tuples to be inserted.
Example 1: suppose we need to insert a new record of Sailors of id is11, name is ―Rahul‖,
rating is 9 and of age is 29 then we write following SQL query,
INSERT INTO Sailors
VALUES (11,’Rahul’, 9, 29);
OR
INSERT INTO Sailors (sid, sname, rating, age)
VALUES (11,’Rahul’, 9, 29);

More generally, we might want to insert tuples on the basis of the result of query.

Example 2: suppose we have already some tuples on the relation ‗Sailores‘. Suppose we need to
insert those tuples of sailors into their own relation whose rating is less than 7, this can be write
as,
INSERT INTO Sailors
SELECT *
FROM Sailors
WHERE rating<7;

2. Deletion:
It is used to remove whole records or rows from the table.
Syntax:
DELETE FROM table_name
WHERE <predicate>
Example 1: suppose we need to remove all tuples of Sailors whose age is 32,
DELETE FROM Sailors
WHERE age=32;
Example 2: Remove all tuples of Sailors whose age is less than 30 and rating greater than 7,
DELETE FROM Sailors
WHERE age<32 AND rating>7;

3. Updates:
If we need to change a particular value in a tuple without changing all values in the tuple, then
for this purpose we use update operation.
Syntax:
UPDATE table_name
SET <column i> = <expression i>;
Example: suppose we need to increase the rating of those sailors whose age is greater than 40
by 20%, this can be write as,
UPDATE sailors
SET rating=rating + rating*0.2
WHERE age>40;
Joined relations:
An SQL JOIN clause is used to combine rows from two or more tables, based on a common
field between them.
The types the different SQL JOINs are:
 INNER JOIN
 LEFT OUTER JOIN
 RIGHT OUTER JOIN
 FULL OUTER JOIN
INNER JOIN:
It is most common type of join. An SQL INNER JOIN return all rows from multiple tables
where the join condition is met.
SQL INNER JOIN Syntax:
SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name=table2.column_name;

Note: INNER JOIN is the same as JOIN.

Example 1: Find the sailor id, boat id, boat name, boat color of those sailors who have
reserved a red boat.
SELECT sailors.sid, boats.bid, boats.bid, boats.bname, boats.color
FROM sailors INNER JOIN reserver INNER JOIN boats
WHERE sailors.sid=reserver.sid AND reserver.bid=boats.bid;
The result-set will look like this:
Example 2: Find the name and age of those sailors who have reserved a Marine boat.
SELECT sailors.sname, sailors.age
FROM sailors INNER JOIN reserver INNER JOIN boats
WHERE sailors.sid=reserver.sid AND reserver.bid=boats.bid;
The result-set will look like this:

LEFT OUTER JOIN:

The LEFT JOIN keyword returns all rows from the left table (table1), with the matching rows in
the right table (table2). The result is NULL in the right side when there is no match.
SQL LEFT JOIN Syntax:
SELECT column_name(s)
FROM table1
LEFT OUTER JOIN table2
ON table1.column_name=table2.column_name;

RIGHT OUTER JOIN:

The RIGHT JOIN keyword returns all rows from the right table (table2), with the matching
rows in the left table (table1). The result is NULL in the left side when there is no match.
SQL RIGHT JOIN Syntax:
SELECT column_name(s)
FROM table1
RIGHT OUTER JOIN table2
ON table1.column_name=table2.column_name;

FULL OUTER JOIN:

The FULL OUTER JOIN keyword returns all rows from the left table (table1) and from the
right table (table2). The FULL OUTER JOIN keyword combines the result of both LEFT and
RIGHT joins.
SQL FULL OUTER JOIN Syntax:
 SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name=table2.column_name;
Example:
Loan borrower

SELECT *
FROM loan NATURAL LEFT OUTER JOIN borrower;

SELECT *
FROM loan NATURAL RIGHT OUTER JOIN borrower;

Data definition languages:

The DDL part of SQL permits database tables to be created or deleted. It also defines indexes
(keys), specify links between tables, and impose constraints between tables.
The most important DDL statements in SQL are:
 CREATE DATABASE- creates a new database
 ALTER DATABASE- modifies a database
 CREATE TABLE- creates a new table
 ALTER TABLE- modifies a table
 DROP TABLE- deletes a table
 CREATE INDEX- creates an index (search key)
 DROP INDEX- deletes an index

Domain type (data type) in SQL:

When we create a table each column of the table must be specified by their domain or data type.
Due to e it helps us what type of data will be stored in the field.
The SQL standard supports a variety of build-in domain types which are:
 Char (n): A fixed length character data (string). Also we can use full form character.
  Varchar(n): A variable character string.
 Int: used to represent whole number. Also we can use it‘s full form integer.
 Numeric(p, d): A fixed point number with user-specified precision. The number
consists of p digits (plus a sign), and d represent the number of digits to right of decimal
point.
 Real, double precision: floating point numbers with machine dependent precisions.
 Float(n): floating point number with precision of at least n digits.
 Date: A calendar date containing a four digit year, month and day. Eg ‗2006-04-22‘
 Time: The time of day, in hours, minutes, and seconds.eg ‘09:34:23‘
 Timestamp: combination of date and time.eg ‗2008-05-21 11:23:08‘

CREATE DATABASE:
The CREATE DATABASE statement is used to create a database.
Syntax:
CREATE DATABASE dbname;
Example:
CREATE DATABASE my_db;

After creating database ‗my_db‘ we need to connect it as;

CONNECT my_db;

ALTER DATABASE:
Allow us to modify existing database name.
Syntax:

CREATE TABLE:
Allow us to create a new table within given database.
Syntax:
CREATE TABLE <table_name>
(
<column1> <data type> [not null] [unique][<integrity constraint>],
<column2> <data type> [not null] [unique][<integrity constraint>],
……………….
………………
<column n> <data type> [not null] [unique][<integrity constraint>]
)
Note: [ ]: optional
Example:
CREATE TABLE Sailors
(
Sid INTEGER NOT NULL,
Sname VARCHAR(12),
Rating INTEGER,
Age INTEGER,
PRIMARY KEY (sid)
)
ALTER TABLE:
Allow us to modify a given table.
The structure of given table can be changed either of the following:
 By adding new column in existing table
 By deleting some columns from an existing table and
 By modifying some columns of given table
A new column can be added to the table as follows:
Syntax:
ALTER TABLE <table name>
ADD (<column_name> <datatype>);

Example: suppose we want to add a new column ‗addresses‘ to an existing table Sailors,
ALTER TABLE Sailors
ADD (addresses varchar(15));

An existing column can be removed from the table as,

ALTER TABLE <table_name>
DROP (column_name);

Example: suppose we want to remove an existing column ‗addresses‘ from the table sailors as,
ALTER TABLE Sailors
DROP (addresses);

An existing column can be modified as,

ALTER TABLE <table_name>
MODIFY (<column name> <data type>);
Example: modify sailors relation by changing the range of the name of sailors by 20,
ALTER TABLE sailors
MODIFY (sname varchar(20));

DROP TABLE
It allows us to remove an existing table from the database.
Syntax:
DROP TABLE <table name>
Example: if we want to remove a table ‗Sailors‘ from the database my_db as,
DROP TABLE Sailors;

Embedded SQL:
The programming language in which SQL queries are embedded is called host language.
And the SQL structures permitted in the host language is called embedded SQL. They are
compiled by the embedded SQL processor.

EXEC SQL statement is used to identify embedded SQL request to the preprocessor
Syntax: EXEC SQL <embedded SQL statement > END-EXEC
Note: this varies by language. E.g. the Java embedding uses # SQL { …. } ;

Example: From within a host language, find the name of sailors who uses red boats.
Specify the query in SQL and declare a cursor for it
EXEC SQL
declare c cursor for
select sname
from Sailors S, Boats B ,Reserver R
where S.sid=R.sid
and R.bid=B.bid
and B.color=”Red”;
END-EXEC

Writing queries in SQL is usually much easier than coding same query in a programming
language. However, a programmer must access to a database from a general purpose
programming language for following two reasons:
 Not all queries can be expressed in SQL
 Non-declarative actions such as printing a report, interacting with user, or sending the
result of query to a graphical user interface etc. cannot be done from the SQL.

Dynamic SQL:
The dynamic SQL component of SQL allows programs to construct and submit SQL
queries at run time. In contrast, embedded SQL statements must be completely present at
compile time; they are compiled by the embedded SQL preprocessor.
Example: The use of dynamic SQL from within a C program.

char * sqlprog = “update Sailors

set rating = rating+rating *0 .25
where sid = ?”

 EXEC SQL prepare dynprog from: sqlprog;

char sailors [10] = ―101‖;
 EXEC SQL execute dynprog using :sailors;
 The dynamic SQL program contains a? which is a place holder for a value that is
provided when the SQL program is executed.

Question: Why we need query language, even we have formal languages?

(formal languages, relational algebra, relational calculus )
 The formal languages provides concise notation for representing query. But commercial
database system requires more user friendly query language. This is a main reason for
why we need query languages, even we have formal languages.
  The formal languages form the basis for data manipulation language of DBMS only but
DBMS/commercial DBMS also supports data definition capabilities as well as data
manipulation capabilities.
 SQL is a most popular and powerful query language. It can do much more than just
query database. It ca define structure of data, modify data in database and allow to
specify security constraints.
 SQL is a truly non procedural language. It has all features of relational algebra,
relational calculus as well as its own powerful features.

Summary of SQL Syntax

CREATE TABLE <table name> (<column name> <column type> [<attribute constraint> ]
{<column name> <column type> [ <attribute constraint> ] }
[<table constraint> {<table constraint> } ] )

DROP TABLE <table name>

ALTER TABLE <table name> ADD <column name> <column type>

SELECT [DISTINCT] <attribute list>

FROM (<table name> { <alias> } | <joined table> ) {( <table name> { <alias> } |
<joined table> ) }
[WHERE <condition> ]
[GROUP BY <grouping attributes> [HAVING <group selection condition> ] ]
[ORDER BY <column name> [ <order> ] { , <column name> [ <order> ] } ]
<attribute list> ::= ( * | ( <column name> | <function> ( ( [ DISTINCT ] <column
name> | * ) ) )
{(<column name> | <function> ( ( [ DISTINCT] <column name> | * ) ) } ) )
<grouping attributes> ::= <column name> { , <column name> }
<order> ::= ( ASC | DESC )

INSERT INTO <table name> [(<column name> {<column name> } ) ]

(VALUES (<constant value> {<constant value>} ) { , ( <constant value>{<constant value>})}
| <select statement>)

DELETE FROM <table name>

[WHERE <selection condition> ]

UPDATE <table name>

SET <column name> = <value expression> { , <column name> = <value expression> }
[WHERE <selection condition> ]

CREATE [UNIQUE] INDEX <index name>

ON <table name>(<column name> [<order>]{<column name> [ <order>]})
[CLUSTER]

DROP INDEX <index name>

CREATE VIEW <view name> [ ( <column name> { , <column name> } ) ]
AS <select statement>

DROP VIEW <view name>

Example:
Example: Assumed simple relational database is as follows.

a. Find all customer names.

SELECT customer_name FROM customer;
b. Find the different customer address (location).
SELECT DISTINCT customer_address FROM customer;
c. Find all address of customer.
SELECT ALL customer_address FROM customer;

d. Find customer_id and its corresponding customer name.

SELECT customer_id, customer_name FROM customer;

e. Find customer detail.

SELECT *FROM customer (* indicates all attributes)
f. List name and address of customer who stay in “KATHMANDU”.
SELECT customer_name, customer_address, FROM customer
WHERE customer_address = ―KATHMANDU‖;

g. List all customer whose name should be “smith” and address should be “Kathmandu”.
SELECT customer_name FROM customer
WHERE customer_name = ‗smith‘
OR customer_ address = ‗Kathmandu‘
i. List account no, balance whose balance is between 200 to 700.
SELECT account_no, balance FROM account
WHERE balance BETWEEN 200 AND 700;
j. What happen if we execute the statement?
SELECT account_no, balance FROM account
WHERE balance NOT BETWEEN 200 AND 700;
k. Write SQL statement for (i) using only AND logical connectives and comparison
operatives.
 SELECT account_no, balance FROM account
WHERE balance <= 700 AND balance >= 200;

Note: We can retrieve the information from multiple tables; there should be a common attribute
between two tables. i.e., table should be related and we require to join condition.

l. List the customer_id, account_id and balance whose balance is more than 300.
SELECT depositor. customer_id, depositor. account_no, account. balance
FROM depositor, account
WHERE depositor.account_no = account.account_no AND account.balance > 300;
m. List all customers and corresponding balance.
SELECT c.customer_name, a.balance
FROM customer c, account a, depositor d
WHERE d.account_no =a.account_no AND d.customer_id =c.customer_id;

Problem: consider a relation schema as follow

branch(#branch_name, branch_city, assets)
account(#account_number, branch_name, balance)
customer(#customer_name, customer_street, customer_city)
depositor(customer_name, account_number)
loan(#loan_number, branch_name, amount)
brrower(customer_name, loan_number)
1. Find all customer who have a loan, account or both at the bank .
SELECT customer nameFrom depositor
UNION
SELECT customer name From borrower;
2. Find all customers who have both loan and account at the bank.
SELECT DISTINCT customer name from depositor
INTERSECT
SELECT DISTINCT customer name from borrower;
3. Find all customers who have account but no loan at the bank.
SELECT DISTINCT customer name from depositor
EXCEPT
SELECT customer name from borrower;

Exercise 1: Consider the following relations:

Student (snum: integer, sname: string, major: string, level: string, age: integer)
Class (cname: string, meets-at: time, room: string, fid: integer)
Enrolled (snum: integer, cname: string)
Faculty (fid: integer, fname: string, deptid: integer)

1. Find the names of all Juniors (Level = JR) who are enrolled in a class taught by I. Teach.
2. Find the age of the oldest student who is either a History major or is enrolled in a course
taught by I. Teach.
3. Find the names of all classes that either meet in room R128 or have five or more
students
 enrolled.
4. Find the names of all students who are enrolled in two classes that meet at the same
time.
5. Find the names of faculty members who teach in every room in which some class is
taught.
6. Find the names of faculty members for whom the combined enrollment of the courses
that they teach is less than _ve.
7. Print the Level and the average age of students for that Level, for each Level.
8. Print the Level and the average age of students for that Level, for all Levels except JR.
9. Find the names of students who are enrolled in the maximum number of classes.
10. Find the names of students who are not enrolled in any class.

Exercise 2 Consider the following schema:

Suppliers (sid: integer, sname: string, address: string)
Parts (pid: integer, pname: string, color: string)
Catalog (sid: integer, pid: integer, cost: real)
Write the following queries in SQL:
1. Find the pnames of parts for which there is some supplier.
2. Find the snames of suppliers who supply every part.
3. Find the snames of suppliers who supply every red part.
4. Find the pnames of parts supplied by Acme Widget Suppliers and by no one else.
5. Find the sids of suppliers who charge more for some part than the average cost of that
part (averaged over all the suppliers who supply that part).
7. Find the sids of suppliers who supply only red parts.
8. Find the sids of suppliers who supply a red part and a green part.
9. Find the sids of suppliers who supply a red part or a green part.

Exercise 3 Consider the following schema of the relational database

Books (Bid,Btitle, Bauthor, Bpublisher, Bprice)
Members ( Member_id, Name, Designation, Age)
Reserve ( Member_id, Bid, Date)
1. Create the tables using Books, Members and Reserve by specifying the Primary key,
Not NULL , Foreign key Constraints DDL Statement in MySQL database
2. Write SQL DML statement to insert any five tuples ( Five records) in each
relation(table)
3. Find the Books of Database System title and price above 500.
4. List the books published by TaTa McGraw Hill publication
5. Find the Name of the member who made reserve book in 12-10-2011

Exercise 4 Consider the following schema of the relational database

Department (dept_no,d_name, city)
Employee (emp_Id, e_name, salary)
Works (dept_no, emp_Id)
1. Create the above tables by specifying the Primary key, Not NULL , Foreign key
Constraints DDL Statement in MySQL database
2. Write DML Statement to Insert any five records in each tables
 3. Display the name of the employees.
4. Find the name of the employees whose salary is greater than 10000.
5. Find the department (d_name) of the employee ‗Binek’.

Exercise 5: Consider the following insurance database, where primary keys are underlined:
Teacher (Tid, Tname, Address, Age)
Student (Sid,Sname, Age, sex)
Takes (sid, course-id)
Course (course-id,course_name, text_book)
Teaches(Tid, Cousrse-id)
Taught-by{Sid, Tid}
Construct the following RA expressions for this relational database
a. Fine name, age and sex of all students who takes course ―DBMS‖
b. Find total number of students who are taught by the teacher ―T01‖
c. List all course names text books taught by teaher ―T16‖
d. Find average age of teachers for each course.
e. Insert the record of new teacher ―T06‖ named ―Bhupi‖ of age 27 into
database who lives in ―Balkhu‖.

Exercise 6: Consider the following employee database, where primary keys are underlined.
employee (employee-name, street, city, salary)
works (employee-name, company-name,)
company (company-name, city)
manages (employee-name, manager-name)
Give an expression in SQL for each of the following queries.
a. Find the names of all employees who work for Second Bank Corporation.
b. Find the names, street and cities of residence of all employees whose salary
is more than average salary.
c. Find the names, street addresses, and cities of residence of all employees to
whom company is not assigned yet.
d. Find the names of all employees who work under the manager ―Devi
Prasad‖.
e. Increase the salary of employees by 10% if their salary is less than 10,000
and by 8% otherwise.

a. Find the names of all employees who work for First Bank Corporation.
select employee-name
from works
where company-name = ‘First Bank Corporation‘
b. Find the names and cities of residence of all employees who work for First Bank
Corporation.
select e.employee-name, city
from employee e, works w
where w.company-name = ‘First Bank Corporation‘ and
w.employee-name = e.employee-name
c. Find the names, street address, and cities of residence of all employees who work for First
Bank Corporation and earn more than $10,000.
Soln:- If people may work for several companies, the following solution will only list those
who earn more than $10,000 per annum from ―First Bank Corporation‖ alone.
select *
from employee
where employee-name in (select employee-name from works
where company-name = ‘First Bank Corporation‘ and salary > 10000)
As in the solution to the previous query, we can use a join to solve this one also.

d. Find all employees in the database who live in the same cities as the companies for which
they work.
select e.employee-name
from employee e, works w, company c
where e.employee-name = w.employee-name and e.city = c.city and
w.company -name = c.company -name
e. Find all employees in the database who live in the same cities and on the same streets as
do their managers.
select P.employee-name
from employee P, employee R, manages M
where P.employee-name = M.employee-name and M.manager-
name=R.employee-name and P.street = R.street and P.city = R.city;

f. Find all employees in the database who do not work for First Bank Corporation.
The following solution assumes that all people work for exactly one company.
select employee-name
from works
where company-name ≠ ‘First Bank Corporation‘
If one allows people to appear in the database (e.g. in employee) but not appear in works, or
if people may have jobs with more than one company, the solution is slightly more
complicated.
select employee-name
from employee
where employee-name not in (select employee-name from works
where company-name = ‘First Bank Corporation‘)
g. Find all employees in the database who earn more than every employee of Small Bank
Corporation.
The following solution assumes that all people work for at most one company.
select employee-name
from works
where salary > all (select salary from works
where company-name = ‘Small Bank Corporation‘)
h. Assume that the companies may be located in several cities. Find all companies located in
every city in which Small Bank Corporation is located.
select S.company-name
from company S
 where not exists ((select city from company where company-name = ‘Small Bank Corporation‘
)
except
(
select city
from company T
where S.company-name = T.company-name))
i. Find all employees who earn more than the average salary of all employees of their
company.
select employee-name
from works T
where salary > (select avg (salary) from works S
where T.company-name = S.company-name)

j. Find the company that has the most employees.

select company-name
from works
group by company-name
having count (distinct employee-name) >= all (select count (distinct employee-name)
from works group by company-name)

k. Find the company that has the smallest payroll.

select company-name
from works
group by company-name
having sum (salary) <= all (select sum (salary) from works
group by company-name)
l. Find those companies whose employees earn a higher salary, on average, than the average
salary at First Bank Corporation.
select company-name
from works
group by company-name
having avg (salary) > (select avg (salary) from works
where company-name = ‘First Bank Corporation‘)

Data modification examples:

a. Modify the database so that Jones now lives in Newtown.
update employee
set city = ‘Newton‘
where person-name = ‘Jones‘
b. Give all employees of First Bank Corporation a 10-percent raise.
update works
set salary = salary * 1.1
where company-name = ‘First Bank Corporation‘
c. Give all managers of First Bank Corporation a 10-percent raise.
update works
 set salary = salary * 1.1
where employee-name in (select manager-name from manages)
and company-name = ‘First Bank Corporation‘
d. Give all managers of First Bank Corporation a 10-percent raise unless the salary becomes
greater than $100,000; in such cases, give only a 3-percent raise.
update works T
set T.salary = T.salary * 1.03
where T.employee-name in (select manager-name from manages)
and T.salary * 1.1 > 100000 and T.company-name = ‘First Bank Corporation‘

update works T
set T.salary = T.salary * 1.1
where T.employee-name in (select manager-name from manages)
and T.salary * 1.1 <= 100000 and T.company-name = ‘First Bank Corporation‘

update works T
set T.salary = T.salary ∗ (case when (T.salary ∗ 1.1 > 100000) then 1.03 else 1.1)
where T.employee-name in (select manager-name from manages) and
T.company-name = ‘First Bank Corporation‘

e. Delete all tuples in the works relation for employees of Small Bank Corporation.
delete works
where company-name = ‘Small Bank Corporation‘

Exercise 7: Consider the following insurance database, where primary keys are underlined:
Student (StuName, StuId, Class, Major)
Course (CourseName, CourseNumber, CreditHours, Department)
Section (SectionId, CourseNumber, Semester, Year, Instructor-Name)
GradeReport (StuId, SectionId, Grade)
Prerequisite (CourseNumber, PrerequisiteNumber)
Construct the following RA expressions for this relational database
 Display name and Id of those students whose major is finance and study in 4 th
semester.
 Display the number of courses taught by ‗Bhupi‘
 Change credit hours of course which course number equal to 19 to 44.
 Insert a new student {‗Raju‘, 10, 12, ‗DBMS‘} in student relation.
 Display student name, class and instructor name who taught ―DBMS‖
Exercise 8: Consider the following employee database, where primary keys are underlined.
DOCTOR (name, age, address)
WORKS (name, deptno)
DEPARTMENT (deptno, floor, room)
Give an expression in SQL for each of the following queries.
a. List the room and floor of the doctors whose name is ‗Aayan‘ and of age 49.
b. Count the number of doctors working in top floor.