PPT
Upcoming SlideShare
Loading in...5
×
 

PPT

on

  • 1,521 views

 

Statistics

Views

Total Views
1,521
Views on SlideShare
1,521
Embed Views
0

Actions

Likes
0
Downloads
2
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

PPT PPT Presentation Transcript

  • C20.0046: Database Management Systems Lecture #14 M.P. Johnson Stern School of Business, NYU Spring, 2008
  • Agenda
    • Today:
      • midterms, etc
      • Proj2, Mysql accounts
      • SQL programming
  • Midterm, etc.
    • Stats:
      • Possible:
      • Max:
      • Mean:
      • Median:
      • Stdev:
      • “ Pretty good”: >=
    • Go through MT…
  • proj2
    • Give relational model (normalized as needed) for your project
    • Give interesting queries
    • Create tables (indices, etc.) for it in your account
    • Should be straightforward
      • If you have an account…
    • Due: 4/2
  • NYU Infrastructure
    • Server: sales (sales.stern.nyu.edu)
    • To connect, ssh to sales
      • http://www.google.com/search?hl=en&q=ssh+client&btnG=Google+Search
      • I use: WinSCP/Putty
    • Server: i5.nyu.edu (ssh)
      • User/pass: netid / netid (or nyu pass?)
    • MySQL user/pass: NetID / NetID
    • MySQL shell: mysql
      • MySQL host: mysql2
      • See proj3 page for exact command syntax
      • sales% mysql -h mysql2 -u my-NetID -p my-UID
      • Check that your account works tonight!
      • phpMyAdmin: http://i5.nyu.edu/phpMyAdmin/
  • Programming for SQL
    • Today: from procedural languages to SQL
      • Pro*C
      • JDBC
    • Next: DB-backed apps on the web
      • PHP
    • Later:
      • PL/SQL, Triggers
  • R.A./SQL has limitations
    • Can easily find Alice’s direct subordinates:
    • But: find all of King’s underlings
    • Cannot compute “transitive closure”
    • Cannot express in R.A./SQL!
    • SQL is not “Turing-Complete”
    Jones Jones King King NULL Boss Analyst Analyst Manager Manager President Job Ford Scott Blake Jones King Name
  • New topic: SQL Programming
    • Can write SQL queries in a SQL interpreter
      • Command prompt
      • SQL*Plus ( sqlplus ) in Oracle
      • mysql in MySQL
    • Good for experimenting, not for anything non-trivial
    • Better: use a standard programming language
      • Host language talks to SQL/DB
  • Using two languages
    • Q: Why not use just one language?
    • “ [W]e can quickly dispense with the idea…” (Ullman, p351)
    • Q: Why not do everything in SQL?
    • A: Not designed as a general-purpose language
      • No recursion (no factorial!), not Turing-complete
      • No, e.g., Swing library
    • Q: Why not do everything in the host lang.?
    • A: What Oracle provides is highly non-trivial
      • Query interpretation, optimizing
      • Queries stay constant across host languages
      • Many points of entry
    • Germ of OO: modularize
  • Impedance mismatch problem
    • Big problem, though: impedance mismatch
      • Data structures in our app-programming lang. don’t automatically map onto those in SQL
        • Different types/representations for data
    • In SQL: tables with scalar fields
    • In C: scalars, records (containing records…), pointers, arrays
    • In Java: scalars, objects, references, arrays
    • In Perl: scalars, lists/arrays, hashes/assoc.
  • SQL/host interface in embedded SQL
    • So Q: how to transfer data between?
    • A: Shared variables
      • Some vars in the program can be used by SQL
      • Prefix var with a :
      • After query, look here for received data
    • SQL commands embedded in app. code
      • Identified by EXEC SQL
    • Source code is preprocessed before regular compilation
      • Result is (e.g.) a C program with library calls
  • Programs with Embedded SQL Preprocessor Host language compiler Preprocessor Oracle’s Pro*C Host language compiler gcc Host language + Embedded SQL prog.pc Host Language + function calls prog.c Executable a.out
  • Interface: SQL / Host Language
    • Values get passed through shared variables.
      • Colons precede shared variables in SQL statements
      • EXEC SQL demarcates every SQL statement
    • The variable SQLSTATE provides error messages and status reports
      • “ 00000” ~ success
      • “ 02000” ~ tuple not found
        • Used in loops
    EXEC SQL BEGIN DECLARE SECTION; char productName[30]; char SQLSTATE[6]; EXEC SQL END DECLARE SECTION;
  • Embedded SQL example
    • Context:
      • Product (pname, price, quantity, maker)
      • Purchase (buyer, seller, store, pname)
      • Company (cname, city)
      • Person(name, phone, city)
    • Goal 1: Insert a new row in Purchase
    • Goal 2: Look up price of product by name
  • Embedded SQL example: insert void simpleInsert() { EXEC SQL BEGIN DECLARE SECTION; char pn[20], cn[30]; /* product-name, company-name */ double p, int q; /* price, quantity */ char SQLSTATE[6]; EXEC SQL END DECLARE SECTION; /* get values for name, price and company somehow */ EXEC SQL INSERT INTO Product(pname, price, quantity, maker) VALUES (:pn, :p, :q, :cn); }
  • Embedded SQL example: look-up int getWindowsPrice() { EXEC SQL BEGIN DECLARE SECTION; double p; char SQLSTATE[6]; EXEC SQL END DECLARE SECTION; EXEC SQL SELECT price INTO :p FROM Product WHERE Product.name = ‘Windows’; return p; }
  • Embedded SQL example: look-up
    • What about search for arbitrary product?
    • Q: Will this work?
    int getPrice(char *name) { EXEC SQL BEGIN DECLARE SECTION; int p; char SQLSTATE[6]; EXEC SQL END DECLARE SECTION; EXEC SQL SELECT price INTO :p FROM Product WHERE Product.name = :name; return p; }
  • Embedded SQL example: look-up int getPrice(char *name) { EXEC SQL BEGIN DECLARE SECTION; char n[20]; int p; char SQLSTATE[6]; EXEC SQL END DECLARE SECTION; strcpy(n, name); /* copy name to local var */ EXEC SQL SELECT price INTO :p FROM Product WHERE Product.name = :n; return p; }
  • Cursors (quickly to 32)
    • For product’s price, looked up single (scalar) value
    • Q: What if we SELECT multiple fields?
      • E.g., find all info for some product
    • A: Just list destination vars separated by commas
    • Q: What if find multiple rows ?
      • E.g., find all products above a certain price
    • Use a cursor to step through the results
      • Each result placed in an array
    • Using cursors:
      • Declare the cursor
      • Open the cursor
      • Fetch tuples one by one
      • Close the cursor
  • Cursor loop structure
    • Each time around loop, we
      • Do a FETCH to obtain next row
      • Examine SQLSTATE to check success
      • Can say:
    • What is NO_MORE_TUPLES ?
    #define NO_MORE_TUPLES !(strcmp(SQLSTATE,”02000”)) if(NO_MORE_TUPLES) break;
  • Multiple-row look-up example void productToXML() { EXEC SQL BEGIN DECLARE SECTION; char pn[20], cn[30]; double p; int q; char SQLSTATE[6]; EXEC SQL END DECLARE SECTION; EXEC SQL DECLARE crs CURSOR FOR SELECT pname, price, quantity, maker FROM Product; EXEC SQL OPEN crs; ...
  • Multiple look-up example printf(&quot;<allProducts> &quot;); while (1) { EXEC SQL FETCH FROM crs INTO :n, :p, :q,:c; if ( NO_MORE_TUPLES ) break; printf(“<product> ”); printf(“ <name>%s</name> ”, n); printf(“ <price>%d</price> ”, p); printf(“ <quantity>%d</quantity> ”, q); printf(“ <maker>%s</maker> ”, c); printf(“</product> ”); } EXEC SQL CLOSE crs; printf(“</allProducts> ”); }
  • More on Cursors
    • Cursors can traverse both stored tables and queries
    • Cursors can modify a relation as well as read it
    • Cursors can be protected against changes to the underlying relations
    • Can determine the order in which the cursor will get tuples by the ORDER BY keyword in the SQL query
    • The cursor can be a scrolling one: can go forward, backward
      • +n, -n, Abs(n), Abs(-n)
  • Cursor on query not table EXEC SQL DECLARE c CURSOR FOR SELECT beer, price FROM Sells WHERE bar = ‘Izzy''s'; EXEC SQL OPEN CURSOR c; while(1) { EXEC SQL FETCH c INTO :theBeer, :thePrice; if (NOT FOUND) break; /* format and print beer and price */ } EXEC SQL CLOSE CURSOR c;
  • Modifications with cursors
    • As we traverse through result set, can modify the current row
      • Can also modify with arb. WHERE clauses
    • NB: In regular SQL, usually modify sets of rows ( UPDATE WHERE …)
    • With cursors, we update the last row fetched
    • Simple example: in RentStab table, we decide we want
      • to raise (e.g., by 5%) all our prices
      • Unless price > 2000, in which case they’re deleted
  • Modification by cursor example void raisePrices() { EXEC SQL BEGIN DECLARE SECTION; double p; char SQLSTATE[6]; EXEC SQL END DECLARE SECTION; EXEC SQL DECLARE crs CURSOR FOR SELECT price FROM RentStab; EXEC SQL OPEN crs; ...
  • Modification by cursor example while (1) { EXEC SQL FETCH FROM crs INTO :p; if ( NO_MORE_TUPLES ) break; if (p < 2000) EXEC SQL UPDATE RentStab SET price = 1.05*price; WHERE CURRENT OF RentStab; else EXEC SQL DELETE FROM RentStab WHERE CURRENT OF RentStab; } EXEC SQL CLOSE crs; }
  • Limitation of embedded SQL
    • Okay for apps with a fixed set of queries/updates
      • Maybe very simple kiosks
    • But consider, say, sqlplus or the sqlzoo website
      • Processes arbitrary queries from user
    • Can we do this with embedded SQL?
  • Dynamic SQL
    • In dynamic SQL , query string can be taken as a parameter, passed to DB
    • Two steps:
      • Prepare: compiles/optimizes the string
      • Execute: executes the query
    • Combine together: EXECUTE IMMEDIATE
      • But separate if query is executed many times (why?)
  • Dynamic SQL
    • myquery = a SQL variable
      • not prefixed by :
    void runQuery() { EXEC SQL BEGIN DECLARE SECTION; char *command; EXEC SQL END DECLARE SECTION; /* command set to some query string */ EXEC SQL PREPARE myquery FROM :command; EXEC SQL EXECUTE myquery; /* or just: */ EXEC SQL EXECUTE IMMEDIATE :command; }
  • Sketch of sqlplus
    • Something like the sqlplus program could be written as a simple dynamic SQL
      • future hw idea?
    EXEC SQL BEGIN DECLARE SECTION ; char query[MAX QUERY LENGTH]; EXEC SQL END DECLARE SECTION ; /* issue SQL> prompt */ /* read user's text into array query */ EXEC SQL EXECUTE IMMEDIATE :query; /* go back to reissue prompt */
  • Interface: SQL/Host Language
    • Two languages: SQL, host (C/Java/whatever)
    • Benefits:
      • DB code (SQL is portable)
      • SQL, host language focus on own strengths
    • SQL code placed in host language code
    • SQL and host language have diff. data types
      • “ impedance mismatch”
      • Data transferred with “shared variables”
    • Use cursors to access/modify data
    • Error messages placed in SQLSTATE
  • Programs with Embedded SQL Host language + Embedded SQL Preprocessor Host Language + function calls Host language compiler Executable Preprocessor Host language compiler Oracle’s Pro*C gcc prog.pc prog.c a.out
  • Next topic: SQL/CLI (break?)
    • Pro*C converts EXEC SQL code
      • --into what?
    • If we know the API (“Call-Level Interface”), can call library routines by hand
    • Is this better or worse?
      • Pros & cons
    • Won’t cover in depth
  • CLI: Java Host language + Embedded SQL Preprocessor Host Language + function calls Host language compiler Executable Preprocessor Host language compiler Oracle’s Pro*C javac + jar prog.pc Prog.java Proj.class
  • CLI - Overview
    • Similar to what really happens in embedded SQL implementations.
    • Major approaches:
      • SQL/CLI - standard of ODBC
      • JDBC - Java database connectivity
      • See http://cbbrowne.com/info/middleware.html for many options
    • Advantages over embedded SQL:
      • Avoid preprocessor-stage, easier to debug
      • In th., use same program with several DBMS
      • “ write once, run everywhere”
    • Disadvantages:
      • Must keep up to date with API changes
      • DBMS may have conflicting APIs
  • Next topic: JDBC (Java’s CLI)
    • As expected: Java too can talk to SQL
    • In some ways: much nicer
    • JDBC is an interface
      • Changes very little
      • Each vendor writes own plug-in
    • Dev. Strategy: write to API, run w/ the DBMS jar
      • See http:// servlet.java.sun.com/products/jdbc/drivers for 219 (!) JDBC drivers
  • JDBC
    • Load JDBC driver for DBMS:
    • Obtain a connection :
      • What does this mean?
      • Find info here: $ORACLE_HOME/network/admin/tnsnames.ora
    Class.forName(&quot;oracle.jdbc.driver.OracleDriver&quot;) Connection con = DriverManager.getConnection( &quot;jdbc:oracle:thin:@as19.es.its.nyu.edu:1521:STN2&quot;, username, passwd);
  • JDBC
    • Obtain a statement object:
    • Run a query:
    • Or an update:
    Statement stmt = con.createStatement(); stmt.executeQuery(“SELECT * FROM table”); stmt.executeUpdate(“INSERT INTO mytable ” + “ VALUES(‘abc’, ‘def’)”);
  • Prepared Statements in JDBC
    • JDBC also supports prepared statements
    • Obtain a PreparedStatement object:
    • Now execute:
      • When better?
    PreparedStatement ps = con.createStatement( “ SELECT * FROM table”); ps.executeQuery();
  • Obtaining query results
    • “ Cursor” not used, but same idea
    • executeQuery() returns a ResultSet:
    • rs.next() advances to new row, returns false if EOF
      • getInt(i) returns ith column (if an int!) from current row
      • can look up metadata…
    ResultSet rs = ps.executeQuery(); while (rs.next()) { String val1 = rs.getString(1); int val2 = rs.getInt(2); … }
  • Java & parameter-based SQL
    • Like SQL/CLI in C, Java also supports parameterized queries (why?)
    • Prepare structure of query
    • Then can set values
    • When better?
    PreparedStatement ps = conn.prepareStatement( &quot;SELECT * FROM table WHERE f1 = ? and f2 = ?&quot;); ps.setString(1, &quot;abc&quot;); ps.setString(2, &quot;def&quot;); ResultSet rs = ps.executeQuery(); ...
  • Also: ODBC
    • Used by Microsoft platforms/tools, others
    • Access:
      • Start | Control Panel | Administrative Tools | Data Sources (ODBC)
    • Similar to JDBC
    • Won’t cover
  • Next time
    • DBs on the web: PHP, etc.
    • Start working through PHP/MySQL tutorials on website
      • Skim relevant parts of ch.7
    • If you (and your group members) can’t log in, let me know ASAP