Adatbázis Rendszerek II. 7. Gy: Oracle JDBC B I v: T 2015.03.20 M A N 1/104
Témakörök JAVA «-» adatbázis-kezelés JDBC alapok Statement PreparedStatement CallabeStatement Tranzakció kezelés 2/104
A cél: Jávás kliensről manipulálni az adatbázist. 3/104
Kis kitérő Adatbázis elérési módok: Beágyazott SQL: egy algoritmikus nyelvbe (C, Pascal, FORTRAN, stb.) ágyazva alkalmazzuk az SQL nyelv elemeit. Az algoritmikus feladatokat a programnyelv, az adatbázissal kapcsolatos műveleteket az SQL végzi. Hátrány: ha változik az adatbázis, teljesen újra kell írni a programot. ODBC (Open Database Connenctivity): szabványos eljáráskészlet az egyes adatbázisokhoz. Technológia: drivereken keresztül érhetők el az adatbázisok, a driverek felülete egységesen programozható. Így ha változik az adatbázis, csak a drivert kell lecserélni. 4/104
Kis kitérő (2) Adatbázis elérési módok: OO LI (Object Oriented Line Interface): adatbázis elérés objektum orientált módon (JDBC, ADO.NET) WEB LI: adatbázis elérés webes felületről 5/104
A probléma és megoldása A Java objektum-orientált, az adatbázisok többnyire még nem azok. Az adatbázis eléréséhez szükséges egy interfész, ennek kezelése lehet adatbázis függő API-hívások JNI-n keresztül (Java Native Interface), de lehet adatbázis független is JDBC (Java Data Base Connectivity). Adatmanipulációs nyelv mindkét esetben az SQL marad. 6/104
JDBC API Java nyelven íródott osztályokat és interfészeket tartalmazó csomagok, melyek egy standard API-t biztosítanak adatbázis-keretrendszerek, valamint adatbázis alapú alkalmazások fejlesztésére. A JDBC API előnye abban áll, hogy elvileg bármilyen adatforrást elérhetünk vele bármilyen platformon, melyen a java virtuális gép futtatható. Nem kell tehát minden adatbázisszerverre külön programot írni, hanem ugyanaz a kód működni fog bármely adatbázisszerverrel. 7/104
JDBC használat Adatbázis feltétel: szükséges egy meghajtó-program (driver), amellyel az adatbázis-kezelő kielégíti a JDBC specifikációt. A driver rendszerfüggő, az adatbázis gyártójának weblapjáról kell letölteni. Java programozó: a java.sql és a javax.sql csomagokban található osztályok, metódusok segítségével dolgozik, és a programhoz csatolja a használt adatbázis-kezelő JDBC driver-ét. 8/104
A megoldás (1.) Kétrétegű megoldás Kliens-oldal Szerver-oldal SQL Driver Piros, Kék, Zöld 9/104
A megoldás (2.) Háromrétegű megoldás Kliens-oldal Szerver-oldal Alkalmazás DB SQL Driver Piros, Kék, Zöld 10/104
Témakörök JAVA «-» adatbázis-kezelés JDBC alapok Statement PreparedStatement CallabeStatement Tranzakció kezelés 11/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés Eredmények feldolgozása Lekapcsolódás 12/104
Az adatbázis-programozás lépései Kapcsolódás Driver regisztrálása Lekérdezés Kapcsolódás a DBMS-hez Eredmények feldolgozása Lekapcsolódás 13/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés SQL kérés (STATEMENT) összeállítása Eredmények feldolgozása SQL kérés elküldése Lekapcsolódás 14/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés Az eredményhalmaz (CURSOR) rekordonkénti bejárása Eredmények feldolgozása Az értékek átadása programváltozóknak Lekapcsolódás 15/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés Eredményhalmaz lezárása Eredmények feldolgozása SQL kérés lezárása Lekapcsolódás Kapcsolat lezárása 16/104
Az adatbázis-programozás lépései Kapcsolódás Driver regisztrálása Kapcsolódás a DBMS-hez Lekérdezés SQL kérés (STATEMENT) összeállítása SQL kérés elküldése Eredmények feldolgozása Lekapcsolódás Az eredményhalmaz (CURSOR) rekordonkénti bejárása Az értékek átadása programváltozóknak Eredményhalmaz lezárása 17/104 SQL kérés lezárása Kapcsolat lezárása
JDBC alapok Kliens számítógép 18/104
A JDBC programozás lépései (1) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt (ResultSet) 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 19/104
DriverManager Feladatai: Kezeli a különböző adatbázisok elérését szolgáló driver-eket, Kezeli a connection-t (kapcsolatot), Kezeli a statement-eket (SQL kifejezéseket), Kezeli a resultset-eket (cursorokat). 20/104
Az adatbázis-programozás lépései Kapcsolódás Driver regisztrálása Lekérdezés Kapcsolódás a DBMS-hez Eredmények feldolgozása Lekapcsolódás 21/104
A JDBC programozás lépései (4) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 22/104
A Driver (meghajtó) betöltése (1) Feltétel: a Java keresési útvonalán elérhető legyen a fizikai driver. Oracle-höz: ojdbc6.jar Megteremtése: bemásolni a drivert a Java keresési útvonalában szereplő könyvtárba, és telepíteni: set classpath=.; ojdbc6.jar 1. 2. 3. 4. 5. 23/104
A Driver (meghajtó) betöltése (1) Ha a driver elérhető a keresési útvonalon, regisztrálható Javaban: import java.sql.*; public void Reg(){ try {Class.forName("oracle.jdbc.driver.OracleDriver");} catch (ClassNotFoundException e) { System.out.println("Hibás driver regisztráció!" +e.getmessage());} } 24/104
A Driver (meghajtó) betöltése (2) Grafikus felületen: import java.sql.*; import java.awt.*; import javax.swing.*; public void Reg(){ } try {Class.forName("oracle.jdbc.driver.OracleDriver");} catch (ClassNotFoundException ex) {JOptionPane.showMessageDialog(null,"Hibás driver regisztráció!", "BitMan mondja: ",2);} 25/104
A DriverManager működése A DriverManager osztály tartalmaz egy listát a regisztrált driverekkel. A getconnection() metódus hívásakor megpróbálja megtalálni a megfelelő drivert, mely kapcsolódni tud az URL-ben megadott adatbázishoz (sorba kipróbálja a drivereket, míg egyet talál, amely kapcsolódik a megfelelő URL segítségével) Ezt a manager-szintet el lehet kerülni direkt Driver metódus hívásával. (csak ritkán használjuk, pl. ha két driver is van, amelyik hozzá tud kapcsolódni egy bizonyos adatbázishoz és explicit szeretnénk meghatározni, hogy melyikkel akarunk kapcsolódni.) 26/104
A JDBC programozás lépései (4) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 27/104
Kapcsolat létrehozása public Connection Kapcs(String host, String dbname, String uname, String pword){ } Connection conn = null; try { String url = "jdbc:oracle:thin:@"+host+":1521:"+dbname; conn = DriverManager.getConnection(url, uname, pword); } catch (SQLException ex) { System.out.println("AB Kapcsolódás hiba: "+e.getmessage()); conn = null; } return conn; 28/104
A kapcsolat lezárása public void Lekapcs(){ try {conn.close();} catch(exception e) { System.out.println("AB lekapcsolódás Hiba: "+ e.getmessage());} } 29/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés SQL kérés (STATEMENT) összeállítása Eredmények feldolgozása SQL kérés elküldése Lekapcsolódás 30/104
Munka az adatbázisban (1) Amint a kapcsolat létrejött, az adatbázisnak SQL parancsokat küldhetünk. A JDBC API nem korlátoz a kiadható SQL parancsok tekintetében: azaz adatbázis-specifikus vagy akár nem SQL parancsokat is használhatunk. Azt azonban biztosítanunk kell, hogy az adatbázis fel tudja dolgozni a parancsokat. Pl. hívhatunk tárolt eljárásokat egy olyan adatbázisra, amelyik nem támogatja ezeket, de egy kivétel fog dobódni. 31/104
Munka az adatbázisban (2) A JDBC API három interfészt biztosít SQL parancsok küldésére: 1. Statement paraméter nélküli SQL parancsok hívására 2. PreparedStatement paraméteres (?), előfordított SQL parancsok hívására 3. CallableStatement Tárolt eljárások hívására 32/104
Munka az adatbázisban (3) Végrehajtási módok: 1. executeupdate(): Adatmanipulációs (INSERT, UPDATE, DELETE) és adatdefiníciós (CREATE/DROP TABLE) utasítások futtatására 2. executequery(): Eredménytáblát visszaadó utasítások futtatására (SELECT) 3. execute(): Mindkét típus végrehajtására alkalmas 33/104
Munka az adatbázisban (4) SQL Statement Végrehajtó parancs Visszatérő érték típusa Magyarázat Select executequery(sqlp); ResultSet Insert Update Delete Create Drop Alter Tárolt eljárások 34/104 executeupdate(sqlp); execute(sqlp); Int boolean Rekordok (adatok) Az érintett sorok száma, vagy 0. Igaz, ha az első visszatérő adat ResultSet.
A JDBC programozás lépései (4) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 35/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés Eredményhalmaz lezárása Eredmények feldolgozása SQL kérés lezárása Lekapcsolódás Kapcsolat lezárása 36/104
Erőforrások felszabadítása ResultSet lezárása: rs.close(); Statement lezárása: stmt.close(); PreparedStatement lezárása: pstmt.close(); CallableStatement lezárása: cstmt.close(); Kapcsolat lezárása: conn.close(); 37/104
Bolt adatbázis alapprogram (1) 38/104
Bolt adatbázis alapprogram (2) 39/104
Témakörök JAVA «-» adatbázis-kezelés JDBC alapok Statement PreparedStatement CallabeStatement Tranzakció kezelés 40/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés SQL kérés (STATEMENT) összeállítása Eredmények feldolgozása SQL kérés elküldése Lekapcsolódás 41/104
Statement A kapcsolat objektum createstatement() metódusával jön létre, és az executeupdate() vagy az executequery() paranccsal hajtható végre. Statement stmt = conn.createstatement(); Írás jellegű műveletekre: DML (INSERT, UPDATE, DELETE) és DDL (CREATE-, ALTER-, DROP TABLE) int SorDb = stmt.executeupdate("update..."); Olvasásra: Select ResultSet rs = stmt.executequery("select a, b, c FROM Table1"); 42/104
A JDBC programozás lépései (2) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 43/104
Statement használata (1) 44/104
Kissé életszerűbben 45/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés Az eredményhalmaz (CURSOR) rekordonkénti bejárása Eredmények feldolgozása Az értékek átadása programváltozóknak Lekapcsolódás 46/104
A JDBC programozás lépései (3) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 47/104
ResultSet használata (1) 48/104
ResultSet használata (2) 49/104
Módosítható (updateable) ResultSet (1) Statement s = conn.createstatement(resultset.type_forward_only, ResultSet.CONCUR_UPDATABLE); String sqlp = select kód, ár from termék where ár > 3000 ; ResultSet rs = s.executequery(sqlp); while (rs.next()) { } int x = rs.getint( ár ); rs.updateint( ár, (int)(x*(0.9))); rs.updaterow(); 50/104
Módosítható (updateable) ResultSet (2) ResultSet.TYPE_FORWARD_ONLY A ResultSet bejárása csak a legelső rekordtól, egyesével növekedve lehetséges (sor1, sor2, sor3 ) ResultSet.TYPE_SCROLL_INSENSITIVE ResultSet.TYPE_SCROLL_SENSITIVE ResultSet.CONCUR_UPDATABLE Olvasható és módosítható a ResultSet. ResultSet.CONCUR_READ_ONLY 51/104
Témakörök JAVA «-» adatbázis-kezelés JDBC alapok Statement PreparedStatement CallabeStatement Tranzakció kezelés 52/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés SQL kérés (PreparedStatement) összeállítása Eredmények feldolgozása SQL kérés elküldése Lekapcsolódás 53/104
PreparedStatement (1) Akkor használjuk, ha egy SQL utasítást többször is végre akarunk hajtani. Előfordított SQL utasítás Ha a meghajtó támogatja az előfordítást Hatékonyabb, mint többször egy Statement-et kiadni Paraméterezhető (csak IN típusú paraméterek!) setxxx metódusok A paraméter típusának megfelelő setxxx kell! A Statement leszármazottja 54/104
PreparedStatement (2) A kapcsolat objektum preparestatement() metódusával jön létre, és az executeupdate() vagy az executequery() paranccsal hajtható végre. PreparedStatement pstmt = conn.preparestatement( "UPDATE table1 SET name =? WHERE id =?"); pstmt.setstring(1, "Joe"); pstmt.setlong(2, 24357); int SorDb = pstmt.executeupdate(); PreparedStatement pstmt = conn.preparestatement( " SELECT a, b, c FROM Table1 WHERE id =?"); pstmt.setint(1, 4357); ResultSet rs = pstmt.executequery(); 55/104
A JDBC programozás lépései (5) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy PreparedStatementet (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A PStatement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a PreparedStatement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 56/104
PreparedStatement (3) Alkalmazott[ ] beo =... PreparedStatement ps = conn.preparestatement( "insert into Alkalmazott" + "(Név, Fizetés, Szülidő) values (?,?,?)" ); for(int i=0; i<beo.length; i++){ ps.setstring(1, beo[i].getnév()); ps.setint(2, beo[i].getfizetés()); ps.setdate(3, date.valueof(beo[i].getszülidő())); ps.executeupdate(); } ps.close(); "1988.07.16" 57/104
Bolt Termékek 58/104
PreparedStatement (4) 59/104
Bolt Termékek (áremelés után) 60/104
A JDBC programozás lépései (6) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy PreparedStatementet (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A PStatement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a PreparedStatement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 61/104
PreparedStatement (5) PreparedStatement ps = c.preparestatement ( "select title, year_made from movies where year_made >=? and year_made <?"); for (int ev = 1920; ev < 2000; ev += 10){ } 62/104 System.out.println("=Filmek a "+ev+"-s évekből"); ps.setint(1, ev); ps.setint(2, ev+10); ResultSet rs = ps.executequery(); while(rs.next()){ } cim = rs.getstring(1); evs = rs.getint(2); System.out.println(cim+" - "+evs);
Témakörök JAVA «-» adatbázis-kezelés JDBC alapok Statement PreparedStatement CallabeStatement Tranzakció kezelés 63/104
Az adatbázis-programozás lépései Kapcsolódás Lekérdezés SQL kérés (CallableStatement) összeállítása Eredmények feldolgozása SQL kérés elküldése Lekapcsolódás 64/104
CallableStatement (1) Nem-SQL utasítások, pl. tárolt eljárások végrehajtására JDBC eljáráshívási módszer { call eljárásnév [<par1>,<par2>,...] } {?= call függvénynév [<par1>,<par2>...] } Lehetnek bemeneti és kimeneti paraméterei A kimenetiek típusát regisztrálni kell végrehajtás előtt A visszaadott eredményeket (pl. ResultSet) előbb kell feldolgozni, mint a kimeneti paramétereket A PreparedStatement leszármazottja 65/104
CallableStatement A kapcsolat objektum preparecall() metódusával jön létre, és az execute() paranccsal hajtható végre. CallableStatement cs = con.preparecall("{call EljNév(?,?)}"); cs.setint(1, kod); cs.setstring(2, feltetel); cs.execute(); CallableStatement cs = con.preparecall("{? = call FgvNév(?)})"; cs.registeroutparameter(1, java.sql.types.integer); cs.setstring(2, feltetel); cs.execute(); out = cs.getint(1); 66/104
A JDBC programozás lépései (7) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy CallableStatement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A CStatement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a CallableStatement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 67/104
Bolt Tárolt eljárás KatNevMod nevű tárolt eljárás, mely módosítja egy paraméterként megadott kódú kategória nevét. create procedure KatNevMod (kk in char, kn varchar) as begin update Kategoria set Nev= kn where kkod= kk; end; 68/104
KatNevMod tárolt eljárás létrehozása 69/104
CallableStatement (2) KatNevMod hívása 70/104
CallableStatement (2) KatNevMod hívása 71/104
Bolt Tárolt függvény Bevetel nevű tárolt függvény, mely megadott nap bevételét adja vissza. create or replace function Bevetel (ip varchar) return int as bev int; begin select sum(ar*darab) into bev from Termek T inner join Vasarlas V on T.Tkod=V.Tkod where datum = ip; return bev; end; 72/104
Bevetel tárolt függvény létrehozása 73/104
CallableStatement (3) Bevetel hívása 74/104
CallableStatement (4) CallableStatement cs = conn.preparecall ( "{ call szabad_helyek(?,?,? ) }" ); IN paraméter cs.setstring(1, "MA-723"); cs.registeroutparameter(2, java.sql.types.boolean); cs.registeroutparameter(3, java.sql.types.integer); cs.execute(); // eredmények feldolgozása, ha vannak boolean dohányzó = cs.getboolean(2); int szabadhelyek = cs.getint(3); OUT paraméter OUT paraméter OUT paraméterek 75/104
CallableStatement (5) CallableStatement cs = conn.preparecall( "{call updateprices(?,?)}"); cs.setstring(1, "Colombian"); cs.setfloat(2, 8.49f); cs.addbatch(); cs.setstring(1, "Italian"); cs.setfloat(2, 9.49f); cs.addbatch();... IN paraméterek, batch végrehajtás cs.executebatch(); 76/104
CallableStatement (6) CallableStatement cs = conn.preparecall( "{call gettestdata(?,?)}"); cs.registeroutparameter(1, java.sql.types.tinyint); cs.registeroutparameter(2, java.sql.types.decimal); ResultSet rs = cs.executequery(); //... byte x = cs.getbyte(1); java.math.bigdecimal n = cs.getbigdecimal(2); OUT paraméterek 77/104
CallableStatement (7) CallableStatement cs = conn.preparecall("{call revisetotal(?)}"); cs.setbyte(1, (byte)25); cs.registeroutparameter(1, java.sql.types.tinyint); cs.executeupdate(); byte x = cs.getbyte(1); INOUT paraméter! 78/104
CallableStatement (8) public void performfunccall() { } 79/104 try { CallableStatement cs = null; double monthlysalary; cs = conn.preparecall("{? = call get_employee_salary(?)}"); cs.registeroutparameter(1,java.sql.types.integer); cs.setstring(2, "A101"); cs.execute(); monthlysalary = cs.getint(1); cs.close(); Függvény hívás System.out.println("Monthly salary is $"+monthlysalary+".\n"); IN paraméter! } catch (SQLException e) { e.printstacktrace(); }
Témakörök JAVA «-» adatbázis-kezelés JDBC alapok Statement PreparedStatement CallabeStatement Tranzakció kezelés 80/104
Tranzakció kezelés (1) Akkor lehet rá szükség ha több logikailag összefüggő SQL utasítást szeretnénk együtt (egy blokkban, közvetlenül egymás után) végrehajtani. Ezeknek az SQL utasításoknak általában van egy logikai sorrendje. Ha bármelyik SQL utasítás meghiúsul, akkor a logikailag ráépülő többi eljárást is vissza kell vonni. Példák: 81/104 Több oldalas regisztráció, ahol minden oldalhoz tartozó adat külön SQL utasítással bekerül az adatbázisba. Ha az x. oldal után a felhasználó nyom egy mégse gombot, akkor az eddig végrehajtott SQL insert-eket is érvénytelenítenünk kell.
Tranzakció kezelés (2) Banki műveletek átutalás egy számláról egy másikra, vagy készpénzfelvétel az automatából: Először megterhelődik az egyik számla a kívánt összeggel, ezután jóváíródik a másik számlán, vagy kiadja az automata. Ha a második lépés meghiúsul (pl.: az automata technikai okok miatt nem tud pénzt kiadni) akkor az első műveletsort is vissza kell vonni. Ezekben az esetekben az SQL utasításokat egy tranzakcióban kezeljük. Ez a teljes tranzakció csak akkor hajtódik végre, ha mi erre a programunkból direkt felszólítjuk, egészen addig az adatbázis-kezelő elkülönítve kezeli őket. A tranzakció közben bármikor lehetőség van arra, hogy az addig kiadott SQL utasításokat érvénytelenítsük, ezzel az adatbázis visszaáll az eredeti állapotához. 82/104
Tranzakció kezelés (3) A tranzakciók kezelésének módját a Connection objecten a setautocommit() metódussal tudjuk megváltoztatni: connection.setautocommit(true): A JDBC alapértelmezésként ezt a beállítást alkalmazza, vagyis nem használ tranzakciókat. Ebben a módban minden egyes kiadott SQL utasítás azonnal végrehajtódik, és nem vonható vissza. connection.setautocommit(false): Ebben az esetben (AutoCommit mód kikapcsolva), az SQL utasítások tranzakciókba (csoportokba) rendezhetők, és csak akkor hajtódnak végre vagy vonódnak vissza, ha a connection-ön meghívjuk a commit() vagy rollback() metódusokat. 83/104
Tranzakció kezelés (4) A commit() hatására a tranzakció utasításai véglegesen bekerülnek az adatbázisba, míg a rollback() visszaállítja az adatbázist a tranzakció megkezdése előtti állapotába. SavePoint: egy köztes pontot jelöl meg egy tranzakción belül és lehetővé teszi, hogy egy tranzakció visszagördüljön addig a pontig ahelyett, hogy a teljes tranzakció visszagördüljön. Savepoint sp1 = connection.setsavepoint("sp1"); connection.rollback(sp1); 84/104
Tranzakció kezelés (5) Egy tranzakcióhoz több Savepoint-ot rendelhetünk. Ezek automatikusan törlődnek commit vagy teljes rollback esetében. Ha egy bizonyos Savepoint-ig gördítünk vissza, az utána definiált Savepoint-ok törlődnek. Expliciten is törölhetünk Savepoint-ot: conn.releasesavepoint(sp1); Ha egy automatikusan vagy expliciten törölt Savepoint-ra hivatkozunk, SQLException kivétel dobódik. 85/104
A JDBC programozás lépései (8) 1. Regisztráljuk a Driver-t a DriverManager-ben. 2. Létrehozunk egy adatbázis kapcsolatot: a DriverManager-től kérünk egy Connection-t 3. Tranzakció kezdete 4. A Connection-ben létrehozunk egy Statement-et (beállítjuk a kapcsolatot egy SQL parancs kiadására) 5. A Statement-hez hozzákapcsolunk egy SQL parancsot 6. Ha szükséges, megadjuk az SQL parancs paramétereit 7. Végrehajtjuk a Statement-et 8. Feldolgozzuk az eredményhalmazt 9. Tranzakció vége 10. Felszabadítjuk az erőforrásokat 86/104
Tranzakciók (2) Connection connection = DriverManager.getConnection(url, username, passwd); connection.setautocommit(false); try { statement.executeupdate(...); statement.executeupdate(...); connection.commit(); } catch (Exception e) { try { connection.rollback(); } catch (SQLException sqle) { // Hiba esetén } } finally { try { connection.close(); } catch (SQLException sqle) { } } 87/104
Tranzakció izolációs szintek (1) Azt határozzák meg, hogy hogyan kezelje a szerver az egyidejű hozzáférési kérelmeket (read, update, insert) ugyanahhoz az objektumhoz (tábla, rekord, ). 1. TRANSACTION_NONE: A tranzakciók nem támogatottak, nincs tranzakció kezelés. 2. TRANSACTION_READ_UNCOMMITED: Olvasáskor mindig az aktuális (módosított) értéket kapjuk, még akkor is, ha az adott insert/update tranzakciót a kezdeményező nem commit-olta. A következő problémák léphetnek fel: Dirty reads: A kiolvasott rekord értéke változhat más tranzakciók által a mi tranzakciónk ideje alatt. Tehát előfordulhat, hogy a tranzakciónk elején és végén az adott rekordban más értékek szerepelnek, holott mi nem is változtattuk, csak olvastuk 88/104
Tranzakció izolációs szintek (2) Non-repeatable reads: A tábla egy adott sora törlődhet a mi tranzakciónk közben. Így amikor mi a tranzakciónk elején és végén futtatunk egy-egy select-et, akkor a második esetben hiányozhatnak sorok az eredményből. Phantom reads: Hasonló az előzőhöz, csak inserttel. A táblába új sor (fantom sor) kerülhet egy másik tranzakció által miközben a mi tranzakciónk még fut. Így a tranzakciónk végén több sor lesz az adott táblában, mint amivel számolhattunk az elején 89/104
Anomáliák (1) Konfliktusban álló műveletek keveredése: Két írás egymás után lost update w1(x) w2(x) Olvasás két írás között dirty read w1(x) r2(x) w1(x) Írás két olvasás között non repeatable read r1(x) w2(x) r1(x) Írás két olvasás között phantom read 90/104 r1(x) w2(x) r1(x)
Anomáliák (2) Lost update Elveszett frissítés A=50 1. 2. BEGIN READ(A) w1(x) w2(x) A=50 3. READ(A) A=70 4. A:= A + 20 A=80 A=70 A=80 A 100 5. 6. 7. 8. A:= A + 30 WRITE(A) WRITE(A) END 91/104
Anomáliák (3) Dirty read Piszkos olvasás (ideiglenes frissítés) A=50 1. 2. BEGIN READ(A) w1(x) r2(x) w1(x) A=70 3. A:= A + 20 A=70 4. WRITE(A) A=70 5. READ(A) A=50 6. ROLLBACK(A) A=50 7. WRITE(A) A 70 8. END 92/104
Anomáliák (4) Non repeatable read Nem megismételhető olvasás A=30 1. 2. BEGIN READ(A) r1(x) w2(x) r1(x) B=20 3. READ(B) A=0 4. DELETE(A) A=50 5. SELECT(A+B) A 20 6. END 93/104
Anomáliák (5) Phantom read Fantom olvasás 1. BEGIN r1(x) w2(x) r1(x) S=300 2. SUM(WHERE) I=20 3. INSERT(WHERE) S=320 4. SUM(WHERE) S S 5. END 94/104
Tranzakció izolációs szintek (3) 3. TRANSACTION_READ_COMMITED: Olvasáskor mindig az adott rekord véglegesített értéket kapjuk. Ez az esetek 99%-ra használható, a tranzakcióink mindig csak olyan rekordokat olvasnak, amik véglegesítve vannak, azaz nincs nyitott tranzakció, ami dolgozna rajtuk. A baj ezzel az, hogy ha sokan írják és olvassák az adott rekordot vagy táblát akkor könnyen kialakulhat az a helyzet, hogy az olvasó tranzakciók arra várnak hogy az írás (pl egy nagy tábla update-je) befejeződjön. Ez a főleg a rekordokra vonatkozik így csak a dirty read-től véd, probléma lehet: a non-repeatable reads, 95/104 és a phantom reads.
Tranzakció izolációs szintek (4) 4. TRANSACTION_REPEATABLE_READ: Ez annyival jobb a READ_COMMITTED-nél, hogy már a non-repeatable read hibát is képes kiszűrni a tranzakcióból. Egyszerűbben: csak a rekordok véglegesített értékeit használja, és a rekordok tranzakció közbeni törlése nem befolyásolja a select-eket. Ebben az esetben csak egy probléma marad: a phantom reads 96/104
Tranzakció izolációs szintek (5) 5. TRANSACTION_SERIALIZABLE: Annyival több a REPEATABLE_READ-től, hogy más tranzakció nem írhatja felül a mi tranzakciónk által olvasott értékeket, azaz addig várakoztatja azokat míg be nem fejeződik a tranzakciónk. Így nem fognak tranzakció közben fantom sorok keletkezni a táblában. Itt elég problémás lehet, ha több résztvevő folyamatosan olvas egy táblát, amíg az updatelő szál várakozik, mert a tábla lock-olva van és nem tud bele írni 97/104
Tranzakció izolációs szintek (6) Ezek szintek föntről lefelé egyre költségesebbek lesznek az adatbázisnak, így a tranzakciók végrehajtási sebessége lassul. Az izolációs szinteket a Connection objektumon a settransactionisolation() metódussal állíthatjuk be a tranzakció megkezdése előtt. Például: connection.settransactionisolation( Connection.TRANSACTION_REPEATABLE_READ); 98/104
Órai feladatok 1. Készítsen egy JDBC alkalmazást, mely alkalmas a következőkre: Használja a Termek táblát! 1. Készítsen egy Java metódust, mely kilistázza a képernyőre a tábla adatait. A metódus neve legyen TermekLista. 2. Készítsen egy Java metódust, mely beszúr egy beolvasott paraméterekkel megadott rekordot. A metódus neve legyen Beszur. 3. Készítsen egy Java metódust, mely kétlépcsős technikával (preparestatement) legalább 3 db, valamilyen adatszerkezetben tárolt rekordot szúr be. Az eljárás írja ki a beszúrt rekordok számát. A metódus neve legyen Beszur_2. 4. Készítsen egy Java metódust, mely módosítja egy adott Tkod-ú rekord Ár mezőjében lévő értékét (egy megadott értékre). A metódus neve legyen Modosit. 5. Készítsen menüt a programhoz, mely a TermekLista, a Beszur a Modosit és a Kilépés funkciókat kezeli. 99/104
Órai feladatok 2. Készítsen egy JDBC alkalmazást, mely alkalmas a következőkre: Használja a Termek táblát! 1. Készítsen egy Java metódust, melyben létrehoz egy tárolt függvényt. A függvény adja vissza egy megadható kategóriájú termék darabszámát a Termék táblából. 2. Készítsen egy Java metódust, mely lefuttatja az 1. feladatban létrehozott tárolt függvényt, és az eredményt kiírja a képernyőre. 3. Készítsen egy Java metódust, melyben létrehoz egy tárolt eljárást. Az eljárás módosítsa egy megadható kódú termék nevét (egy szintén megadható értékre) a Termék táblában. 4. Készítsen egy Java metódust, mely lefuttatja a 3. feladatban létrehozott tárolt eljárást, ezután visszaolvassa az adatbázisból, és kiírja a képernyőre az adott termék tényleges (módosítás utáni) nevét. 100/104
Órai feladatok 3. Készítsen egy egyetlen osztályból álló JAVA programot, mely a main metódusban kapcsolódik az Oracle szerverhez. Készítse el, és futtassa le az alábbi metódusokat: 1. Készítsen egy Java metódust, mely létrehoz egy táblát az Oracle szerveren. A táblában legyen egy KÓD mező, mely legyen numerikus, és legyen elsődleges kulcs. Legyen a táblában egy NÉV mező, és egy NUMERIKUS adatmező, melyben 10000-es nagyságrendű, két tizedes pontosságú adatokat kell tárolni. A tábla sémája [ Kulcs, Név, Num_adat ] 2. Készítsen egy Java metódust, mely beszúr egy statikus paraméterekkel megadott rekordot. 3. Készítsen egy Java metódust, mely kétlépcsős technikával legalább 3, valamilyen adatszerkezetben tárolt kódú rekordot módosít. Az eljárás írja ki a ténylegesen módosított rekordok számát. 101/104
Órai feladatok 3. 4. Készítsen egy Java metódust, mely kilistázza a képernyőre a tábla adatait. 5. Készítsen egy Java metódust, melyben létrehoz egy tárolt eljárást. A tárolt eljárás módosítja egy paraméterként kapott azonosítójú rekord numerikus mezőjében lévő értékét egy szintén paraméterként kapott értékre. 6. Készítsen egy Java metódust, mely lefuttatja az 5. feladatban létrehozott tárolt eljárást, ezután visszaolvassa az adatbázisból, és kiírja a képernyőre az adott termék tényleges (módosítás utáni) numerikus értékét. 7. A main metódusban szabadítsa fel a használt erőforrásokat! 102/104
Felhasznált irodalom Kovács László: Adatbázis rendszerek 2., elektronikus jegyzet Barabás Péter: Adatbázis rendszerek 2., elektronikus jegyzet Kozsik Tamás: JDBC, elektronikus jegyzet http://www.cs.ubbcluj.ro/~bittologatok/ - JDBC adatbázis-hozzáférés java-ban, elektronikus jegyzet 103/104
VÉGE V É G E 104/104