Dr.RAJASHEKAR. K.J, Professor & Head , ISE . 4th Sem B.E.

, ISE BCS403-DBMS| Notes

KIT
SQL
Summary
SQL Data Definition and Data Types; Specifying basic constraints in SQL; Schema change statements in
SQL; Basic queries in SQL; More complex SQL Queries. Insert, Delete and Update statements in SQL;
Triggers Views (Virtual Tables) in SQL; Additional features of SQL; Database programming issues and
techniques; Embedded SQL, Dynamic SQL; Database stored procedures and SQL.

 SQL: Structured Query Language

 Pronounced as SEQUEL: Structured English QUEry Language
 Pure non-procedural query language
 Designed and developed by IBM, Implemented by Oracle
 1978 System/R IBM- 1st Relational DBMS
 1979 Oracle and Ingres
 1982 SQL/DS and DB2 IBM
 Accepted by both ANSI + ISO as Standard Query Language for any RDBMS
- SQL86 (SQL1) : first by ANSI and ratified by ISO (SQL-87), minor revision on 89 (SQL-89)
- SQL92 (SQL2) : major revision
- SQL99 (SQL3) : add recursive query, trigger, some OO features, and non-scholar type
- SQL2003 : XML, Window functions, and sequences (Not free)
 Supports all the three sublanguages of DBMS: DDL, DML, DCL
 Supports Aggregate functions, String Manipulation functions, Set theory operations, Date
Manipulation functions, rich set of operators ( IN, BETWEEN, LIKE, IS NULL, EXISTS)
 Supports REPORT writing features and Forms for designing GUI based applications
Data Definition, Constraints, and Schema Changes
- Used to CREATE, ALTER, and DROP the descriptions of the database tables (relations)
- Data Definition in SQL
CREATE
ALTER
DROP
table .............................................................. relation
row................................................................ tuple
column… ...................................................... attribute
Data Types
 Numeric: NUMBER, NUMBER(s,p), INTEGER, INT, FLOAT, DECIMAL
 Character: CHAR(n), VARCHAR(n), VARCHAR2(n), CHAR VARYING(n)
 Bit String: BLOB, CLOB
 Boolean: true, false, and null
 Date and Time: DATE (YYYY-MM-DD) TIME( HH:MM:SS)
 Timestamp: DATE + TIME
 USER Defined types
CREATE SCHEMA
- Specifies a new database schema by giving it a name
Ex: CREATE SCHEMA COMPANY AUTHORIZATION Jsmith;

CREATE TABLE
- Specifies a new base relation by giving it a name, and specifying each of its attributes and their data
types
- Syntax of CREATE Command:
Dr.RAJASHEKAR. K.J, Professor & Head , ISE . 4th Sem B.E., ISE BCS403-DBMS| Notes
KIT
CREATE TABLE <table name> ( <Attribute A1> <Data Type D1> [< Constarints>],
<Attribute A2> <Data Type D2> [< Constarints>],
…….
<Attribute An> <Data Type Dn> [< Constarints>],
[<integrity-constraint1>, <integrity-constraint k> ] );
- A constraint NOT NULL may be specified on an attribute
Ex: CREATE TABLE DEPARTMENT (
DNAME VARCHAR(10) NOT NULL,
DNUMBER INTEGER NOT NULL,
MGRSSN CHAR(9),
MGRSTARTDATE CHAR(9) );
- Specifying the unique, primary key attributes, secondary keys, and referential integrity constraints
(foreign keys).
Ex: CREATE TABLE DEPT (
DNAME VARCHAR(10) NOT NULL,
DNUMBER INTEGER NOT NULL,
MGRSSN CHAR(9),
MGRSTARTDATE CHAR(9),
PRIMARY KEY (DNUMBER),
UNIQUE (DNAME),
FOREIGN KEY (MGRSSN) REFERENCES EMP(SSN));
- We can specify RESTRICT, CASCADE, SET NULL or SET DEFAULT on referential integrity
constraints (foreign keys)
Ex: CREATE TABLE DEPT (
DNAME VARCHAR(10) NOT NULL,
DNUMBER INTEGER NOT NULL,
MGRSSN CHAR(9),
MGRSTARTDATE CHAR(9),
PRIMARY KEY (DNUMBER),
UNIQUE (DNAME),
FOREIGN KEY (MGRSSN) REFERENCES EMP
ON DELETE SET DEFAULT ON UPDATE CASCADE);
Ex: CREATE TABLE EMP(
ENAME VARCHAR(30)NOT NULL,
ESSN CHAR(9),
BDATE DATE,
DNO INTEGER DEFAULT 1,
SUPERSSN CHAR(9),
PRIMARY KEY (ESSN),
FOREIGN KEY (DNO) REFERENCES DEPT (Dnumber)
ON DELETE SET DEFAULT ON UPDATE CASCADE,
FOREIGN KEY (SUPERSSN) REFERENCES EMP (Ssn) ON DELETE SET NULL ON UPDATE
CASCADE);

DROP TABLE
- Used to remove a relation (base table) and its definition
- The relation can no longer be used in queries, updates, or any other commands since its description no
longer exists
- Example: DROP TABLE DEPENDENT;
Dr.RAJASHEKAR. K.J, Professor & Head , ISE . 4th Sem B.E., ISE BCS403-DBMS| Notes
KIT
ALTER TABLE:
-- Used to add an attribute to/from one of the base relations
drop constraint
-- The new attribute will have NULLs in all the tuples of the relation right after the command is executed;
hence, the NOT NULL constraint is not allowed for such an attribute.
Example:
ALTER TABLE EMPLOYEE ADD JOB VARCHAR2(12);
-- The database users must still enter a value for the new attribute JOB for each EMPLOYEE tuple. This can
be done using the UPDATE command.
DROP a column (an attribute)
ALTER TABLE COMPANY.EMPLOYEE DROP ADDRESS CASCADE;
All constraints and views that reference the column are dropped automatically, along with the column.
ALTER TABLE COMPANY.EMPLOYEE DROP ADDRESS RESTRICT;
Successful if no views or constraints reference the column.
ALTER TABLE COMPANY.DEPARTMENT ALTER MGRSSN DROP DEFAULT;
ALTER TABLE COMPANY.DEPARTMENT ALTER MGRSSN SET DEFAULT “333445555”;

Basic Queries in SQL

- SQL has one basic statement for retrieving information from a database; the SLELECT statement
- This is not the same as the SELECT operation of the relational algebra
- Important distinction between SQL and the formal relational model;
- SQL allows a table (relation) to have two or more tuples that are identical in all their attribute
values
- Hence, an SQL relation (table) is a multi-set (sometimes called a bag) of tuples; it is not a set
of tuples
- SQL relations can be constrained to be sets by using the CREATE UNIQUE INDEX command, or by
using the DISTINCT option
- Basic form of the SQL SELECT statement is called a mapping of a SELECT-FROM-WHERE block
SELECT <attribute list>
FROM <table list>
WHERE <condition>
<attribute list> is a list of attribute names whose values are to be retrieved by the query
<table list > is a list of the relation names required to process the query
<condition> is a conditional (Boolean) expression that identifies the tuples to be retrieved by the query
Simple SQL Queries
 Basic SQL queries correspond to using the following operations of the relational algebra:
- SELECT
- PROJECT
- JOIN
 All subsequent examples use the COMPANY database as shown below
Dr.RAJASHEKAR. K.J, Professor & Head , ISE . 4th Sem B.E., ISE BCS403-DBMS| Notes
KIT
Dr.RAJASHEKAR. K.J, Professor & Head , ISE . 4th Sem B.E., ISE BCS403-DBMS| Notes
KIT
 Example of a simple query on one relation
Query 0: Retrieve the birthdate and address of the employee whose name is 'John B. Smith'.
Q0: SELECT BDATE, ADDRESS
FROM EMPLOYEE
WHERE FNAME='John' AND MINIT='B’ AND LNAME='Smith’
- Similar to a SELECT-PROJECT pair of relational algebra operations: The SELECT-clause
specifies the projection attributes and the WHERE-clause specifies the selection condition
- However, the result of the query may contain duplicate tuples
 Example of a simple query on two relations
Query 1: Retrieve the name and address of all employees who work for the 'Research' department.
Q1: SELECT FNAME, LNAME, ADDRESS
FROM EMPLOYEE, DEPARTMENT
WHERE DNAME='Research' AND DNUMBER=DNO
- Similar to a SELECT-PROJECT-JOIN sequence of relational algebra operations
- (DNAME='Research') is a selection condition (corresponds to a SELECT operation in
relational algebra)
- (DNUMBER=DNO) is a join condition (corresponds to a JOIN operation in relational algebra)
 Example of a simple query on three relations
Query 2: For every project located in 'Stafford', list the project number, the controlling department
number, and the department manager's last name, address, and birthdate.
Q2: SELECT PNUMBER, DNUM, LNAME, BDATE, ADDRESS
FROM PROJECT, DEPARTMENT, EMPLOYEE
WHERE DNUM=DNUMBER AND MGRSSN=SSN
AND PLOCATION='Stafford'
- In Q2, there are two join conditions
- The join condition DNUM=DNUMBER relates a project to its controlling department
- The join condition MGRSSN=SSN relates the controlling department to the employee who
manages that department

Aliases, * and DISTINCT, Empty WHERE-clause

 In SQL, we can use the same name for two (or more) attributes as long as the attributes are in different
relations
 A query that refers to two or more attributes with the same name must qualify the attribute name with
the relation name by prefixing the relation name to the attribute name
Example: EMPLOYEE.LNAME, DEPARTMENT.DNAME
 Some queries need to refer to the same relation twice. In this case, aliases are given to the relation
name
Query 3: For each employee, retrieve the employee's name, and the name of his or her immediate
supervisor.

Q3: SELECT E.FNAME, E.LNAME, S.FNAME, S.LNAME

FROM EMPLOYEE E S
WHERE E.SUPERSSN=S.SSN
- In Q3, the alternate relation names E and S are called aliases or tuple variables for the
EMPLOYEE relation
- We can think of E and S as two different copies of EMPLOYEE; E represents employees in
role of supervisees and S represents employees in role of supervisors
- Aliasing can also be used in any SQL query for convenience. Can also use the AS keyword to
specify aliases
Dr.RAJASHEKAR. K.J, Professor & Head , ISE . 4th Sem B.E., ISE BCS403-DBMS| Notes
KIT

Q3: SELECT E.FNAME, E.LNAME, S.FNAME, S.LNAME

FROM EMPLOYEE AS E, EMPLOYEE AS S
WHERE E.SUPERSSN=S.SSN

UNSPECIFIED WHERE-clause
 A missing WHERE-clause indicates no condition; hence, all tuples of the relations in the FROM-
clause are selected
- This is equivalent to the condition WHERE TRUE
Query 4: Retrieve the SSN values for all employees.
Q4: SELECT SSN
FROM EMPLOYEE
 If more than one relation is specified in the FROM-clause and there is no join condition, then the
CARTESIAN PRODUCT of tuples is selected
Example:
Q5: SELECT SSN, DNAME
FROM EMPLOYEE, DEPARTMENT
Note: It is extremely important not to overlook specifying any selection and join conditions in
the WHERE-clause; otherwise, incorrect and very large relations may result
USE OF *
 To retrieve all the attribute values of the selected tuples, a * is used, which stands for all the attributes
Examples:
Retrieve all the attribute values of EMPLOYEES who work in department 5.
Q1a: SELECT *
FROM EMPLOYEE
WHERE DNO=5
Retrieve all the attributes of an employee and attributes of DEPARTMENT he works in for every employee of
‘Research’ department.
Q1b: SELECT *
FROM EMPLOYEE, DEPARTMENT
WHERE DNAME='Research' AND DNO=DNUMBER
USE OF DISTINCT
 SQL does not treat a relation as a set; duplicate tuples can appear
 To eliminate duplicate tuples in a query result, the keyword DISTINCT is used
For example, the result of Q1c may have duplicate SALARY values whereas Q1d does not have any
duplicate values
Q1c: SELECT SALARY
FROM EMPLOYEE
Q1d: SELECT DISTINCT SALARY
FROM EMPLOYEE
SET OPERATIONS
 SQL has directly incorporated some set operations such as union operation (UNION), set difference
(MINUS) and intersection (INTERSECT) operations
 The resulting relations of these set operations are sets of tuples; duplicate tuples are eliminated from
the result
 The set operations apply only to union compatible relations; the two relations must have the same
attributes and the attributes must appear in the same order
Query 5: Make a list of all project numbers for projects that involve an employee whose last name is
'Smith' as a worker or as a manager of the department that controls the project.
Dr.RAJASHEKAR. K.J. Professor & Head, ISE 4th Sem B.E., ISE BCS403-DBMS| Notes,

Q5: (SELECT PNAME

FROM PROJECT, DEPARTMENT, EMPLOYEE
WHERE DNUM=DNUMBER AND MGRSSN=SSN AND LNAME='Smith')
UNION
(SELECT PNAME
FROM PROJECT, WORKS_ON, EMPLOYEE
WHERE PNUMBER=PNO AND ESSN=SSN AND NAME='Smith')

Specifying Updates in SQL

There are three SQL commands to modify the database: INSERT, DELETE, and UPDATE
INSERT
- In its simplest form, it is used to add one or more tuples to a relation
- Attribute values should be listed in the same order as the attributes were specified in the CREATE
TABLE command
Example:
INSERT INTO EMPLOYEE VALUES ('Richard','K','Marini', '653298653', '30-DEC-52',
'98 Oak Forest,Katy,TX', 'M', 37000,'987654321', 4 )
- An alternate form of INSERT specifies explicitly the attribute names that correspond to the values in
the new tuple. Attributes with NULL values can be left out
Example: Insert a tuple for a new EMPLOYEE for whom we only know the FNAME, LNAME, and
SSN attributes.
INSERT INTO EMPLOYEE (FNAME, LNAME, SSN)VALUES ('Richard', 'Marini', '653298653')
- Important Note: Only the constraints specified in the DDL commands are automatically enforced by
the DBMS when updates are applied to the database
- Another variation of INSERT allows insertion of multiple tuples resulting from a query into a relation
Example: Suppose we want to create a temporary table that has the name, number of employees, and
total salaries for each department. A table DEPTS_INFO is created first, and is loaded with the
summary information retrieved from the database by the query.
CREATE TABLE DEPTS_INFO
(DEPT_NAME VARCHAR(10),
NO_OF_EMPS INTEGER,
TOTAL_SAL INTEGER);
INSERT INTO DEPTS_INFO (DEPT_NAME, NO_OF_EMPS, TOTAL_SAL)
SELECT DNAME, COUNT (*), SUM (SALARY)
FROM DEPARTMENT, EMPLOYEE
WHERE DNUMBER=DNO
GROUP BY DNAME ;
Note: The DEPTS_INFO table may not be up-to-date if we change the tuples in either the
DEPARTMENT or the EMPLOYEE relations after issuing the above. We have to create a view (see
later) to keep such a table up to date.

DELETE
 Removes tuples from a relation
- Includes a WHERE-clause to select the tuples to be deleted
- Referential integrity should be enforced
- Tuples are deleted from only one table at a time (unless CASCADE is specified on a
referential integrity constraint)
- A missing WHERE-clause specifies that all tuples in the relation are to be deleted; the table
then becomes an empty table
Dr.RAJASHEKAR. K.J. Professor & Head, ISE 4th Sem B.E., ISE BCS403-DBMS| Notes,
- The number of tuples deleted depends on the number of tuples in the relation that satisfy the
WHERE-clause
Examples:
1: DELETE FROM EMPLOYEE WHERE LNAME='Brown’;
2: DELETE FROM EMPLOYEE WHERE SSN='123456789’;

3: DELETE FROM EMPLOYEE WHERE DNO IN

(SELECT DNUMBER FROM DEPARTMENT WHERE DNAME='Research');
4: DELETE FROM EMPLOYEE;

UPDATE
- Used to modify attribute values of one or more selected tuples
- A WHERE-clause selects the tuples to be modified
- An additional SET-clause specifies the attributes to be modified and their new values
- Each command modifies tuples in the same relation
- Referential integrity should be enforced
Example1: Change the location and controlling department number of project number 10 to 'Bellaire'
and 5, respectively.
UPDATE PROJECT SET PLOCATION = 'Bellaire', DNUM = 5 WHERE PNUMBER=10;
Example2: Give all employees in the 'Research' department a 10% raise in salary.
UPDATE EMPLOYEE SET SALARY = SALARY *1.1 WHERE DNO IN (SELECT DNUMBER
FROM DEPARTMENT WHERE DNAME='Research');

Recap of SQL Queries

 A query in SQL can consist of up to six clauses, but only the first two, SELECT and FROM, are
mandatory. The clauses are specified in the following order:
SELECT <attribute list>
FROM <table list>
[WHERE <condition>]
[GROUP BY <grouping attribute(s)>]
[HAVING <group condition>]
[ORDER BY <attribute list>]

 There are three SQL commands to modify the database: INSERT, DELETE, and UPDATE