SQL

Chapter 4: Intermediate SQL
Database System Concepts, 6th Ed.

Silberschatz, Korth and Sudarshan
See www.db-book.com for conditions on re-use
Chapter 4: Intermediate SQL

Join Expressions
Views
Transactions
Integrity Constraints
SQL Data Types and Schemas
Authorization
Database System Concepts - 6th Edition
4.2
Joined Relations
Join operations take two relations and return as a result
another relation.
These additional operations are typically used as subquery
expressions in the from clause
Join condition defines which tuples in the two relations
match, and what attributes are present in the result of the join.
Join type defines how tuples in each relation that do not
match any tuple in the other relation (based on the join

condition) are treated.
4.3
Full Outer Join

course natural full outer join prereq
4.4
Joined Relations Examples

course inner join prereq on
course.course_id = prereq.course_id
What is the difference between the above, and a natural join?

course left outer join prereq on
course.course_id = prereq.course_id
4.5
Joined Relations Examples

course natural right outer join prereq
course full outer join prereq using (course_id)
4.6
Views
In some cases, it is not desirable for all users to see the
entire logical model
Consider a person who needs to know an instructors name
and department, but not the salary. This person should see a
relation described, in SQL, by
select ID, name, dept_name
from instructor
A view provides a mechanism to hide certain data from the
view of certain users.
view :Any relation that is not in the conceptual model but is
made visible to a user as a virtual relation .
4.7
View Definition
A view is defined using the create view statement which has
the form
create view v as < query expression >

where <query expression> is any legal SQL expression. The
view name is represented by v.
Once a view is defined, the view name can be used to refer to
the virtual relation that the view generates.
View definition is not the same as creating a new relation by
evaluating the query expression
Rather, a view definition causes the saving of an expression;

the expression is substituted into queries using the view.
4.8
Example Views
A view of instructors without their salary
create view faculty as

select ID, name, dept_name
from instructor
Find all instructors in the Biology department
select name
from faculty
where dept_name = Biology
Create a view of department salary totals
create view departments_total_salary(dept_name, total_salary) as

select dept_name, sum (salary)
from instructor
group by dept_name;
4.9
Views Defined Using Other Views

create view physics_fall_2009 as
select course.course_id, sec_id, building, room_number

from course, section
where course.course_id = section.course_id
and course.dept_name = Physics
and section.semester = Fall
and section.year = 2009;
create view physics_fall_2009_watson as
select course_id, room_number

from physics_fall_2009
where building= Watson;
4.10
View Expansion
Expand a view in a query/another view
create view physics_fall_2009_watson as

(select course_id, room_number
from (select course.course_id, building, room_number
from course, section
where course.course_id = section.course_id
and course.dept_name = Physics
and section.semester = Fall
and section.year = 2009)
where building= Watson;
4.11
Views Defined Using Other Views

One view may be used in the expression defining another view
A view relation v1 is said to depend directly on a view relation
v2 if v2 is used in the expression defining v1
A view relation v1 is said to depend on view relation v2 if either
v1 depends directly to v2 or there is a path of dependencies
from v1 to v2
A view relation v is said to be recursive if it depends on itself.
4.12
View Expansion
A way to define the meaning of views defined in terms of other
views.
Let view v1 be defined by an expression e1 that may itself
contain uses of view relations.
View expansion- the process of replacing views by view
definitions following the path of view dependecies:
repeat
Find any view relation vi in e1
Replace the view relation vi by the expression defining vi
until no more view relations are present in e1
Note:As long as the view definitions are not recursive, this
loop will terminate
4.13
Update of a View
Add a new tuple to faculty view which we defined earlier
insert into faculty values (30765, Green, Music);

This insertion must be represented by the insertion of the tuple
(30765, Green, Music, null)
into the instructor relation
4.14
Some Updates cannot be Translated Uniquely
create view instructor_info as

select ID, name, building
from instructor, department
where instructor.dept_name= department.dept_name;
insert into instructor_info values (69987, White, Taylor);

which
what
department, if multiple departments in Taylor?
if no department is in Taylor?
Most SQL implementations allow updates only on simple views
The from clause has only one database relation.
The select clause contains only attribute names of the

relation, and does not have any expressions, aggregates, or
distinct specification.
Any attribute not listed in the select clause can be set to null
The query does not have a group by or having clause.
4.15
Materialized Views
Materializing a view: creates a physical table containing the tuples
of the view
Incrementally updated whenever the underlying relations are

updated .
Improves response time
Note: Create materialized views corresponding to Aggregate queries
that are frequently used by Applications/users
4.17
Transactions
Transaction-Unit of work-- consists of a sequence of query and/or
update statements
Transactions begin implicitly
Ended by commit work or rollback work
Commit work- the updates performed by the transaction become

permanent in the database
Rollback work - undoes all the updates performed by the SQL

statements in the transaction
By default : each SQL statement commits automatically
Can turn off auto commit for a session (e.g. using API)
In SQL:1999, can use: begin atomic . end
Not supported on most databases
4.18
Integrity constraints ensure that changes made by
authorized users do not violate consistency of database
Examples of integrity constraints:
An instructor name cannot be null.
No two instructors can have the same instructor ID.

Every department name in the course relation must
have a matching department name in the department

relation.
The budget of a department must be greater than

$0.00.
4.19
In general, an integrity constraint can be an arbitrary
predicate pertaining to the database. As arbitrary

predicates are costly to test , databases allow the integrity
constraints that can be tested with minimal overhead
declared as part of the create table

can also be added to an existing relation by using the
command alter table table-name add constraint
Integrity constraints on single table
not null
primary key
unique
check (P), where P is a predicate
4.20
Not Null and Unique Constraints

not null
prohibits the insertion of a null value for the attribute
Declare name and budget to be not null

name varchar(20) not null
budget numeric(12,2) not null
unique ( A1, A2, , Am)
Used to specify candidate key.
Null values are permitted.
4.21
The check clause

check (P)
where P is a predicate
Example: ensure that semester is one of fall, winter, spring

or summer:
create table section (
course_id varchar (8),
sec_id varchar (8),
semester varchar (6),
year numeric (4,0),
building varchar (15),
room_number varchar (7),
time slot id varchar (4),
primary key (course_id, sec_id, semester, year),
check (semester in (Fall, Winter, Spring, Summer))
);
4.22
The check clause

The predicate in the check clause can, according to the SQL
standard, be an arbitrary predicate that can include a subquery.

However, currently none of the widely used database products allows
the predicate to contain a sub query
check (time_slot_id in (select time_slot_id from time_slot))
Eg time-slots of two different subjects should not clash
A course should not be given more than four time slots
4.23
Referential Integrity
Ensures that a value that appears in one relation for a given
set of attributes also appears for a certain set of attributes in

another relation.
Usually specified as part of foreign key.

Values in child table refers values in parent table or takes a
null value
create table course (

course_id char(5) primary key,
title
varchar(20),
dept_name varchar(20) references department
)
Note: SQL also supports a version of the references clause where a
candidate key of the referenced relation is specified
4.24
SQL data definition for part of the

university database
create table classroom
(building varchar (15),

room number varchar (7),
capacity numeric (4,0),
primary key (building, room number))
create table department
(dept name varchar (20),
budget numeric (12,2) check (budget > 0),
primary key (dept name))
4.25

university database
create table course
(course id varchar (8),
title varchar (50),
dept name varchar (20),
credits numeric (2,0) check (credits > 0),
primary key (course id),
foreign key (dept name) references department)
create table instructor
(ID varchar (5),
name varchar (20), not null
salary numeric (8,2), check (salary > 29000),
primary key (ID),
foreign key (dept name) references department)
4.26

university database
create table section
(course id varchar (8),
sec id varchar (8),
semester varchar (6), check (semester in
(Fall, Winter, Spring, Summer),
year numeric (4,0), check (year > 1759 and year < 2100)
room number varchar (7),
time slot id varchar (4),
primary key (course id, sec id, semester, year),
foreign key (course id) references course,
foreign key (building, room number) references classroom)
4.27
Cascading Actions in Referential Integrity

a foreign key clause can specify that if a delete or update action
on the referenced relation violates the constraint, then instead of

rejecting the action, the system must take steps to change the
tuple in the referencing relation to satisfy the constraint
create table course (
dept_name varchar(20),
foreign key (dept_name) references department
on delete cascade
on update cascade,
...
)
alternative actions to cascade: set null, set default, restrict
In case of chain of cascade updates system may abort the
transaction
c
4.28
Integrity Constraint Violation During

Transactions
E.g.
create table person (

ID char(10),
name char(40),
mother char(10),
father char(10),
primary key ID,
foreign key father references person,
foreign key mother references person)
How to insert a tuple without causing constraint violation ?
insert father and mother of a person before inserting person
OR, set father and mother to null initially, update after inserting all
persons (not possible if father and mother attributes declared to be
not null)
OR defer constraint checking (next slide)
4.29
Integrity Constraint Violation During

Transactions
Specify the following options in the constraints
clause
initially deferred ( part of constraint clause)
Deferrable
(part of constraint clause)
set constraints constraint-list deferred as part of a

transaction clauses
4.30
Complex Check Clauses

Every section has at least one instructor teaching the section.
how to write this?
create assertion <assertion-name> check <predicate>;

For each tuple in the student relation, the value of the attribute tot cred
must equal the sum of credits of courses that the student has
completed successfully.
create assertion credits earned constraint check
(not exists (select ID
from student
where tot cred <> (select sum(credits)
from takes natural join course
Where grade is not null and grade<> F ) )
Also not supported by anyone
4.31
Index Creation
create table student
(ID varchar (5),

name varchar (20) not null,
dept_name varchar (20),
tot_cred numeric (3,0) default 0,
primary key (ID))
create index studentID_index on student(ID)

Indices are data structures used to speed up access to records
with specified values for index attributes
e.g. select *
from student
where ID = 12345
4.32
User-Defined Types
create type construct in SQL creates user-defined type
create type Dollars as numeric (12,2) final

create type Pounds as numeric(12,2) final;
SQL supports two forms of user defined types: Distinct types,
Structured types
Follows rules of strong type checking(name equivalence)
Use cast operator to perform operations

cast
(budget to numeric(12,2))+20
SQL provides drop type and alter type clauses to drop or
modify types that have been created earlier
4.33
Domains
create domain construct in SQL-92 creates user-defined
domain types
create domain person_name char(20) not null

Domains vs User defined Types:
Domains can have constraints and default values specified

on them
Domains are not strongly typed.
Note: support for types and domains varies from vendor to
vendor.
4.34
Large-Object Types
Large objects (photos, videos, CAD files, etc.) are stored as a
large object:
blob: binary large object -- object is a large collection of

uninterpreted binary data (whose interpretation is left to an
application outside of the database system)
clob: character large object -- object is a large collection of

character data
When a query returns a large object, a pointer(locator) is

returned rather than the large object itself.
4.35
Default Values
SQL allows a default value to be specified for an attribute
create table student

(ID varchar (5),
name varchar (20) not null,
tot cred numeric (3,0) default 0,
primary key (ID));
insert into student(ID, name, dept name)
values (12789, Newman, Comp. Sci.);
4.36
Create Table Extensions

Applications often require creation of tables that have the same
schema as an existing table
create table temp_instructor like instructor;
SQL:2003 provides a technique to create a table containing the results
of a query
create table t1 as
(select *
from instructor
where dept name= Music)
with data;
Note: create view vs create table as :contents of the table are set
when the table is created, whereas the contents of a view always

reflect the current query result.
4.37
Schemas, Catalogs, and Environments
a three-level hierarchy for naming relations
The top level of the hierarchy consists of catalogs, each of which

can contain schemas
SQL objects such as relations and views are contained within a
schema.
Used To identify a relation uniquely
catalog5.univ schema.course
different applications and different users can work independently
without worrying about name clashes
We can create and drop schemas by means of create schema and
drop schema statements
4.38
Schemas, Catalogs, and Environments

Each user has a default catalog and schema,
In order to perform any actions on a database, a user (or a program)
must first connect to the database by specifying user id and his

password
When a user connects to a database system, the default catalog and
schema are set up for the connection
The default catalog and schema are part of an SQL environment that
is set up for each connection
4.39
Authorization
Authorization control: ensures that only authorized users are
allowed to perform operations they are permitted to do.
Consists of following triple:
User----Operation------Database object
Authentication: done by user name and password

More complicated than OS as it includes many types of
objects
4.40
Authorization
Note: Also known as privilege
Forms of authorization on parts of the database such as relation/view:

Read -reading, but not modification .
Insert - insertion of new data, but not modification .
Update - modification, but not deletion .
Delete - allows deletion of data.
Forms of authorization to modify the database schema

Index - creation and deletion of indices.
Resources - creation of new relations.
Alteration - addition or deletion of attributes in a relation.
Drop - deletion of relations.
4.41
Privileges in SQL
select: same as read
eg
grant select on instructor to U1, U2, U3
insert: insert tuples

Update: use the SQL update statement
delete: delete tuples.
all privileges: short form for all the privileges
Note:A user who creates a new relation(owner) is given all
privileges on that relation automatically
4.42
Authorization Specification in SQL

The grant statement is used to confer authorization
grant <privilege list>

on <relation name or view name> to <user list>
<user list> is:
a user-id
public, which denotes all current and future users
A role
Granting a privilege on a view does not imply granting any
privileges on the underlying relations.
4.43
Authorization in SQL
Example:
grant select on department to Amit, Satoshi

grant update (budget) on department to Amit, Satoshi
Note: Attribute names can be specified with Insert and Update
privileges
By default, a user/role that is granted a privilege is not
authorized to grant that privilege to another user/role.
SQL allows a privilege grant to specify that the recipient may
further grant the privilege to another user.
Note: SQL does not permit authorizations on specific tuples of
a relation. Use application level security/ virtual private

databases
4.44
Authorization in SQL
4.45
Revoking Authorization in SQL

The revoke statement is used to revoke authorization.
revoke <privilege list>

on <relation name or view name> from <user list>
Example:
revoke select on department from Amit, Satoshi;

revoke update (budget) on department from Amit, Satoshi;
<privilege-list> may be all to revoke all privileges the revokee may
hold.
If <user-list> includes public, all users lose the privilege except the
owners.
If the same privilege was granted twice to the same user by
different grantees, the user may retain the privilege after the
revocation.
All privileges that depend on the privilege being revoked are also
revoked
4.46
4.47
4.48
4.49
Roles
4.50
Roles
create role instructor;

grant instructor to Amit;
Privileges can be granted to roles:
grant select on takes to instructor;
Roles can be granted to users, as well as to other roles
create role teaching_assistant
grant teaching_assistant to instructor;
Instructor inherits all privileges of teaching_assistant
Chain of roles
create role dean;
grant instructor to dean;
grant dean to Satoshi;
Note: When a user logs in to the database system, the actions executed by
the user during that session have all the privileges granted directly to
the user, and all privileges granted to roles that are granted to the
user
4.51
Authorization on Views
create view geo_instructor as
(select *
from instructor
where dept_name = Geology);
grant select on geo_instructor to geo_staf

Suppose that a geo_staf member issues
select *
from geo_instructor;
Note: the creator of the view must have select authorization on

the instructor relation.
geo_staf does not have permissions on instructor?
4.52
Authorizations on Schema
Only the owner of the schema can carry out any modification to
the schema
references privilege to create foreign key
grant reference (dept_name) on department to Mariano;
why is this required?
Foreignkey constraints restrict deletion and update operations

on the referenced relation
4.53
Transfer of Privileges
A user who has been granted some form of authorization may
be allowed to pass on this authorization to other users
grant select on department to Amit with grant option;
The passing of a specific authorization from one user to another

can be represented by an authorization graph
A user has an authorization if and only if there is a path from the

root of the authorization graph
4.54
If DBA revokes grant from U1:
Grant must be revoked from U4 but not from U5
Must prevent cycles of grant with no path from root:
DBA grants authorization to U7
U7 Grants authorization to U8
U8 Grants authorization to U7
DBA revokes authorization from U7
Must revoke grant from U7 to U8 and from U8 to U7 as there is no path

from DBA to either U7 or U8
4.55
cascading revocation: revocation of a privilege from a user/role may
cause other users/roles also to lose that privilege.
the revoke statement may specify restrict in order to prevent
cascading revocation:
revoke select on department from Amit, Satoshi restrict;
Cascading revocations are in appropriate in many cases
SQL permits a privilege to be granted by a role rather than by a user

SQL has a notion of the current role associated with a session (set role role name ).
To grant a privilege with the grantor set to the current role associated
with a session, we can add the clause:
granted by current role
4.56

SQL

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SQL

Uploaded by

Copyright:

Available Formats

Chapter 4: Intermediate SQL

Database System Concepts, 6th Ed.

Chapter 4: Intermediate SQL

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

These additional operations are typically used as subquery

expressions in the from clause

Join condition defines which tuples in the two relations

Join type defines how tuples in each relation that do not

match any tuple in the other relation (based on the join

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

Full Outer Join

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

Joined Relations Examples

What is the difference between the above, and a natural join?

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

Joined Relations Examples

course full outer join prereq using (course_id)

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

entire logical model

Consider a person who needs to know an instructors name

A view provides a mechanism to hide certain data from the

view of certain users.

view :Any relation that is not in the conceptual model but is

made visible to a user as a virtual relation .

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

create view v as < query expression >

the virtual relation that the view generates.

View definition is not the same as creating a new relation by

evaluating the query expression

Rather, a view definition causes the saving of an expression;

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

create view faculty as

Find all instructors in the Biology department

Create a view of department salary totals

create view departments_total_salary(dept_name, total_salary) as

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

Views Defined Using Other Views

select course.course_id, sec_id, building, room_number

create view physics_fall_2009_watson as

select course_id, room_number

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

create view physics_fall_2009_watson as

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

Views Defined Using Other Views

v2 if v2 is used in the expression defining v1

A view relation v1 is said to depend on view relation v2 if either

v1 depends directly to v2 or there is a path of dependencies

A view relation v is said to be recursive if it depends on itself.

Database System Concepts - 6th Edition

Silberschatz, Korth and Sudarshan

Let view v1 be defined by an expression e1 that may itself

contain uses of view relations.

View expansion- the process of replacing views by view

definitions following the path of view dependecies: