Download Introduction to Database Systems

SQL in the real world
1
The SQL Client-Server Interactions
Contains
Embedded SQL
SQL-agent
Module
Written in a
host language
Environment
<server name, (name, password)>
Connection
SQL-client
SQL-server
Session
Current catalog and schema
2
SQL/Host Language Interface
Prepare SQL statements
from user inputs
SQL stmt
Function call
while(1){
Cursor
Table
SQL
Library
DBMS
}
Host language program
Fetch rows
from the cursor
Impedance
mismatch
problem
3
Connecting SQL to the Host Language
1. Embedded SQL is a standard for
combining SQL with seven languages.
2. CLI (Call-Level Interface ) is a different
approach to connecting from a host
language to an SQL database.
• SQL/CLI
• JDBC (Java Database Connectivity ) is a way to
connect Java with an SQL database.
• PHP…
4
Two Ways to Connect SQL
with a Host Program
Host language
+
Embedded SQL
Preprocessor
CLI (Call-level
interface)
SQL library
Host language
+
Function calls
Host-language
compiler
Object-code
program
5
All these methods follow the same
paradigm
1.
2.
3.
4.
Connect to a DB server.
Say what database you want to use.
Assemble a string containing an SQL statement.
Get the DBMS to prepare a plan for executing
the statement.
5. Execute the statement.
6. Extract the results into variables in the local
programming language.
6
Embedded SQL
7
Embedded SQL
• Use a preprocessor to turn SQL statements into
procedure calls that fit with the host-language code
surrounding.
• All embedded SQL statements begin with EXEC
SQL, so the preprocessor can find them easily.
• Language constructs:
– Connecting to a database:
EXEC SQL CONNECT
– Declaring variables:
EXEC SQL BEGIN (END) DECLARE SECTION
– Statements:
EXEC SQL Statement;
8
Shared Variables
• To connect SQL and the host-language
program, the two parts must share some
variables.
• Declarations of shared variables are
bracketed by:
EXEC SQL BEGIN DECLARE SECTION;
Always
<host-language declarations>
needed
EXEC SQL END DECLARE SECTION;
9
Use of Shared Variables
• In SQL, the shared variables must be preceded by a
colon.
– They may be used as constants provided by the host-language
program.
– They may get values from SQL statements and pass those
values to the host-language program.
• In the host language, shared variables behave like any
other variable.
10
Extract Results
• Use SELECT-INTO for a query guaranteed to
produce a single tuple.
• Otherwise, you have to use a cursor.
11
Example of C plus SQL: Looking Up the Price
EXEC SQL BEGIN DECLARE SECTION;
Note 21-char
char theBar[21], theBeer[21];
arrays needed
for 20 chars +
float thePrice;
endmarker
EXEC SQL END DECLARE SECTION;
/* obtain values for theBar and theBeer */
theBar = “Blind Pig”;
theBeer = “Bud”;
EXEC SQL SELECT price INTO :thePrice
FROM Sells
WHERE bar = :theBar AND beer = :theBeer;
/* do something with thePrice */
printf(“Price is %f\n”, thePrice);
12
Cursor Statements
• Declare a cursor c with:
EXEC SQL DECLARE c CURSOR FOR <query>;
• Open and close cursor c with:
EXEC SQL OPEN CURSOR c;
EXEC SQL CLOSE CURSOR c;
• Fetch from c by:
EXEC SQL FETCH c INTO <variable(s)>;
– Macro NOT FOUND is true if and only if the FETCH
fails to find a tuple.
13
Example with a Cursor
EXEC SQL BEGIN DECLARE SECTION;
char theBeer[21]; float thePrice;
EXEC SQL END DECLARE SECTION;
EXEC SQL DECLARE c CURSOR FOR
SELECT beer, price FROM Sells
WHERE bar = ‘Joe’’s Bar’;
Compute a list of
beer-price pairs
at Joe’s bar
The cursor declaration goes
outside the declare-section
14
Example with a Cursor
The C style
EXEC SQL OPEN CURSOR c;
of breaking
while(1) {
loops
EXEC SQL FETCH c
INTO :theBeer, :thePrice;
if (NOT FOUND) break;
/* format and print theBeer and thePrice */
}
EXEC SQL CLOSE CURSOR c;
15
Example with a Cursor
• Two special “error” variables:
– SQLCODE (long, is negative if an error has
occurred)
– SQLSTATE (char[6], predefined codes for common
errors)
Example:
if (NOT FOUND)… is indeed:
if (!strcmp(SQLSTATE, “02000”)) break;
No tuple found
Need for Dynamic SQL
• Most applications use specific queries and
modification statements in their interaction with the
database.
– Thus, we can compile the EXEC SQL … statements into
specific procedure calls and produce an ordinary hostlanguage program that uses a library.
• What if the program is something like a generic
query interface, that doesn’t know what it needs to
do until it runs?
17
Dynamic SQL
• Preparing a query:
EXEC SQL PREPARE <query-name>
FROM <text of the query>;
• Executing a query:
EXEC SQL EXECUTE <query-name>;
• “Prepare” = optimize query.
• Prepare once, execute many times.
18
Example: A Generic Interface
EXEC SQL BEGIN DECLARE SECTION;
char query[MAX_LENGTH];
EXEC SQL END DECLARE SECTION;
while(1) {
/* issue SQL> prompt */
/* read user’s query into array query */
EXEC SQL PREPARE q FROM :query;
EXEC SQL EXECUTE q;
q is an SQL variable
representing the optimized
}
form of whatever statement
is typed into :query
19
Example: Generic Interface Again
EXEC SQL BEGIN DECLARE SECTION;
char query[MAX_LENGTH];
EXEC SQL END DECLARE SECTION;
while(1) {
/* issue SQL> prompt */
/* read user’s query into array
query */
EXEC SQL EXECUTE IMMEDIATE :query;
}
If we are only going to execute the query
once, we can combine the PREPARE and
20
Dynamic SQL
strcpy (tmp, “SELECT C.NumEnrolled FROM Course C \
WHERE C.CrsCode = ?” ) ;
EXEC SQL PREPARE st FROM :tmp;
placeholder
EXEC SQL EXECUTE st INTO :num_enrolled USING :crs_code;
• st is an SQL variable; names the SQL statement
• tmp, crscode, num_enrolled are host language variables (note
colon notation)
• crscode is an in parameter; supplies value for placeholder (?)
• num_enrolled is an out parameter; receives value from
C.NumEnrolled
21
JDBC
22
JDBC
• Instead of using a preprocessor, we can use a
library of functions and call them as part of a
Java program.
• Java Database Connectivity (JDBC) is a library,
with Java as the host language.
– The library for C is called SQL/CLI = “Call-Level
Interface.”
23
JDBC: Architecture
• Four architectural components:
– Application (initiates and terminates connections,
submits SQL statements)
– Driver manager (load JDBC driver)
– Driver (connects to data source, transmits requests
and returns/translates results and error codes)
– Data source (processes SQL statements)
CENG 352 Database Management
Systems
JDBC Run-Time Architecture
Oracle
Oracle
database
driver
application
driver
manager
SQLServer
SQLServer
driver
database
DB/2
driver
DB/2
DBMS
database
25
Data Structures
Java connects to the database by structures of
the following types:
1. Connections : logins to the database.
2. Statements : records that hold SQL statements
to be passed to a connection.
3. Descriptions : records about tuples from a
query or parameters of a statement.
26
Steps in JDBC Database Access
1. Import JDBC library (java.sql.*)
2. Load JDBC driver:
Class.forname(“oracle.jdbc.driver.OracleDriver”)
3. Define appropriate variables
4. Create a connect object (via getConnection)
5. Create a statement object from the Statement
class:
1. PreparedStatement
2. CallableStatement
27
Steps in JDBC Database Access
(continued)
6. Identify statement parameters
7. Bound parameters to program variables
8. Execute SQL statement (referenced by an
object) via JDBC’s executeQuery
9. Process query results (returned in an object of
type ResultSet)
–
ResultSet is a 2-dimentional table
28
Initial steps
import java.sql.*;
-- import all classes in package java.sql
Class.forName (driver name);
// static method of class Class
// loads specified driver
//e.g. Class.forName(“oracle.jdbc.driver.Oracledriver”);
Connection myCon = DriverManager.getConnection(Url, Id, Passwd);
• Static method of class DriverManager; attempts to
connect to DBMS
• If successful, creates a connection object, myCon, for
managing the connection
Statement stat = con.CreateStatement ();
• Creates a statement object stat
• Statements have executeQuery() method
29
Statements

Three types:
 Statement (both static and dynamic SQL
statements)
 PreparedStatement (semi-static SQL statements)
 CallableStatment (stored procedures)

PreparedStatement class:
Precompiled, parametrized SQL statements:
 Structure is fixed
 Values of parameters are determined at run-time
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
30
Creating Statements
• The Connection class has methods to create
Statements and PreparedStatements.
Statement stat1 = myCon.createStatement();
Java trick: +
PreparedStatement stat2 =
concatenates
myCon.prepareStatement(
strings.
“SELECT beer, price FROM Sells” +
“WHERE bar = ‘Joe’’s Bar’”
);
31
Executing SQL Statements
• JDBC distinguishes queries from modifications,
which it calls “updates.”
• Statement and PreparedStatement each have
methods executeQuery and executeUpdate.
– For Statements, these methods have one argument: the
query or modification to be executed.
– For PreparedStatements: no argument.
32
Example: Update
• stat1 is a Statement.
• We can use it to insert a tuple as:
stat1.executeUpdate(
“INSERT INTO Sells” +
“VALUES(‘Brass Rail’, ‘Bud’, 3.00)”
);
33
Example: Query
• stat2 is a PreparedStatement holding the query
“SELECT beer, price FROM Sells WHERE
bar = ‘Joe’’s Bar’”.
• executeQuery returns an object of class
ResultSet
• The query:
ResultSet Menu = stat2.executeQuery();
34
Accessing the ResultSet
• An object of type ResultSet is something like a
cursor.
• Method Next() advances the “cursor” to the
next tuple.
– The first time Next() is applied, it gets the first
tuple.
– If there are no more tuples, Next() returns the value
FALSE.
35
Accessing Components of Tuples
• When a ResultSet is referring to a tuple, we can
get the components of that tuple by applying
certain methods to the ResultSet.
• Method getX (i ), where X is some type, and i is
the component number, returns the value of that
component.
– The value must have type X.
36
Example: Accessing Components
• Menu is the ResultSet for the query “SELECT beer,
price FROM Sells WHERE bar = ‘Joe’’s Bar’”.
• Access the beer and price from each tuple by:
while ( Menu.Next() ) {
theBeer = Menu.getString(1);
thePrice = Menu.getFloat(2);
/* do something with theBeer and
thePrice */
}
37
Preparing and Executing a Query
String query = “SELECT T.StudId FROM Transcript T” +
“WHERE T.CrsCode = ? AND T.Semester = ?”;
placeholders
PreparedStatement ps = con.prepareStatement ( query );
• Prepares the statement
• Creates a prepared statement object, ps, containing the
prepared statement
• Placeholders (?) mark positions of in parameters;
special API is provided to plug the actual values in
positions indicated by the ?’s
38
Preparing and Executing a Query
String crs_code, semester;
………
ps.setString(1, crs_code); // set value of first in parameter
ps.setString(2, semester); // set value of second in parameter
ResultSet
•
•
•
res = ps.executeQuery ( );
Creates a result set object, res
Executes the query
Stores the result set produced by execution in res
while ( res.next ( ) ) {
j = res.getInt (“StudId”);
…process output value…
}
// advance the cursor
// fetch output int-value
39
Matching Java and SQL Data Types
SQL Type
BIT
CHAR
VARCHAR
DOUBLE
FLOAT
INTEGER
REAL
DATE
TIME
TIMESTAMP
Java class
Boolean
String
String
Double
Double
Integer
Double
java.sql.Date
java.sql.Time
java.sql.TimeStamp
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
ResultSet get method
getBoolean()
getString()
getString()
getDouble()
getDouble()
getInt()
getFloat()
getDate()
getTime()
getTimestamp()
40
JDBC: Exceptions and Warnings
Most of java.sql can throw and SQLException
if an error occurs.
 SQLWarning is a subclass of EQLException;
not as severe (they are not thrown and their
existence has to be explicitly tested)

Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
41
Warning and Exceptions (Contd.)
try {
stmt=con.createStatement();
warning=con.getWarnings();
while(warning != null) {
// handle SQLWarnings;
warning = warning.getNextWarning():
}
con.clearWarnings();
stmt.executeUpdate(queryString);
warning = con.getWarnings();
…
} //end try
catch( SQLException SQLe) {
// handle the exception
}
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
42
Examining Database Metadata
DatabaseMetaData object gives information
about the database system and the catalog.
DatabaseMetaData md = con.getMetaData();
// print information about the driver:
System.out.println(
“Name:” + md.getDriverName() +
“version: ” + md.getDriverVersion());
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
43
Database Metadata (Contd.)
DatabaseMetaData md=con.getMetaData();
ResultSet trs=md.getTables(null,null,null,null);
String tableName;
While(trs.next()) {
tableName = trs.getString(“TABLE_NAME”);
System.out.println(“Table: “ + tableName);
//print all attributes
ResultSet crs = md.getColumns(null,null,tableName, null);
while (crs.next()) {
System.out.println(crs.getString(“COLUMN_NAME” + “, “);
}
}
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
44
A (Semi-)Complete Example
Connection con = // connect
DriverManager.getConnection(url, ”login", ”pass");
Statement stmt = con.createStatement(); // set up stmt
String query = "SELECT name, rating FROM Sailors";
ResultSet rs = stmt.executeQuery(query);
try { // handle exceptions
// loop through result tuples
while (rs.next()) {
String s = rs.getString(“name");
Int n = rs.getFloat(“rating");
System.out.println(s + " " + n);
}
} catch(SQLException ex) {
System.out.println(ex.getMessage ()
+ ex.getSQLState () + ex.getErrorCode ());
}
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
45
Transactions in JDBC
• Default for a connection is
– Transaction boundaries
• Autocommit mode: each SQL statement is a transaction.
• To group several statements into a transaction use
con.setAutoCommit (false)
– Isolation
• default isolation level of the underlying DBMS
• To change isolation level use
con.setTransactionIsolationLevel (TRANSACTION_SERIALIZABLE)
• With autocommit off:
– transaction is committed using con.commit().
– next transaction is automatically initiated (chaining)
• Transactions on each connection committed separately
46
SQL/PSM
Procedures Stored in the Database
47
Stored Procedures

What is a stored procedure:
 Program executed through a single SQL statement
 Executed in the process space of the server

Advantages:
 Can encapsulate application logic while staying
“close” to the data
 Reuse of application logic by different users
 Avoid tuple-at-a-time return of records through
cursors
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
48
Stored Procedures
• An extension to SQL, called SQL/PSM, or
“persistent, stored modules,” allows us to store
procedures as database schema elements.
• The programming style is a mixture of
conventional statements (if, while, etc.) and SQL.
• Lets us do things we cannot do in SQL alone.
• Why? Performance.
49
Basic PSM Format
CREATE PROCEDURE <name> (
<parameter list> )
<optional local declarations>
Example: compute square
<body>;
footage of house lot; then
you can query on it
• Function alternative:
CREATE FUNCTION <name> (
<parameter list> ) RETURNS <type>
50
Parameters in PSM
• Unlike the usual name-type pairs in languages
like C, PSM uses mode-name-type triples, where
the mode can be:
– IN = procedure uses value, does not change value.
– OUT = procedure changes, does not use.
– INOUT = both.
51
Example: Stored Procedure
• Let’s write a procedure that takes two arguments
b and p, and adds a tuple to Sells that has bar =
’Joe’’s Bar’, beer = b, and price = p.
– Used by Joe to add to his menu more easily.
52
The Procedure
CREATE PROCEDURE JoeMenu (
IN b
CHAR(20),
Parameters are both
read-only, not changed
IN p
REAL
)
INSERT INTO Sells
The body --a single insertion
VALUES(’Joe’’s Bar’, b, p);
53
Invoking Procedures
• Use SQL/PSM statement CALL, with the
name of the desired procedure and
arguments.
• Example:
CALL JoeMenu(’Moosedrool’, 5.00);
• Functions used in SQL expressions where a
value of their return type is appropriate.
54
Types of PSM statements -- 1
• RETURN <expression> sets the return value
of a function.
– Unlike C, etc., RETURN does not terminate
function execution.
• DECLARE <name> <type> used to declare
local variables.
• BEGIN . . . END for groups of statements.
– Separate by semicolons.
55
Types of PSM Statements -- 2
• Assignment statements:
SET <variable> = <expression>;
– Example: SET b = ’Bud’;
• Statement labels: give a statement a label by
prefixing a name and a colon.
56
IF statements
• Simplest form:
IF <condition> THEN
<statements(s)>
END IF;
• Add ELSE <statement(s)> if desired, as
IF . . . THEN . . . ELSE . . . END IF;
• Add additional cases by ELSEIF <statements(s)>:
IF … THEN … ELSEIF … ELSEIF … ELSE … END
IF;
57
Example: IF
• Let’s rate bars by how many customers they
have, based on Frequents(drinker, bar).
– <100 customers: ‘unpopular’.
– 100-199 customers: ‘average’.
– >= 200 customers: ‘popular’.
• Function Rate(b) rates bar b.
58
Example: IF (continued)
CREATE FUNCTION Rate (IN b CHAR(20) )
Number of
RETURNS CHAR(10)
customers of
bar b
DECLARE cust INTEGER;
BEGIN
SET cust = (SELECT COUNT(*) FROM Frequents
WHERE bar = b);
IF cust < 100 THEN RETURN ’unpopular’
ELSEIF cust < 200 THEN RETURN ’average’
ELSE RETURN ’popular’
Nested
END IF;
IF statement
Return
occurs
here,
not
at
END;
one of the RETURN statements
59
Loops
• Basic form:
LOOP <statements> END LOOP;
• Exit from a loop by:
LEAVE <loop name>
• The <loop name> is associated with a loop by
prepending the name and a colon to the
keyword LOOP.
60
Example: Exiting a Loop
loop1: LOOP
...
LEAVE loop1;
...
END LOOP;
If this statement is executed . . .
Control winds up here
61
Other Loop Forms
• WHILE <condition>
DO <statements>
END WHILE;
• REPEAT <statements>
UNTIL <condition>
END REPEAT;
62
Queries
•
•
General SELECT-FROM-WHERE queries
are not permitted in PSM.
There are three ways to get the effect of a
query:
1. Queries producing one value can be the
expression in an assignment.
2. Single-row SELECT . . . INTO.
3. Cursors.
63
Example: Assignment/Query
• If p is a local variable and Sells(bar, beer, price) the
usual relation, we can get the price Joe charges for Bud
by:
SET p = (SELECT price FROM Sells
WHERE bar = ’Joe’’s Bar’ AND
beer = ’Bud’);
64
SELECT . . . INTO
• An equivalent way to get the value of a query that is
guaranteed to return a single tuple is by placing
INTO <variable> after the SELECT clause.
• Example:
SELECT price INTO p FROM Sells
WHERE bar = ’Joe’’s Bar’ AND
beer = ’Bud’;
65
Cursors
• A cursor is essentially a tuple-variable that
ranges over all tuples in the result of some
query.
• Declare a cursor c by:
DECLARE c CURSOR FOR <query>;
66
Opening and Closing Cursors
• To use cursor c, we must issue the command:
OPEN c;
– The query of c is evaluated, and c is set to point to
the first tuple of the result.
• When finished with c, issue command:
CLOSE c;
67
Fetching Tuples From a Cursor
• To get the next tuple from cursor c, issue
command:
FETCH FROM c INTO x1, x2,…,xn ;
• The x ’s are a list of variables, one for each
component of the tuples referred to by c.
• c is moved automatically to the next tuple.
68
Breaking Cursor Loops -- 1
• The usual way to use a cursor is to create a loop
with a FETCH statement, and do something
with each tuple fetched.
• A tricky point is how we get out of the loop
when the cursor has no more tuples to deliver.
69
Breaking Cursor Loops -- 2
• Each SQL operation returns a status, which is a
5-digit number.
– For example, 00000 = “Everything OK,” and 02000
= “Failed to find a tuple.”
• In PSM, we can get the value of the status in a
variable called SQLSTATE.
70
Breaking Cursor Loops -- 3
• We may declare a condition, which is a boolean
variable that is true if and only if SQLSTATE
has a particular value.
• Example: We can declare condition NotFound to
represent 02000 by:
DECLARE NotFound CONDITION FOR
SQLSTATE ’02000’;
71
Breaking Cursor Loops -- 4
• The structure of a cursor loop is thus:
cursorLoop: LOOP
…
FETCH c INTO … ;
IF NotFound THEN LEAVE cursorLoop;
END IF;
…
END LOOP;
72
Example: Cursor
• Let’s write a procedure that examines Sells(bar,
beer, price), and raises by $1 the price of all
beers at Joe’s Bar that are under $3.
– Yes, we could write this as a simple UPDATE, but
the details are instructive anyway.
73
The Needed Declarations
CREATE PROCEDURE JoeGouge( )
Used to hold
DECLARE theBeer CHAR(20);
beer-price pairs
when fetching
DECLARE thePrice REAL;
through cursor c
DECLARE NotFound CONDITION FOR
SQLSTATE ’02000’;
Returns Joe’s menu
DECLARE c CURSOR FOR
(SELECT beer, price FROM Sells
WHERE bar = ’Joe’’s Bar’);
74
The Procedure Body
BEGIN
Check if the recent
OPEN c;
FETCH failed to
menuLoop: LOOP
get a tuple
FETCH c INTO theBeer, thePrice;
IF NotFound THEN LEAVE menuLoop END IF;
IF thePrice < 3.00 THEN
UPDATE Sells SET price = thePrice+1.00
WHERE bar = ’Joe’’s Bar’ AND beer = theBeer;
END IF;
END LOOP;
If Joe charges less than $3 for
CLOSE c;
the beer, raise it’s price at
Joe’s Bar by $1.
END;
75
Calling Stored Procedures (Contd.)
JDBC:
CallableStatement cstmt=
con.prepareCall(“{call
ShowSailors});
ResultSet rs =
cstmt.executeQuery();
while (rs.next()) {
…
}
Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke
76
Statements
•
JDBC provides two classes:
1. Statement = an object that can accept a string that
is an SQL statement and can execute such a
string.
2. PreparedStatement = an object that has an
associated SQL statement ready to execute.
77
The Three-Tier Architecture
of Database Applications
Display
Forms
&
query result
Buttons
Web server
network
Application
server
HTTP
browser
Client &
Server
Interaction
Your business logic
is executed here
Database server
database
Server
78