Database Systems - SQL - DDL Statements (Chapter 3/3)

6. DML Statements of SQL
 INSERT, UPDATE, DELETE and SELECT Statements
 SELECT DISTINCT, ALL, Column Alias, Column Expressions
 WHERE Clause and Search Conditions
 Logical and Relational Operators
 NULL, LIKE, IN and BETWEEN Predicates
 ORDER BY Clause
 Aggregate Functions, GROUP BY and HAVING Clauses
 Sub-queries, Quantifiers, EXISTS and NOT EXISTS Predicates
 Joins, Cartesian Products and Cross Join, Inner and Outer Joins
 Set Operations

SQL DML Statements
There are 4 DML statements:
DML
Statements
SELECT
INSERT
UPDATE
DELETE

INSERT Statement
The INSERT statement adds a row to the specified table.
Syntax: INSERT INTO table-name [ ( column-list ) ]
VALUES ( value-list )
column-list: Comma separated columns
value-list: Comma separated values
Examples:
INSERT INTO books VALUES (10001, ’Harry Potter and The
Chamber of Secrets’, ’J.K. Rowling’, ’Bloomsbury’);
INSERT INTO books (book_id) VALUES (10002);
INSERT INTO books (book_title, book_id)
VALUES (’Android 4 Application Development’, 10005);

INSERT Statement
Contents of table “books”

UPDATE Statement
The UPDATE statement modifies values of specified columns of
specified table of all rows or only those rows that satisfy given
search condition.
Syntax: UPDATE table-name SET column-name = value
[, column-name = value ] …
[ WHERE search-condition ]
search-condition: An expression containing column names and/or
literals with relational operators and logical operators yielding a
boolean value.
Examples:
UPDATE books SET publisher = ’Bloomsbury’;
UPDATE books
SET book_title = ’Harry Potter and The Philosopher’s Stone’
WHERE book_id = 10001;

UPDATE Example Results
Result of executing two update statements shown in the
earlier slide:

DELETE Statement
The DELETE statement deletes all rows or only those rows that
satisfy given search condition from the specified table.
Syntax: DELETE FROM table-name [ WHERE search-condition ]
search-condition: An expression containing column names and/or
literals with relational operators and logical operators yielding a
boolean value.
Examples:
DELETE FROM books WHERE book_id = 10005;

DELETE Statement
Example Results
The slide shows contents of table books after executing the delete
statement specified in the previous slide.

SELECT Statement
The SELECT statement retrieves all rows or only those rows that
satisfy given search condition from the list of specified tables.
SELECT statement syntax is complex of all SQL statements. A simple
SELECT statement syntax is as follows:
Syntax:: SELECT [ DISTINCT | ALL ] { * | { column-expr
[ AS column-alias ] } [ , column-expr [ AS column-alias ] ] …
FROM table-name [ table-alias ] [, table-name [ table-alias ] ] …
[ WHERE search-condition ]
[ GROUP BY grp-column-list ] [ HAVING search-condition ]
[ ORDER BY ord-column-list ]
column-expr: An expression whose value will form a column value in
the result of the SELECT statement.
search-condition: An expression to select only those rows satisfying
the expression.

Tables for Demonstration
CREATE TABLE emp(
eno INTEGER NOT NULL
PRIMARY KEY,
ename VARCHAR (50) NOT NULL,
designation VARCHAR(50)
NOT NULL,
salary DECIMAL(10, 2),
mno INTEGER NULL,
dno INTEGER NOT NULL
REFERENCES dept(dno)
);
CREATE TABLE bldg(
bno INTEGER NOT NULL
PRIMARY KEY,
bname VARCHAR (50) NOT NULL,
city VARCHAR(50) NOT NULL
);
CREATE TABLE dept(
dno INTEGER NOT NULL
PRIMARY KEY,
dname VARCHAR (50) NOT NULL,
mno INTEGER NULL,
bno INTEGER NOT NULL
REFERENCES
bldg(bno)
);
Tables with primary keys and foreign keys:
ALTER TABLE dept
ADD FOREIGN KEY (mno)
REFERENCES emp(eno);

Data for Building Table bldg
INSERT INTO bldg VALUES(1, ’UB Tower’, ’Bangalore’);
INSERT INTO bldg VALUES(2, ’Cyber Tower’, ’Hyderabad’);
INSERT INTO bldg VALUES(3, ’Discoverer, ITPL’,
’Bangalore’);
INSERT INTO bldg VALUES(4, ’ Maker Towers’, ’Mumbai’);

Data for Department Table dept
INSERT INTO dept VALUES(11, ’Corporate’, NULL, 1);
INSERT INTO dept VALUES(22, ’HR’, NULL, 1);
INSERT INTO dept VALUES(33, ’ Accounts’, NULL, 1);
INSERT INTO dept VALUES(44, ’Projects’, NULL, 2);
INSERT INTO dept VALUES(55, ’Products’, NULL, 3);

Data for Employee Table emp
INSERT INTO emp VALUES(111, ’Akhil’, ’President & CEO’, 500000, 111, 11);
INSERT INTO emp VALUES(112, ’Dinesh’, ’COO’, 300000, 111, 11);
INSERT INTO emp VALUES(113, ’Bhaskar’, ’CTO’, 300000, 111, 11);
INSERT INTO emp VALUES(114, ’Harish’, ’CFO’, 300000, 111, 11);
INSERT INTO emp VALUES(221, ’Rajesh’, ’HR Manager’, 75000, 112, 22);
INSERT INTO emp VALUES(222, ’Mathew’, ’HR Executive’, 50000, 221, 22);
INSERT INTO emp VALUES(331, ’Bala’, ’Accounts Manager’, 75000, 114, 33);
INSERT INTO emp VALUES(332, ’Venky’, ’Accounts Trainee’, 20000, 331, 33);
INSERT INTO emp VALUES(441, ’Suri’, ’Manager - Projects’, 75000, 113, 44);
INSERT INTO emp VALUES(442, ’Vinny’, ’Engineer’, 25000, 441, 44);
INSERT INTO emp VALUES(443, ’Bhargav’, ’Engineer’, 20000, 442, 44);
INSERT INTO emp VALUES(551, ’Jimson’, ’Manager - Products’, 75000, 113, 55);
INSERT INTO emp VALUES(552, ’Niranjan’, ’Engineer’, 50000, 551, 55);
INSERT INTO emp VALUES(553, ’Praveen’, ’Engineer’, 25000, 552, 55);
INSERT INTO emp VALUES(554, ’Sugumar’, ’Engineer’, 20000, 552, 55);

Setting up Managers for
Departments
The following statements setup managers for Corporate, Projects and Products
departments:
UPDATE dept SET mno = 111 WHERE dno = 11;

Select Examples
Projecting All Columns of A Table
Project all columns from table emp:
SELECT eno, ename, designation, salary, mno, dno FROM emp;

Select Examples
Projecting A Few Columns of A Table
Project two columns from table emp:
SELECT ename, salary FROM emp;

Select Examples
Using Table Alias
Table alias e used for table emp:
SELECT e.ename, e.salary FROM emp e;

Select Examples
Projecting All Columns with *
Project all columns
from table emp:
SELECT * FROM emp;
Using a table alias:
SELECT e.*
FROM emp e

SELECT Examples:
DISTINCT Clause
SELECT designation FROM emp;
SELECT DISTINCT designation
FROM emp
The DISTINCT clause gives only
distinct rows as result set of
SELECT statement.

SELECT Examples:
ALL Clause
SELECT designation FROM emp;
SELECT ALL designation
FROM emp
The ALL specified before result
set column expressions makes
the SELECT to return all rows.

SELECT Examples: Result Column Names
using AS Clause
SELECT
eno AS ’Employee Number’,
ename AS ’Employee Name’
FROM emp
SELECT eno, ename
FROM emp

SELECT: Column
Expressions
Salary raise by 10%:
SELECT ename , salary + salary * 0.1
FROM emp
Salary raise by 10% with name for the
column expression:
SELECT ename , salary + salary * 0.1
AS ’New Salary’
FROM emp

SELECT: Row Selection Using
WHERE Clause
• The WHERE clause is used to specify a condition to select only
those rows from the input tables that satisfy the condition.
• The condition is known as Search Condition.
• The condition should evaluate to a BOOLEAN value: TRUE or FALSE
• The SELECT statement evaluates search condition for each row of
the table specified in the FROM clause by substituting columns of
the condition with values from the row. If the search condition
evaluates to TRUE, the statement selects the row and outputs.
• Arithmetic and Logical operators can be used in the search
condition.
• Search Condition can contain columns, literals and even other
SELECT statements.

SELECT: WHERE Clause
Search Condition Operators
Logical Operators: AND, OR, NOT
Relational Operators: =, !=, <>, >, <. >= , <=
Quantifiers: ALL, ANY, SOME
Specific Predicates: NULL, LIKE, CONTAINS, EXISTS, IN, BETWEEN

SELECT: Row Selection Using
WHERE Clause
Employees who work in Products
department:
SELECT ename , salary
FROM emp
WHERE dno = 55
Employees who work in Products
department and whose salary is more
than Rs 25000:
FROM emp
WHERE dno = 55 AND salary > 25000

SELECT : WHERE clause -
LOGICAL operators AND & OR
Employees who work in department
number 44 or 55:
SELECT ename , salary, dno
FROM emp
WHERE dno = 44 OR dno = 55
Employees who work in department
number 55 and get salary of more
than Rs 50,000:
FROM emp
WHERE dno = 55 AND
salary > 50000

SELECT: WHERE clause -
LOGICAL operator NOT
Employees who do not work in department number 44 or 55:
FROM emp
WHERE NOT (dno = 44 OR dno = 55)

SELECT: WHERE clause – Other
Relational operators != and <>
You already saw usage of relational operators =, > and <.
The behaviors of operators != and <> are equivalent. Here is an
example:
Employees who do not work in
both departments 44 and 55:
FROM emp
WHERE dno != 44 AND dno <> 55;

SELECT: WHERE clause – Other
Relational operators >= and <=
Employees who earn salary Rs 25,000 or more but 50,000 or less:
FROM emp
WHERE salary >= 25000 AND salary <= 50000

SELECT : WHERE clause – IS NULL
Operator in NULL Predicate
The NULL operator is used to check if
a value of a column in a row is NULL.
Departments who do not have a
manager:
SELECT * FROM dept
WHERE mno IS NULL
Departments who have a manager:
SELECT * FROM dept
WHERE mno IS NOT NULL
NULL predicate
NULL predicate

SELECT: WHERE clause – Incorrect
use of NULL in predicates
SELECT *
FROM dept
WHERE mno = NULL;
WRONG!
SELECT *
FROM dept
WHERE mno != NULL;
WRONG!

SELECT: WHERE clause – LIKE
Operator & LIKE Predicate
The LIKE operator is used to do pattern
matching with character columns.
Employees whose names start with ’B’:
SELECT ename FROM emp
WHERE ename LIKE ’B%’
Employees whose names do NOT start with ‘B’:
WHERE ename NOT LIKE ’B%’
LIKE predicate
LIKE predicate

LIKE Operator: Pattern Matching
Characters % and _
% matches with any zero or more
characters whereas _ matches
with any one character.
Employees whose names have ’i’
in second position:
WHERE ename LIKE ’_i%’
Employees whose names have ’a’
and ‘k’ in that order:
WHERE ename LIKE ’%a%k%’

LIKE Operator with
ESCAPE clause
The ESCAPE clause is needed if the column values contain the pattern
matching characters % and _.
If a column, offer, values are ’50% discount’, ‘30 percent discount’,
‘no discount’, to select rows that contain the % character, the following
LIKE with ESCAPE can be used:
Items having % character in offer column:
SELECT item_name, offer FROM store
WHERE offer LIKE ’%#%%’ ESCAPE ’#’
Using predefined escape character ’’:
SELECT item_name, offer FROM store
WHERE offer LIKE ’%%%’

IN Operator &
IN Predicate
The IN operator is used to specify a list of values
a column expression has to satisfy:
Employees who work in departments 11, 44 or
55:
WHERE dno IN (11, 44, 55)
IN predicate or membership search condition
Equivalent statement without using the IN
operator:
WHERE dno = 11 OR dno = 44 OR dno = 55

BETWEEN Operator &
BETWEEN Predicate
The BETWEEN operator is used to specify a range
of values a column expression has to satisfy.
Employees whose salary range is 25000 to 75000:
SELECT ename, salary FROM emp
WHERE salary BETWEEN 25000 AND 75000
BETWEEN predicate or
Range search condition
The result includes end points of the range. The end points are
values 25000 and 75000 in the above example.

ORDER BY Clause for Sorting
Results
The ORDER BY clause is used to sort results of SELECT statements.
Syntax:
ORDER BY {{ column-name | column-number } [ ASC | DESC ] }
[, …]
column-number: serial number of a column expression in
SELECT clause
• The ORDER BY clause should be the last clause of a SELECT
statement.
• Column names should be in SELECT clause. But some RDBMSs allow
columns not in the SELECT clause.
• ASC causes results in ascending order of the column. This is default.
• DESC causes results in descending order of the column.
• Column numbers start from 1.

ORDER BY Clause Examples with
one column
Results in ascending order of values
of one column:
SELECT ename, salary, eno
FROM emp
ORDER BY ename
Results in descending order of values
of one column:
SELECT ename, salary, eno
FROM emp
ORDER BY ename DESC

two columns
Results in ascending order of values
of two columns:
SELECT salary, ename, eno
FROM emp
ORDER BY salary, ename
Results in descending order of
values of first column and
ascending order of second
column:
FROM emp
ORDER BY salary DESC,
ename ASC

Column Expression numbers
Ordering based on column numbers:
FROM emp
ORDER BY 1 DESC, 3 ASC
Ordering based on expressions:
SELECT salary, salary * 0.2,
ename, eno
FROM emp
ORDER BY 2 DESC, 1 ASC

SQL Aggregate Functions
 COUNT
 SUM
 AVG
 MAX
 MIN

SQL Aggregate Functions
An aggregate function gives one value from multiple values of a
column.
SQL standard defined aggregate functions are as follows:
SNO Aggregate
Function
Functionality
1 COUNT Returns number of values in a column or count of rows.
2 SUM Returns sum of the values of a numeric column.
3 AVG Returns average of values of a numeric column.
4 MIN Returns the smallest value in a column.
5 MAX Returns the largest value in a column.

SQL Aggregate Function Usage
SUM and AVG functions can be used on only numeric columns.
Each function takes one argument which should be a column name.
COUNT can be applied on all columns using COUNT(*) which will return
number of rows in a table as qualified by WHERE clause.
Except COUNT(*) all other aggregate functions ignore NULL values in
a column.
Aggregate functions can be used only in SELECT and HAVING clauses.
If SELECT clause contains any aggregate function, the select list can
contain only those columns used in GROUP BY clause in addition to
aggregate functions. It can not contain any other column references.

SQL Aggregate Function Examples:
COUNT with and without NULLs
The screen shot on the right side shows there are
6 employees in department 55 using a select
statement without using aggregate functions..
SELECT COUNT(ename)
FROM emp
WHERE dno = 55
SELECT COUNT(salary)
FROM emp
WHERE dno = 55
SELECT COUNT(*)
FROM emp
WHERE dno = 55;
Note that NULL values are
considered in the counts..

MAX, MIN, SUM & AVG
The screen shot shows there are 6
employees in department number 55.
SELECT MAX(salary), MIN(salary),
SUM(salary), AVG(salary)
FROM emp
WHERE dno = 55;
Note that NULL values are not considered
in computing aggregate values.
For example, we can find that AVG(salary) =
SUM(salary)/4 where the sum is divided by
the number of non-null values and not
number of all values in the column.

COUNT (DISTINCT…)
The screen shot shows there are 6
employees in department number
55.
SELECT
COUNT(DISTINCT designation),
COUNT(DISTINCT salary),
COUNT(DISTINCT mno)
FROM emp
WHERE dno = 55
Note that NULL values are not
considered in the counts with
DISTINCT.

Grouping Results
 Partitioning of Rows into Groups
 GROUP BY Clause
 Grouping Columns
 Aggregate Functions

GROUP BY clause
The GROUP BY clause groups results of a SELECT statement based on
grouping column list specified for the clause.
Syntax: GROUP BY grp_column_list
grp_column_list: List of comma separated column names.
Example:
SELECT dno, COUNT(eno), MAX(salary)
FROM emp
GROUP BY dno
This select statement outputs one row for each department containing
the department number, count of employees in the department and
maximum salary given in the department.
Grouping column list: dno

GROUP BY clause
examples
The following statement groups
employees by department
number:
SELECT dno, COUNT(eno),
MAX(salary)
FROM emp
GROUP BY dno
The following statement groups
employees by department number
and designation:
SELECT dno, designation,
COUNT(eno), MAX(salary)
FROM emp
GROUP BY dno, designation

GROUP BY clause:
Points to be noted
1. A query that contains GROUP BY clause is known as grouped
query.
2. Columns named in the GROUP BY clause are known as
grouping columns.
3. Each item (column or expression) in the SELECT clause must
be single valued per group. Hence the item has to be a
grouping column or an aggregate function. It is an error to
use non-grouping columns in the SELECT clause.
4. Grouping is done only after applying WHERE clause if it
exists in a SELECT statement.

Restricting Groups: HAVING clause
The HAVING clause is used to restrict resulting rows of the
GROUP BY clause.
Syntax: HAVING search-condition
The search condition is similar WHERE clause search condition.
Unlike WHERE clause search condition, the HAVING clause
search condition can contain aggregate functions.
If the search condition contains any predicate that does not
contain grouping columns or aggregate functions, such
predicate may be moved to WHERE clause.

HAVING clause example
The following statement restricts to groups having number of employees 4 or
more.
SELECT dno, COUNT(eno), MAX(salary)
FROM emp
GROUP BY dno
HAVING COUNT(eno) >= 4

Subqueries
 Subqueries: Scalar Subqueries, Row Subqueries,
Table Subqueries
 Quantifiers : ANY, SOME and ALL
 Predicate: IN, EXISTS and NOT EXISTS

Subqueries
Subquery is a query embedded in another query.
Subquery is also referred to as inner select, subselect or
nested query or nested statement.
The query that contains the subquery is called outer query or
outer statement.
Subqueries can be used in WHERE clause, HAVING clause and
SELECT clause of SELECT statements.
Subqueries can also be used in INSERT, UPDATE and DELETE
statements.

Types of Subqueries
Scalar subquery:
Returns only one column and one row; essentially one
value.
The query can be used in predicates as an operand for
relational operators =, !=, <, <=, > and >=.
Row subquery:
Returns multiple columns in one row.
Table subquery:
Returns multiple columns and multiple rows.

Example: Scalar Subquery in
WHERE clause
The following statement uses a scalar subquery that returns
department number of department “Products” to list all employees of
the department.
WHERE dno = (SELECT dno FROM dept WHERE dname=’Products’)

Example: Scalar Sub-query with
Aggregate function in WHERE clause
The following statement returns employees whose salary is
more than average salary of all employees using a scalar
subquery that returns average salary of all employees:
WHERE salary > (SELECT AVG(salary) FROM emp)

Example: Scalar Sub-query in
SELECT clause
The following statement returns employee name and difference
between salary and average salary of all those employees whose salary
is more than average salary:
SELECT ename, salary - (SELECT AVG(salary) FROM emp) AS SalDiff
FROM emp WHERE salary > (SELECT AVG(salary) FROM emp)

Example: Nested Subquery
The following statement returns number of employees whose buildings
are situated in Bangalore.
SELECT COUNT(*) FROM emp
WHERE dno IN (SELECT dno FROM dept
WHERE bno IN (SELECT bno FROM bldg
WHERE city =’Bangalore’))

Predicates with Quantifiers:
ANY, SOME and ALL
Keywords ANY, SOME and ALL are called quantifiers used to modify meaning of
relational operators in predicates that contain sub-queries.
Syntax: opd rel-oper { ANY | SOME | ALL } sub-query
opd is an operand which could be a literal, column or a scalar sub-query
or an expression containing them.
rel-oper is any relational operator >, >=, <, <=, =, !=
sub-query should project only one column but any number of rows.
If ANY or SOME quantifier is used, the predicate value is TRUE if it is satisfied with
any one value returned by the sub-query. Otherwise, it is false. If the sub-query does
not return any row, the predicate value is FALSE.
If ALL quantifier is used, the predicate value is TRUE if it is satisfied with all values
returned by the sub-query. Otherwise, it is false. If the sub-query does not return any
row, the predicate value is TRUE.

An Example using quantifier ANY
The following statement finds all employees who work in departments other than 55
and whose salary is greater than the salary of at least one employee of department
55:
SELECT ename, dno, salary FROM emp
WHERE dno != 55 AND
salary > ANY (SELECT salary FROM emp WHERE dno = 55)

An Example using quantifier: ALL
The following statement finds all employees who work in departments other than 55
and whose salary is greater than the salary of all employees of department 55:
SELECT ename, dno, salary FROM emp
WHERE dno != 55 AND
salary > ALL (SELECT salary FROM emp WHERE dno = 55)

Predicates EXISTS and NOT EXISTS
The predicates EXISTS and NOT EXISTS can be used only with sub-
queries.
Syntax: WHERE EXISTS sub-query
WHERE NOT EXISTS sub-query
The predicate EXISTS evaluates to true if the sub-query returns at least
one row. Otherwise it evaluates to false.
The predicate NOT EXISTS is true if the sub-query does not return any
row, i.e., it returns empty result set. False otherwise. The behavior is
opposite of EXISTS predicate.
The sub-query can project one or more columns or expressions.

Examples of predicates EXISTS and
NOT EXISTS
Find cities where company
departments are located.
SELECT DISTINCT b.city
FROM bldg b
WHERE EXISTS
(SELECT * FROM dept d
WHERE d.bno = b.bno)
Find cities that do not yet
have a company department:
SELECT DISTINCT b.city
FROM bldg b
WHERE NOT EXISTS
(SELECT * FROM dept d
WHERE d.bno = b.bno);

Sub-query Points to Remember
• Scalar subqueries need to be used with relational operators and in
all places in an SQL statement where only one value is expected.
• Quantifiers can be used only with relational operators.
• Subqueries used with Quantifiers as well as IN operator must be
table subqueries with one result column.
• Subqueries used with EXISTS and NOT EXISTS predicates can be
any kind of subqueries.
• ORDER BY clause may not be allowed inside sub-queries. Some
RDBMSs allow the clause as it makes sense if TOP clause is used in
the SELECT clause.

Multi-Table Queries (JOINS)
 Table List & Table Alias
 Equi-joins
 Sorting and Grouping Result sets
 Cartesian Product & Cross Join
 Inner Joins
 Outer Joins
 Left Outer Join, Right Outer Join and Full Outer Join

Multi-Table Queries or
JOINs
The multi-table queries involve more than one table in the FROM
clause of SELECT statements which combine columns of the tables
and output specified columns as per the select-list of the
statements.
The operation used for combing columns is called join operation.
The join operation on two tables gives rows
where each row consists of required columns of a row of a table
and required columns of rows of another table such that
specified predicates
where each predicate containing columns of the two tables are
satisfied.

Table List & Table Alias
Table List in the FROM clause is separated by comma.
Each table can be optionally followed by an alias which can be
used wherever table name is required.
An alias can be used as a qualifier for column name in order to
use the alias as shorthand for table name and/or to disambiguate
column names which could be same in multiple tables.
In order to use an alias for a column, prefix column name with
the alias separated by a dot.
Example: t1.c1

Two Table Join with equal-to
predicate : Equi-Join
List names of employees and departments they work for:
SELECT e.ename, d.dname FROM emp e, dept d
WHERE e.dno = d.dno

Two Table Join – Sorting results
List names of employees and departments they work for in the
ascending order of department name and employee name in each
department:
SELECT e.ename, d.dname FROM emp e, dept d
WHERE e.dno = d.dno ORDER BY d.dname, e.ename

Two Table Join –
Grouping results
Find number of employees in each department:
SELECT d.dname AS ’Department’,
COUNT(*) AS ’Number of Employees’
FROM emp e, dept d
WHERE e.dno = d.dno GROUP BY d.dname ORDER BY d.dname

Three Table Join
Find city and department for each employee:
SELECT b.city AS ’City’, d.dname AS ’Department’,
e.ename AS ’Employee’
FROM emp e, dept d, bldg b
WHERE e.dno = d.dno AND d.bno = b.bno ORDER BY 1, 2, 3

Cartesian Product using
CROSS JOIN
The Cartesian product of two tables is another table consisting of
all possible pairs of rows from the two tables.
Syntax: table1 CROSS JOIN table2
The columns of the Cartesian product consist of all columns of the
table1 followed by all columns of the table2.
If a join condition (in WHERE clause) is not specified for two tables in
a two table join, the Cartesian product is
produced.
Example:
A B
a1 b1
a2 b2
a3 b3
C D E
c1 d1 e1
c2 d2 e2
A B C D E
a1 b1 c1 d1 e1
a1 b1 c2 d2 e2
a2 b2 c1 d1 e1
a2 b2 c2 d2 e2
a3 b3 c1 d1 e1
a3 b3 c2 d2 e2
CROSS JOIN =A, B, C, D and
E are names
of columns.

Cartesian Product – Example
Find Cartesian product of emp and dept tables.
SELECT * FROM emp CROSS JOIN dept;
=
…
Tables: emp and dept
Result set

INNER JOINS and OUTER JOINS
Inner Join:
So far whatever joins we have talked about are essentially inner
joins. An inner join outputs rows from two tables that match the join
condition.
Inner joins can be written using list of tables, INNER JOIN keyword
or just JOIN keyword.
Outer Join:
An outer join returns rows that not only match the join condition but
also those that do not match the join condition.
There are three types of outer joins: LEFT OUTER JOIN, RIGHT
OUTER JOIN and FULL OUTER JOIN.

INNER JOIN with List of Tables
The simplest way to write an inner join query is to have a comma
separated list of required tables in the FROM clause of a query.
This syntax is already familiar to you.
Example: SELECT ot1.*, ot2.* FROM ot1, ot2
WHERE ot1.b = ot2.b;
Note that row <a4, NULL> of table ot1 does not match with
any row of table ot2 even though column b of table ot2 has
NULL values in two rows because NULL values can not be
compared; NULL is an unknown value.

Inner Join with key words
INNER & JOIN
If you want to write an inner join query that explicitly shows that
it is such a query, use the keywords INNER and JOIN as shown in
the following example:
SELECT ot1.*, ot2.*
FROM ot1 INNER JOIN ot2
Or
SELECT ot1.*, ot2.*
FROM ot1 JOIN ot2
Use of keyword INNER is optional.

LEFT OUTER JOIN
A left outer join of two tables returns rows that match specified join
condition between the two tables as well as non-matching rows from
the left table of the join. Values for the columns of the right table of
the join will receive NULL values for the non-matching rows of the
left table of the join. Here is an example:
SELECT t1.*, t2.*
FROM t1 LEFT OUTER JOIN t2
ON t1.b = t2.b;
•Keyword OUTER is optional.
•ON keyword is used to specify the outer join condition.
Only rows <a1,b1> and <a3,b3> of
t1 have matching rows in t2 based
on the join condition.
As it is left outer join , remaining
rows of t1 (<a2,b2> and <a4,
NULL>) have NULL values for
columns b and c of t2.

RIGHT OUTER JOIN
A right outer join of two tables returns rows that match specified join
condition between the two tables as well as non-matching rows from
the right table of the join. Values for the columns of the left table of
the join will receive NULL values for the non-matching rows of the
right table of the join. Here is an example:
SELECT t1.*, t2.*
FROM t1 RIGHT OUTER JOIN t2
ON t1.b = t2.b;
•ON keyword is used to specify the outer join condition.
Only rows <b1,c1> and <b3,c3> of
t2 have matching rows in t1 based
on the join condition.
As it is right outer join , remaining
rows of t2 (<NULL,c2> , <NULL, c4>
and <b5,c5>) have NULL values for
columns a and b of t1.

FULL OUTER JOIN
A full outer join of two tables returns rows that match specified join condition
between the two tables as well as non-matching rows from the both tables of
the join. Values for the columns of the left table of the join will receive NULL
values for the non-matching rows of the right table of the join and vice versa.
Here is an example:
SELECT t1.*, t2.* FROM t1 FULL OUTER JOIN t2 ON t1.b = t2.b
In the result of the full outer join,
•1st and 5th rows are the matching rows.
•6th and 7th rows are non-matching rows
from t1 and they have NULLs for columns
of t2.
•2nd,3rd and 4th rows are non-matching
rows from t2 and they have NULLs for
columns of t1.
•ON keyword is used to specify the outer
join condition.
A B
a1 b1
a2 b2
a3 b3
a4 -
t1 t2
Result
B C
b1 c1
- c2
b3 c3
- c4
b5 c5
A B B C
a1 b1 b1 c1
- - - c2
- - - c4
- - b5 c5
a3 b3 b3 c3
a4 - - -
a2 b2 - -

Outer Join support
All database systems may not support all outer joins.
MySQL does not support full outer join. Oracle database supports it.
The full outer join can be simulated using left and right outer joins as following:
SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.b = t2.b
UNION
SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.b = t2.b

SET Operations
 UNION
 INTERSECT
 EXCEPT (MINUS)

SET Operations
The set operations are used to combine results returned by other
SELECT statements. These operations are
UNION, INTERSECT and EXCEPT
Each operation takes two table operands which are the result sets of
SELECT statements.
The two tables must be union-compatible, i.e., they should have the
same data structure and hence the same number of columns and the
same data types and lengths.
Of course most RDBMSs relax above condition. For example, two
corresponding columns of two operands need not have the same data
type as long as they are compatible.

UNION Operation
The UNION of two tables is a table containing all rows of both the
tables.
Set representation of UNION of table A and table B: A ∪ B
A
B
Graphical representation:Example:
SELECT a, b FROM t1
UNION
SELECT c, b FROM t2

UNION Operation:
DISTINCT and ALL rows
By default the result table of UNION contains distinct rows as shown
in the following example:
Example 1:
SELECT b FROM t1
UNION
SELECT b FROM t2
To get all rows from both the tables including duplicates use keyword
ALL after keyword UNION as shown in the
example:
Example 2:
SELECT b FROM t1
UNION ALL
SELECT b FROM t2

INTERSECT Operation
The INTERSECT operation of two tables is a table containing all rows
common to both the tables.
Set representation of INTERSECT of table T1 and table T2: T1 ∩ T2
T1 T2
Graphical representation
Example:
SELECT B FROM T1
INTERSECT
SELECT B FROM T2
B
b1
b3
-
A B
a1 b1
a2 b2
a3 b3
a4 -
B C
b1 c1
- c2
- c4
b5 c5
b3 c3
T1 T2 Result
Note:-The tables and result shown on the
right side are from Oracle RDBMS. MySQL
does not support INTERSECT set operation.

EXCEPT Operation
The EXCEPT operation of two tables is a table containing all rows
that are in the first table but are not in the second table. Keyword
used for the operation in old SQL standard is MINUS.
Set representation of EXCEPT of table T1 and table T2: T1 − T2
This is essentially set difference.
T1
T2
Graphical representation
Example:
SELECT B FROM T1
MINUS
SELECT B FROM T2
A B
a1 b1
a2 b2
a3 b3
a4 -
B C
b1 c1
- c2
- c4
b5 c5
b3 c3
T1 T2 Result
Note:-The tables and result shown on the
right side are from Oracle RDBMS. MySQL
does not support EXCEPT set operation.
Oracle does not recognize new keyword
EXCEPT.
B
b2

What You Have Learnt!
 How to add rows to a table using INSERT statements.
 How to modify rows using UPDATE statements.
 How to delete rows using DELETE statements.
 How to retrieve rows using SELECT statements.
 Retrieving DISTINCT rows and ALL rows.
 Retrieving rows satisfying a search condition of WHERE
clause.
 Logical operators AND, OR and NOT.
 Relational operators =, !=, <>, <, <=, > and >=.
 Predicates NULL, LIKE, IN and BETWEEN.
 Sorting result set rows using ORDER BY clause.
 Aggregate functions COUNT, SUM, AVG, MAX and MIN and
behavior of these functions in the presence of NULL values.
 Grouping results using GROUP BY clause.
 Restricting grouped results using HAVING Clause.

What You Have Learnt !
(contd…)
 Subqueries – Scalar subqueries, row subqueries and table
subqueries.
 Usage of Quantifiers ALL, ANY and SOME in predicates
containing subqueries.
 Predicates EXISTS and NOT EXISTS.
 Multi-table Joins.
 Cartesian Product and Cross join.
 Inner joins and outer joins.
 Left outer joins, right outer joins and full outer joins.
 Set operators UNION, INTERSECT and EXCEPT (MINUS).

Database Systems - SQL - DDL Statements (Chapter 3/3)

More Related Content

What's hot (17)

Viewers also liked (20)

Similar to Database Systems - SQL - DDL Statements (Chapter 3/3) (20)

More from Vidyasagar Mundroy (6)

Recently uploaded (20)

Database Systems - SQL - DDL Statements (Chapter 3/3)