CS145 Assignment #4
Due Wednesday, Oct. 28, 1998
Step 4 of Your PDA
This week we shall write and run some SQL queries.
It is suggested that you begin to follow the routine of loading your
database from your load file, running queries or other commands from
a file that contains those SQL statements, and then deleting your data
so it doesn't clutter up the database all week and (worse) you don't
forget and load the same tuples several times into your relations.
Remember that SQL thinks of relations as bags, and so will happily let
you insert the same tuple as many times as you ask it to.
To clean out a relation R without deleting the schema itself, use
DELETE FROM R;.
Write five queries on your PDA database,
using the select-from-where construct of SQL.
To receive full credit, all but perhaps one of your queries should exhibit
some interesting feature of SQL: queries over more than one relation,
or subqueries, for example.
We suggest that you experiment with your SQL
commands on a small database (e.g., your hand-created database),
before running them on the large database that you loaded in PDA part
Initial debugging is much easier when you're operating on small
amounts of data. Once you're confident that your queries are
working, run them on your complete database.
If you discover that most or all of your ``interesting'' queries
return an empty answer on your large database, check whether you
followed the instructions in Assignment #3 for generating data
values that join properly. You will need to modify your data
Turn in a copy of all of your SQL queries, along with a script
illustrating their execution. Your script should be sufficient to
convince us that your commands run successfully. Please do not,
however, turn in query results that are thousands (or hundreds of
thousands) of lines long!
- (15 pts.) Write five data modification commands on your PDA
Most of these commands
should be ``interesting,'' in the sense that they involve some complex
feature, such as inserting the result of a query, updating several tuples
at once, or deleting a set of tuples that is more than one but less than
all the tuples in a relation. As for the queries in (1), you might
want to try out your commands on small data before trying it on your full
database. Hand in a script that shows your modification commands running
in a convincing fashion.
- (10 pts.) Create two views on top of your database schema. Show
your CREATE VIEW statements and the response of the system. Also,
show a query involving each view and the system response (but truncate
the response if there are more than a few tuples produced). Finally, show
a script of what happens when you try to update your view, say by inserting
a new tuple into it. Are either of your views updatable? Why or why not?
(Updatable views are discussed in Section 5.8.4 of the text.
Essentially, a view is updatable if it is a selection on one base
In part (1) you probably discovered that some queries run very
slowly over your large database. An important
technique for improving the performance of queries is to create
indexes. An index on an attribute A of relation R allows the
database to quickly find all tuples in R with a given value for
This index is useful if a value of A is specified by your query
(in the where-clause).
It may also be useful if A is involved in a join that equates it
to some other attribute.
For example, in the query
FROM Drinkers, Bars
WHERE Drinkers.name = 'joe'
AND Drinkers.frequents = Bars.name;
we might use an index on Drinkers.name to help us find the
tuple for drinker Joe quickly.
We might also like an index on Bars.name, so we can take all
the bars Joe frequents and quickly find the tuples for those bars to
read their addresses.
In Oracle, you can get an index by the command:
CREATE INDEX <IndexName> ON <RelName>(<Attribute List>)
The text on the second line (``tablespace indexes'') is
unique to the Stanford Oracle installation and is designed to get our
indexes onto a second disk used only for that purpose, so one disk can
be retrieving data while the other is using an index.
Oracle creates indexes automatically when you declare an attribute(s)
PRIMARY KEY or UNIQUE.
Thus, some indexes may exist before you create them and may also be
making certain queries run faster than than they would with no indexes
Be sure to take this factor into account when trying to explain
differences in running times.
If the attribute list contains more than one attribute, then the index
requires values for all the listed attributes to find a tuple.
That situation might be helpful if the attributes together form a key,
An illustration of the CREATE INDEX command is
CREATE INDEX DrinkerInd ON Drinkers(name)
CREATE INDEX BarInd ON Bars(name)
which creates the two indexes mentioned above.
To get rid of an index, you can say DROP INDEX followed by the
name of the index.
Notice that each index must have a name, even though we only refer to
the name if we want to drop the index.
Create at least two useful indexes for your PDA. Run your queries
from part (1) on your large database with the indexes and without the
To time your commands, you may issue the following commands to
- TIMING START <TimerName>; starts your timer.
Give it whatever name you wish.
- TIMING SHOW; prints the current wall-clock time of your
(There is a way to switch among timers, which is why they are named,
but we shall not use this feature.)
- TIMING STOP; prints the current time of your timer and stops
Naturally these times may be affected by external factors
such as system load, etc. Still, you should see a dramatic difference
between the execution times with indexes and the times without. Turn
in a script showing your commands to create indexes, and showing the
relative times of query execution with and without indexes.
We will be working with the following Movies database schema in the
following eight questions.
Movies(Title, Year, filmType, DirectedBy)
Stars(Title, Year, StarName, Salary)
Oscars(Title, Year, OscarAwardType, AwardedTo)
BoxOffice(Title, Year, City, GrossSales)
Ratings(Title, Year, Reviewer, Score)
The Movies relation contains the list of all movies. The value of the
filmType attribute may be 'horror', 'romance', 'thriller' etc.
(Title, Year) form a key in the Movies relation. The Salary attribute
in the Stars relation is the amount paid to StarName for working in
the movie: (Title, Year). The Oscars relation has a tuple for each
Oscar awarded to a movie. The only awards of interest to us are the
Best Actor, Best Actress, and Best Director awards. A typical record
in the Oscars relation would look like
(Cleopatra, 1963, Best Actor, Rex Harrison).
The BoxOffice relation records for each movie its gross sales at the
box office for each city. Also, each movie is rated at a scale of 1-10
by many reviewers. The rating information is kept in the relation
Write SQL statements to produce tables that contain the following
information. You may use views to store intermediate results.
- (5 pts.)
A table containing for each year, the movie that has the maximum
TotalSalaryCost (total salary paid to stars).
A table containing total gross sales of all movies that won some
Oscar award in the 1960s.
A table containing, for each director, the total number of his/her
movies that have won an Oscar.
Above question, except that consider only those movies that
were rated 7 or above by at least two reviewers. You are
REQUIRED to use views to answer this one.
A table containing, for each star, the total number of movies
for which he/she has won an Oscar AND that have won at least
two Oscars. You need not include any items for which this
count is zero.
A table containing the list of all directors who received the "Best
Director" award, even though the movie for which they received the
award had an average rating of less than 5.
- (5 pts.)
Write an UPDATE statement that changes the filmType of a movie that
has won an Oscar to 'OscarWinner'.
- (5 pts.)
Write an INSERT statement to add, for each movie, one more rating
score, equal to the average rating for that movie, to the relation
Ratings. Let the reviewer for the newly added rating be