This document provides an outline and overview of key concepts in SQL including: 1. Data types that can be used in SQL and considerations when choosing a data type. 2. The two basic classes of SQL - DDL (data definition language) for defining database objects and DML (data manipulation language) for manipulating data. 3. Key DDL operations like CREATE, ALTER, and DROP for creating, modifying and deleting database objects as well as creating primary keys, foreign keys, views and more.

1. SQL
Chapter 8
1

2. Outline
• Data types
• DDL
• Views
• DML
2

3. One preliminary note..
• SQL is case insensitive!!
CREATE TABLE = create table = CreAte TAblE
• Quoted text, however, is case sensitive
“Payroll” != “payroll”
3

4. Data Types
• Each data item has an associated data type
– Integer, Char, Date …
• the data type determines the range of values &
the set of operators and functions that apply to
it.
4

5. Data Types (choose carefully!)
Data Types
UDT
Binary Character Numeric
String DateTime
String
date time timestamp
INT DECIMAL
CHAR CLOB
BLOB
VARCHAR
5

6. Data Types
• Some data types require additional
information
– decimal(p, s) with precision p & scale s
– char(n) where n is the (fixed) length of the
string
– varchar(n) where n is the max characters in
the string
– ……..
6

7. 2 Basic SQL Classes
• DDL = Data Definition Language
• DML = Data Manipulation Language
7

8. SQL DDL Operations...
• CREATE
– CREATE <database object>
• database, table, index, schema, view, alias, trigger
• DELETE
– DROP <database object>
• database, table, index, schema, view, alias, trigger,
• MODIFY
– ALTER <database object> …
• table
8

9. Create Table
CREATE TABLE student (
Number INTEGER,
Name VARCHAR(50),
Street VARCHAR(20),
City VARCHAR(20),
PostalCode CHAR(7),
Date_of_birth DATE);
Create Table is the most fundamental
DDL statement in SQL
9

10. Primary Keys
CREATE TABLE student (
Number INTEGER,
Name VARCHAR(50),
Street VARCHAR(20),
City VARCHAR(20),
PostalCode CHAR(7),
Date_of_birth DATE,
PRIMARY KEY (Number));
• many attributes can have unique
constraints but there is only one primary
key.
10

11. Primary Keys (cont’d)
CREATE TABLE student (
Number INTEGER PRIMARY KEY ,
Name VARCHAR(50) NOT NULL,
Street VARCHAR(20),
City VARCHAR(20) NOT NULL,
Postal Code CHAR(7) NOT NULL
Date_of_birth DATE NOT NULL);
•The primary key can be defined immediately
after the attribute if it is a single attribute primary
key.
11

12. Foreign Keys
CREATE TABLE Projects(
Code CHAR(4) PRIMARY KEY,
Name VARCHAR(30) NOT NULL,
Start_date Date,
End_Date Date,
dnum INTEGER,
FOREIGN KEY (dnum) REFERENCES Department);
• The table referenced by a foreign key must have
already been created
• If it hasn’t been, you can alter the table later to include
the foreign key. This solves the “circular reference”
problem.
12

13. Default Values
CREATE TABLE faculty(
Number INTEGER NOT NULL PRIMARY KEY,
Name VARCHAR(50) NOT NULL,
Rank VARCHAR(15) default “Assistant”,
Phone VARCHAR(15),
Office VARCHAR(10),
Email VARCHAR(30),
Dcode CHAR(4)REFERENCES department);
• A default value can be specified for an attribute
if its value is unknown
• Note: a default value cannot be used for a
primary key…why not?
13

14. Dropping an Object (con’t)
• When dropping an object, you may affect
other objects that depend on it.
– Eg. A view is defined using one or several
base tables. If one of these base tables is
dropped, the view is no longer valid.
• In some cases, the system repairs the
damage, in other cases you may not be
allowed to drop an object.
14

15. Modifying An Object
ALTER TABLE course
ADD status CHAR(5);
ALTER TABLE faculty
MODIFY email VARCHAR(75);
ALTER TABLE faculty
DROP PRIMARY KEY;
• ALTER can be used to add columns, to increase the
length of an existing VARCHAR attribute or to add
or delete constraints
• In other cases, you need to drop the table &
recreate it.
15

16. Views
• Views are “virtual” tables derived from
tables which exist in the database.
• Might be defined to omit some data from a
table (for privacy), to combine two (or
more tables) to contain summary data.
16

17. Views
• we say that the tables defined in the schema
are base tables
• eg. course, section, faculty, department
• a view is a virtual table (ie. it does not
physically exist in the database)
– derived from one or more base tables
– adapts the DB to the application without
modification
– CREATE VIEW V1 AS <SELECT CLAUSE>
17

18. Student ( number, street, city, province, postal_code,
name, date_of_birth)
Faculty (number, name, rank, phone, office, email,
dcode, salary)
Department (code, name, start_date, end_date, fnum)
Section (number, cnum, dcode, term, slot, faculty_num)
Course (number , dcode, title, description)
Enrolled (student_num, section_num, cnum, dcode)
Dept_phones (dcode, phone_number)
18

19. • Create a view thirdOffered which gives the
dcode & couses whose number lise between
3000 & 3999
CREATE VIEW thirdOffered AS
SELECT number, dcode
FROM course
WHERE number >=3000
AND number <= 3999
• thirdOffered is a window on the course
table
– changes to course are visible in thirdOffered
– changes to thirdOffered are applied to base 19
tables

20. • Create a view ClassList which gives student
number and name those who are enrolled for the
course 3753 and section ‘X1’.
CREATE VIEW ClassList AS
SELECT student.Number, student.Name
FROM student, enrolled
WHERE student_num = number
AND cnum = 3753
AND section_num = ‘X1’
• ClassList is a window on a join between student
and enrolled
– changes to either table are visible in ClassList
– changes to ClassList cannot be applied to base tables
20

21. Querying Views
SELECT *
FROM thirdOffered
WHERE dcode=‘COMP’
Implemented As
SELECT number, dcode
FROM course
WHERE number >=3000
AND number <= 3999
AND dcode=‘COMP’
21

22. Advantages of Views
• allows same data to be seen in different
ways by different users
• users perception of DB simplified
– complex tables are reduced to needed data
• automatic security for data outside view
– confidential data is left out of the view, making
it “secure” for people to see the needed info
22

23. View Update Problem
23

24. Example 1
INSERT INTO thirdOffered
VALUES (3754, ‘COMP’)
INSERT INTO course
VALUES (3754, ‘COMP’, NULL, NULL)
24

25. Example 2
CREATE VIEW offered AS
SELECT number
FROM course
WHERE dcode = ‘COMP’
What happens if we perform
INSERT INTO offered
VALUES (3754)
25

26. Updating Views
• Is somewhat complicated – sometimes
you can do it, and sometimes you can’t.
• Generally, an update to a view from a
single table with no aggregate functions
and including the primary (or candidate)
keys is possible.
• Constraints concerning not null fields may
cause the view update to fail.
26

27. Updating Views (cont’d)
• Views created from two or more tables
involving a join cannot be updated.
• Views containing aggregate functions or
grouping cannot be updated.
27

28. DML
28

29. Our database (simple version)
Student ( number, street, city, province, postal_code,
name, date_of_birth)
Faculty (number, name, rank, phone, office, email,
dcode, salary)
Department (code, name, start_date, end_date, fnum)
Section (number, cnum, dcode, term, slot, faculty_num)
Course (number , dcode, title, description)
Enrolled (student_num, section_num, cnum, dcode)
Dept_phones (dcode, phone_number)
29

30. DML - Data Manipulation
Language
• 4 main SQL statements:
– INSERT
– UPDATE
– DELETE
– SELECT
30

31. INSERT
INSERT INTO course VALUES
(3753, ‘COMP’, ‘DBMS’, ‘Database Management Systems’)
INSERT INTO course (number, dcode, title)
VALUES (3753, ‘COMP’, ‘DBMS’)
INSERT INTO course (number, dcode, title)
VALUES (3753, ‘COMP’, ‘DBMS’),
(3713, ‘COMP’, ‘OS’)
INSERT INTO course
VALUES (&number, &dcode, &title, &description)
31

32. UPDATE
UPDATE course
SET description = ‘A fun course!’
WHERE title = ‘DBMS’
UPDATE course
SET description = ‘A fun course!’
WHERE number = 3753 AND
dcode = ‘COMP’
32

33. DELETE
DELETE FROM course
•deletes the whole table
DELETE FROM course where dcode=‘HIST’
•deletes the tuples where dcode=‘HIST’
33

34. Queries (SELECT)
• Retrieval of some information from the
database
• Result Set contains the “answer” for the
query.
• Result “Sets” can contain duplicate rows
• Single value Result Sets are considered to
be one row with one column
• Result Sets can be empty
34

35. Simple Format
SELECT <columns>
FROM <tables>
WHERE <condition>
Where:
•Columns = list of attributes to be retrieved
•Tables = list of relations needed to process the query
•Condition = a boolean expression that identifies which
tuples are to be retrieved
35

36. Example
SELECT <columns>
FROM <tables>
WHERE <condition>
Example:
SELECT title, description
FROM course
WHERE dcode=‘COMP’
36

37. Important to note ..
• SQL allows duplicate tuples in the result
set
• For example, retrieving “cnum” and
“dcode” from Section, we will get identical
tuples for courses with multiple sections.
37

38. Important Note #2
• If you are trying to select on a field where
the data type is VARCHAR(), then this
select will do:
– SELECT * FROM t1 WHERE name=‘BOB’
• If you are trying to select on a field where
the data type is CHAR(5), then this select
will do:
– SELECT * FROM t1 WHERE name=‘BOB ’
38

39. Important Note #3
• Remember that selects on CHAR and
VARCHAR types are case sensitive. The
SELECTS:
– SELECT * FROM t1 WHERE name=‘BOB’
– SELECT * FROM t1 WHERE name=‘Bob’
– SELECT * FROM t1 WHERE name=‘BoB’
• are all different to the DBMS.
39

40. Example 1
List course number, department code, title
and description of each course.
SELECT number, dcode, title, description
FROM course
SELECT *
FROM course
40

41. Example 2
Find the faculty number and name of each
faculty member in Computer Science with
the rank of “Assistant”
SELECT number, name
FROM faculty
WHERE dcode = ‘COMP’ and rank = ‘Assistant’
41

42. Example #3
Which computer science courses are being
taught in the second term?
SELECT cnum
FROM section
WHERE dcode = ‘COMP’ and term = ‘X2’
42

43. Aggregate Functions
• Aggregate functions cannot be expressed
in regular relational algebra.
• Aggregate functions include simple
mathematical functions that are useful in a
DBMS environment such as:
– sum, average, maximum, minimum, count
43

44. Aggregate Functions (cont’d)
Find the average salary of associate
professors.
SELECT AVG(salary) AS AverageSalary
FROM faculty
WHERE rank=‘Associate’
•The result has one column called
“AverageSalary” with only one tuple.
44

45. Aggregate Functions (con’t)
How many professors make more than
$30,000?
SELECT COUNT(*) as NumProfs
FROM faculty
WHERE salary > 30000
•The result has one column called “NumProfs”
with only one tuple.
45

46. Aggregate Functions (con’t)
How many different salary levels are paid to
assistant professors?
SELECT COUNT(DISTINCT salary)
FROM faculty
WHERE rank = ‘Assistant’
•The result will be one column (which is
nameless) with one tuple.
46

47. Grouping
• Sometimes useful to group rows of a table
together then apply a function to each group
separately
• select rank wise minimum, maximum and avg
salary of faculty
SELECT rank, AVG(salary) AS AV, MIN(salary)AS MinSalary,
MAX(salary) AS MaxSalary FROM faculty
GROUP BY rank
• The result has 4 columns (rank, AV, MinSalary,
MaxSalary) and one tuple for each rank.
47

48. • select rank wise minimum, maximum and avg
salary of comp department faculties and their
avg salary is greater than 10000.
SELECT rank, AVG(salary) AS AV,
MIN(salary) AS MinSalary, MAX(salary) AS MaxSalary
FROM faculty
WHERE dcode = ‘comp’
GROUP BY rank
HAVING AV > 10000;
48

49. Expressions in SELECT
• What is the difference between the start
and end dates in the department table?
SELECT sdate, edate, (edate-sdate) AS TimeDiff
FROM department
•The result has 3 attributes (sdate, edate,
timeDiff)
•timeDiff is returned in a 8 digit number where
the
first 4 digits are the years, the next two are the
months, and the final two are the days.
49

50. The “Like” Predicate
Retrieve the average salary of professors
with offices in Carnegie Hall.
SELECT AVG(salary) AS CSalary
FROM faculty
WHERE office LIKE ‘CAR%’
50

51. Sorting
• rows of result relation can be sorted by
values in one or more columns
SELECT name, salary
FROM faculty
WHERE salary > 40000
ORDER BY salary
51

52. Sorting
Show all salaries less than 40000. Sort the
output according to salary.
SELECT * SELECT *
FROM faculty FROM faculty
WHERE salary < 40000 WHERE salary < 40000
ORDER BY salary ORDER BY salary DESC
Lowest to Highest Highest to Lowest
52

53. “IN”
• The “IN” clause is useful as it allows us to
match up on a set of data rather than just
a single piece of data.
• Assuming that the subquery will return
more than one item, we can match on
anything in the subquery.
53

54. Retrieval Using a Subquery
• Find Name & Salary of all department
heads
SELECT name, salary
FROM faculty
WHERE number
IN
(SELECT fnum
FROM department)
54

55. “EXISTS”
• We can check to see if a row exists in a
subquery.
• The subquery does not return any values
– only the existence of the row is checked.
• We can also use “NOT EXISTS” when the
cases arises.
55

56. EXISTS
• List the name, number and salary of all
professors who are not department heads.
SELECT name, number, salary
FROM faculty
WHERE NOT EXISTS
(SELECT *
FROM department
WHERE fnum = faculty.number)
56

57. Correlated subqueries
• A correlated sub-query is a sub-query (a query nested
inside another query) that uses values from the outer
query in its WHERE clause. The sub-query is evaluated
once for each row processed by the outer query.
• Example
• Find the list of employees (employee number and names)
having more salary than the average salary of all
employees in that employee's department.
SELECT employee_number, name
FROM employee AS e1
WHERE salary > (SELECT avg(salary) FROM
employee
WHERE department = e1.department);
57

58. • In the above query the outer query is
SELECT employee_number, name
FROM employee AS e1
WHERE salary >
• And the inner query is,
(SELECT avg(salary) FROM employee
WHERE department = e1.department);
• In the above nested query the inner query has to be
executed for every employee as the department will
change for every row.
• Hence the average salary will also change.
58

59. Join
q Find Name & Salary of all department
heads
SELECT name, salary
FROM faculty, department
WHERE faculty.number = department.fnum
For a join, you need to specify all the tables
which you will use in getting the information.
59

60. Join (con’t)
Find the course title, number and section for all
sections taught by department heads.
SELECT course.title, section.number, course.number,
course.dcode, faculty.name
FROM section, course,
department, faculty
WHERE section.cnum = course.number
AND section.dcode = department.dcode
AND department.fnum = faculty.number
60

61. Renaming (Aliasing)
Find the course title, number and section for all
sections taught by department heads.
SELECT C.title, S.number, C.number,
C.dcode, F.name
FROM section as S, course as C,
department as D, faculty as F
WHERE S.cnum = C.number
AND S.dcode = D.dcode
AND D.fnum = F.number
61

62. Set Operations
• Set operations DO exist in SQL
– UNION
– INTERSECT
– EXCEPT (difference)
62