Database Principles

SQL 1

Database Principles

Connecting to db2:

• Using your userID and password connect to our server.

• Connect to the Library database

ssh –l userID avalon.cs.newpaltz.edu

$ db2 connect to Library$ db2 “set schema = db2inst1”

db2 instance

Library Sample

userID1 userID2 db2inst1. . .

Cardholder Book . . .

OS process

manages various databases

each database has one schemaper user

each schema has tables created by the schema owner

Database Principles

Once Connected:

• db2inst1 schema has Library tables already created.• Viewing the tables:

select * from Cardholderselect * from Bookselect * from Copyselect * from Reservesselect * from Borrowsselect * from Status

* means “all columns”

Database Principles

Two Kinds of Interaction:

• Command-line:

• Execute a file:– place your query in a file

– execute the file

• Latter is better:– easier to edit– don’t have to type same command twice.

$ db2 “select * from Cardholder”

# query1.sql

select * from Cardholder;

$ db2 –tf query1.sql

end all commands with a ;

Database Principles

Split Personality

• SQL is made up of two parts– DDL (Data Definition Language)– DML (Data Manipulation Language)

• DDL:– Mostly “create” statements: create table, create index,

create view, drop table, …

• DML: Made up of 4 commands: insert, delete, update and select

Database Principles

DDL vs DML:

• The nature of DDL commands is that – they are used infrequently, – have syntax that does not vary and – can always be looked up in a book.

• The DML commands tend to– be unique to the situation,– contain very complicated logic and– require great effort to become proficient.

Database Principles

DDL:

• I have nothing more to say.• If you want to be good at it, read a book

Database Principles

DML:

• Four commands – insert, delete, update and select – that do the obvious.

• Insert: Add new rows to a table• Delete: Remove rows from a table• Update: Modify columns in certain table rows• Select: Retrieve information from database tables.

• All four commands share the property that the programming problem they present is the logic of expressing what rows to add, drop, modify or retrieve.

Database Principles

Basic Syntax (db2):

• Insert Statement:

• Delete Statement:

Insert into <table name> (<list of columns>) values (<matching list of values>)

orInsert into <table name> (<list of columns>) select_statement (see def’n later)

Delete from <table name> where <condition describing rows to be deleted>

Database Principles

Basic Syntax:

• Update Statement:

• Select Statement:

update <table name> set column name = new value, . . . where <condition describing rows to be updated>

Select <list of output columns> from <list of input tables> where <condition describing rows to be retrieved>

NOTE 1: Other versions of SQL such as T-SQL allow the updateand delete statements to containa from_clause. db2 does not.

NOTE 2: When the <list of outputcolumns> is * this means “all columnsin all tables in the from_clause”

Database Principles

Shared Property and Our Focus:

• The shared property that these four commands share is a where_clause condition.

• It turns out that learning to write the where_clause condition correctly is what it is all about.

• We shall spend our time learning to write where_clause conditions in the context of select statements.

Database Principles

Procedural vs Declarative Languages:

• Most programming languages are procedural; that is the programmer must write down a sequence of instructions that are to be executed when the program is run.

• Java, C++, Perl and Php are all procedural languages.• Using a procedural language, the programmer figures

out what needs to be done and then writes out an algorithm for how to accomplish the desired task.

• Defining what is primarily a design activity.• Defining how is primarily a programming activity.

Database Principles

SQL is a Declarative Language

• With SQL you focus on saying what not how. • This sounds simple. • Easier to say “write a program that X” than to actually

write the program.• However, expressing “what” in terms of precise logic

takes some training and that is what we will do in this section of the course

Database Principles

SQL SELECT:

• Many of the operations of Relational Algebra – select, project, join, set difference and quotient – are all performed in SQL with the SELECT command.

• Instead of putting together a sequence of commands in Relational Algebra we ask one query in SQL.

• This one query can contain all the logic of several Relational Algebra queries.

Database Principles

Hard to be Complete and Concise:

• In the book, “The River Runs Through”, the author, Norman MacLean, as a young boy writes a page describing something.

• His father says, “That’s fine, now reduce all you have said to one paragraph and don’t leave anything out.”

• When the boy returns with the result his father says, “That’s fine, now reduce all you have said to one sentence and don’t leave anything out.”

• Being complete and concise at the same time is hard!

Database Principles

SELECT Syntax:

• select_list: A list of columns/expressions that make up the output of the query.

• table_list: A list of tables that make up the input of the query.

• condition: A boolean expression (sometimes very complex) that must be true about rows in the various tables in the table_list in order to produce an output looking like the select_list.

Select <select_list> from <table_list> where <condition>

final project

input tablesjoins andconditions

Database Principles

Select Example 1:

• This query gives a complete list of all cardholder names and addresses.

• Things to note:– The select_list acts like the final project in a Relational

Algebra query– The from_clause only contains one table– There is no where_clause condition so the

where_clause is TRUE for each row of Cardholder.

Select b_name, b_addr from Cardholder

Database Principles

How to Imagine the Query being Executed

• Imagine there is a row-variable, ch, that visits each row of the table.

• Each time it stops at a row the where_clause is evaluated.

• Each time the where_clause is TRUE, values are extracted from the row and sent to output.

ch

Database Principles

Select Example 2:

Select b_name, b_addr from Cardholder where b_status = ‘junior’

ch

where_clause

b_name

jo-annjohn

b_addr

New PaltzKingston

Answer

Acts like Relational Algebra PROJECT

Acts like Relational Algebra SELECT

false

truefalsetruefalsefalse

falsechchchchchch

NOTE: The condition b_status = ‘junior’is called a SARG (Search ARGument)

Database Principles

Select Example 3:

• Find the cardholders (b_name, b_addr) with Reservations on December 1.

Select b_name, b_addr from cardholder ch, borrows b where ch.borrowerid = b.borrowerid and l_date = ‘Dec 1’

ch b

bch

called a join-term

b_name

johnsusan

b_addr

New PaltzWallkill

ch and b are calledtable aliases

Database Principles

Imagining a Multi-table Query

Select b_name, b_addr from cardholder ch, borrows b where ch.borrowerid = b.borrowerid and l_date = ‘Dec 1’

for each row in Cardholder (ch) for each row in Borrows (b) if ( ch.borrowerid = b.borrowerid and b.l_date = ‘Dec 1’) then copy columns in select_list to output

ch

b

Database Principles

Alternative Syntax:

Can also be written

By this logic the join terms are removed from the where_clause and placed inside the from_clause.

Select b_name, b_addr from cardholder ch, borrows b where ch.borrowerid = b.borrowerid and l_date = ‘Dec 1’

Select b_name, b_addr from cardholder ch inner join borrows b on ch.borrowerid = b.borrowerid where l_date = ‘Dec 1’

NOTE: In terms of RelationalAlgebra both these queriescombine select, project andjoin

select

project

join

Database Principles

More Complicated Join Query:

• Find the cardholders (b_name, b_addr) who have reserved a book that was borrowed on Dec 1. Include in your answer the book (author, title) involved.

Select b_name, b_addr, author, title from cardholder ch, reserves r, book k, copy c, borrows b where ch.borrowerid = r.borrowerid AND # cardholder reserved something r.ISBN = k.ISBN AND # that is a book k.ISBN = c.ISBN AND # which has a copy c.accession_no = b.accession_no AND # that was loaned b.l_date = ‘Dec 1’ # on Dec 1

Select distinct b_name, b_addr, author, title from cardholder ch, reserves r, book k, copy c, borrows b where ch.borrowerid = r.borrowerid AND r.ISBN = k.ISBN AND k.ISBN = c.ISBN AND c.accession_no = b.accession_no AND b.l_date = ‘Dec 1’

unique answers

Database Principles

Subqueries:

• It is possible to nest one query inside another. This is called a subquery.

• Subqueries act somewhat like subordinate clauses in an English sentence.

• The query strategy can be– First find all books borrowed by John from New Paltz– Then find who reserved “those” books.

Who reserved the books that John from New Paltz borrowed?

Database Principles

Subqueries 2:

• Since the results of subqueries are sets then we need special set operators to manipulate them.

• The special boolean operators are IN and EXISTS• IN (tests set membership):

tests if the thing on the left (element) belongs to the set which is the result of the subquery.

• EXISTS (tests set existence):

tests if the subquery has an empty result set or not.

element IN (select … )

EXISTS (select … )

Database Principles

Subquery Example (cont):

Who reserved the books that John from New Paltz borrowed?

Select distinct b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid AND r.ISBN IN (select c.ISBN from copy c, borrows b, cardholder ch1 where c.accession_no = b.accession_no AND b.borrowerid = ch1.borrowerid AND ch1.b_name = ‘John’ AND ch1.b_addr = ‘New Paltz’)

Exercise: Rewrite this query without using a subquery.

Select distinct b_name, b_addr from cardholder ch, reserves r, copy c, borrows b, cardholder ch1 where ch.borrowerid = r.borrowerid AND r.ISBN = c.ISBN AND c.accession_no = b.accession_no AND b.borrowerid = ch1.borrowerid AND ch1.b_name = ‘John’ AND ch1.b_addr = ‘New Paltz’

Database Principles

UNION Query:

• Find the cardholders (b_name, b_addr) who have borrowed or reserved a book.

(select distinct b_name, b_addr from cardholder ch, borrows b where ch.borrowerid = b.borrowerid)UNION(select distinct b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid)

NOTE: There is a possibility of duplicate rows in the answer for a coupleof reasons - a cardholder may reserve or borrow more than one book - a cardholder may reserve one book and borrow anotherThe key word “distinct” makes sure the output of the subqueries aredistinct and the key word “UNION” makes sure that duplicate answers

across the subqueries are not displayed. To see all duplicates drop the “distinct” key word and replace “UNION”with “UNION ALL”

Database Principles

Query Exercise:

• Rewrite the previous query without using UNION.• Find the cardholders (b_name, b_addr) who have

borrowed or reserved a book.

select distinct b_name, b_addr from cardholder ch, borrows b, reserves r where ch.borrowerid = b.borrowerid or ch.borrowerid = r.borrowerid)

Database Principles

INTERSECT Query:

• Find the cardholders (b_name, b_addr) who have both borrowed and reserved books

(select distinct b_name, b_addr from cardholder ch, borrows b where ch.borrowerid = b.borrowerid)INTERSECT(select distinct b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid)

Database Principles

SET DIFFERENCE Query:

• Find the cardholders (b_name, b_addr) who have borrowed a book but not reserved any books

(select distinct b_name, b_addr from cardholder ch, borrows b where ch.borrowerid = b.borrowerid)MINUS(select distinct b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid)

Database Principles

Hard Queries:

• Like RA, hard queries signaled by key words: only, all, not, none and so forth.

• Like RA, hard queries resolved using techniques other than select, project and join.

• Using the MINUS operator as in our previous example, we can implement set differences.

• We can also implement set differences using NOT IN.

element NOT IN (select …)

Database Principles

NOT IN Queries:

• Advantage of the NOT IN syntax: it reads like English.

• Rewrite this same query removing the word “only” and using the phrase “not in” instead.

Find cardholders (b_name, b_addr) who have only reserved books on Dec 1

Find cardholders (b_name, b_addr) who have reserved a book and are not in the set of cardholders who have reserved books on a date other than Dec 1

BookReservers

Reservers of Books on a date other than Dec 1

Reservers of Books only on Dec 1

Database Principles

English-to-SQL Translation:

• The latest version of our query translated easily into SQL

Find cardholders (b_name, b_addr) who have reserved a book and are not in the set of cardholders who have reserved books on a date other than Dec 1

Select b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid AND ch.borrowerid NOT IN (select borrowerid from reserves where r_date != ‘Dec 1’)

those cardholders

Exercise: Rewrite this query using the MINUS operator

Database Principles

Using Minus

Find cardholders (b_name, b_addr) who have only reserved books on Dec 1

(select b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid and r_date = “Dec 1”)MINUS(select b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid and r_date != “Dec 1”)

Database Principles

Observation:

• Both the MINUS syntax and the NOT IN syntax allow the programmer to program the query in steps:– First find what you don’t want– Throw it away– You are left with what you want.

• Since one of these queries may run faster than the other you will need to know how to write both.

• You get paid not only for correctness but probably more important, speed.

Database Principles

Negation Queries:

• Like RA, some negation queries are “easy” in SQL and some are “hard”.

• The former use SARGS and join_terms only.• The latter usually need to use NOT IN.• Like RA, the hard queries come from negating the

presence on an entity in some relationship where the minimum participation number is 0.

Database Principles

Hard Negation Query Example 1

• Find the cardholders who have not borrowed anything.• Rewritten as: Find the cardholders who are not in the set

of borrowers of books.

Select b_name, b_addr from cardholder where borrowerid NOT IN (select borrowerid from borrows)

Database Principles

Hard Negation Query Example 2

• Find the cardholders who have not borrowed any book they have reserved.

• Rewritten as: Find the cardholders who have reserved something and are not in the set of borrowers of books they have also reserved.

Select b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid AND ch.borrowerid NOT IN (select b.borrowerid from borrows b, copy c, reserves r where b.borrowerid = r.borrowerid AND b.accession_no = c.accession_no AND c.ISBN = r.ISBN)

Database Principles

Hard Negation Query Example 3

• This query is called a co-related subquery.• Find the cardholders who have not borrowed the same

book they have reserved.• Rewritten as: Find the cardholders who have reserved at

least one book and that book not in the set of books they have borrowed.

Select b_name, b_addr from cardholder ch, reserves r where ch.borrowerid = r.borrowerid AND r.ISBN NOT IN (select c.ISBN from borrows b, copy c where b.borrowerid = ch.borrowerid AND b.accession_no = c.accession_no)

Database Principles

Co-related Subquery:

• What makes the subquery “co-related” is the presence of a table alias inside the subquery that is defined outside the subquery.

• This is very similar to using a global variable inside function definition.

• It is easy to pick up because in the English version of the query you will have a definite article (the, those, that) or definite pronoun (they, she, he, it) inside the subquery phrase that refers to something outside the subquery phrase.

Database Principles

EXISTS:

• EXISTS can be used with a subquery to decide if it is empty or not.

• The logic is that if the subquery is empty this EXISTS is false so nothing is returned.

select b_name, b_addr from cardholder ch where exists (select * from borrows b where b.borrowerid = ch.borrowerid)

Find the cardholders who have borrowed a book

Find the cardholders where there exists a book loan made by them

Database Principles

Exercise:

• Write the previous query without using EXISTS.

select distinct b_name, b_addr from cardholder ch, borrows b where b.borrowerid = ch.borrowerid)

Database Principles

NOT EXISTS:

• In RA we used the QUOTIENT operator for this query.• In SQL we use NOT EXISTS• Rewrite the query in English with NOT EXISTS

Find the cardholders who have reserved all AW books

Find the cardholders where there does NOT EXIST a book published by Addison-Wesley that they did not reserve.

Find the cardholders where there does NOT EXIST a book published by Addison-Wesley and that book is NOT IN the set of books they reserved.

Select b_name, b_addr from cardholder ch where NOT EXISTS (select * from book k where k.pub_name = ‘AW’ AND k.ISBN NOT IN (select ISBN from reserves r where r.borrowerid = ch.borrowerid))