Adatbázis Rendszerek II. 7. Ea: MySQL – JDBC
B I T MAN
1/87
B Iv: T2014.02.15 MAN
Témakörök
JAVA «-» adatbázis-kezelés
JDBC alapok
Statement
PreparedStatement CallabeStatement
2/87
Tranzakció kezelés
B I T MAN
A cél: Jávás kliensről manipulálni az adatbázist.
3/87
B I T MAN
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.
4/87
B I T MAN
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.
5/87
B I T MAN
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.
6/87
B I T MAN
A megoldás (1.) Kétrétegű megoldás Kliens-oldal
Szerver-oldal
SQL
Driver
7/87
Piros, Kék, Zöld
B I T MAN
A megoldás (2.) Háromrétegű megoldás Kliens-oldal
Szerver-oldal Alkalmazás
DB
SQL
Driver
8/87
Piros, Kék, Zöld
B I T MAN
Témakörök
JAVA «-» adatbázis-kezelés
JDBC alapok
Statement
PreparedStatement CallabeStatement
9/87
Tranzakció kezelés
B I T MAN
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 10/87
B I T MAN
JDBC alapok
11/87
B I T MAN
B I T MAN
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).
12/87
B I T MAN
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 13/87
B I T MAN
A Driver (meghajtó) betöltése (1) Feltétel: a Java keresési útvonalán elérhető legyen a
fizikai driver. MySQL-hez: mysql-connector-java-5.1.24-bin.jar Megteremtése: bemásolni a drivert a Java keresési útvonalában szereplő könyvtárba, és telepíteni: set classpath=.; mysql-connector-java-5.1.24-bin.jar
14/87
B I T MAN
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("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) { System.out.println("Hibás driver regisztráció!"+e.getMessage());} } 15/87
B I T MAN
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("com.mysql.jdbc.Driver");} catch (ClassNotFoundException ex) {JOptionPane.showMessageDialog(null,"Hibás driver regisztráció!", "BitMan mondja: ",2);} }
16/87
B I T MAN
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.) 17/87
B I T MAN
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 18/87
B I T MAN
Kapcsolat létrehozása public Connection Kapcs(String host,String dbname, String uname, String pword){ Connection conn = null; try { String url = "jdbc:mysql://”+host+":3306/"+dbname; conn = DriverManager.getConnection(url,uname,pword); //conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bolt","root", "root"); } catch (SQLException ex) { System.out.println("SQL Hiba: "+e.getMessage()); conn = null; } return conn; } 19/87
B I T MAN
A kapcsolat lezárása public void Lekapcs(){ try {conn.close();} catch(Exception e) { System.out.println("SQL Hiba: "+e.getMessage());} }
20/87
B I T MAN
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.
21/87
B I T MAN
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
22/87
B I T MAN
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
23/87
B I T MAN
Munka az adatbázisban (4) SQL Statement Select Insert Update Delete Create Drop Alter Tárolt eljárások 24/87
Végrehajtó parancs
Visszatérő érték típusa
executeQuery(sqlp);
ResultSet
executeUpdate(sqlp);
Int
execute(sqlp);
boolean
Magyarázat Adatbázis adatok
Az érintett sorok száma, vagy 0.
Igaz, ha az első visszatérő adat ResultSet.
B I T MAN
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 25/87
B I T MAN
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();
26/87
B I T MAN
Bolt adatbázis – alapprogram (1)
27/87
B I T MAN
Bolt adatbázis – alapprogram (2)
28/87
B I T MAN
Témakörök
JAVA «-» adatbázis-kezelés
JDBC alapok
Statement
PreparedStatement CallabeStatement
29/87
Tranzakció kezelés
B I T MAN
Statement A kapcsolat objektum createStatement()
metódusával jön létre, és az executeUpdate() vagy az executeQuery() paranccsal hajtható végre. Statement stmt = con.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"); 30/87
B I T MAN
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 31/87
B I T MAN
Statement használata (1)
32/87
B I T MAN
Kissé életszerűbben
33/87
B I T MAN
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 34/87
B I T MAN
ResultSet használata (1)
35/87
B I T MAN
ResultSet használata (2)
36/87
B I T MAN
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(); }
37/87
B I T MAN
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
38/87
B I T MAN
Témakörök
JAVA «-» adatbázis-kezelés
JDBC alapok
Statement
PreparedStatement CallabeStatement
39/87
Tranzakció kezelés
B I T MAN
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
40/87
B I T MAN
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 = con.prepareStatement( "UPDATE table1 SET name = ? WHERE id = ?"); pstmt.setString(1, "Joe"); pstmt.setLong(2, 24357); int SorDb = pstmt.executeUpdate(); PreparedStatement pstmt = con.prepareStatement( " SELECT a, b, c FROM Table1 WHERE id = ?"); pstmt.setInt(1, 4357); B I T MAN 41/87 ResultSet rs = pstmt.executeQuery();
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 42/87
B I T MAN
PreparedStatement (3) Alkalmazott[ ] beo = ... PreparedStatement ps = conn.prepareStatement( "insert into Alkalmazott" + "(Név, Fizetés, Szülidő) values (?,?,?)" ); for(int i=0; i
"1988.07.16"
43/87
B I T MAN
Bolt – Termékek
44/87
B I T MAN
PreparedStatement (4)
45/87
B I T MAN
Bolt – Termékek (áremelés után)
46/87
B I T MAN
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 47/87
B I T MAN
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){ 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); } } 48/87
B I T MAN
Témakörök
JAVA «-» adatbázis-kezelés
JDBC alapok
Statement
PreparedStatement CallabeStatement
49/87
Tranzakció kezelés
B I T MAN
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 50/87
B I T MAN
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(); B I T MAN out 51/87= cs.getInt(1);
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 52/87
B I T MAN
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. DELIMITER // CREATE PROCEDURE KatNevMod (in kk char(3), in kn varchar(20)) BEGIN Update Kategória set Név= kn where kkód= kk; END; // DELIMITER ; CALL KatNevMod(′k01′, ′Élelmiszer′); 53/87
B I T MAN
KatNevMod tárolt eljárás létrehozása
54/87
B I T MAN
CallableStatement (2) – KatNevMod hívása
55/87
B I T MAN
CallableStatement (2) – KatNevMod hívása
56/87
B I T MAN
Bolt – Tárolt függvény Bevetel nevű tárolt függvény, mely megadott nap bevételét adja vissza. DELIMITER // CREATE FUNCTION Bevetel (ip varchar(15)) returns int BEGIN DECLARE bev int default 0; set ip = Concat(ip,’%’); select sum(Ár*Darab) into bev from Termék T inner join Vásárlás V ON T.Tkód=V.Tkód where időpont like ip; RETURN bev; END; // DELIMITER ; SELECT Bevetel(′2013-03-21′); 57/87
B I T MAN
Bevetel tárolt függvény létrehozása
58/87
B I T MAN
CallableStatement (3) – Bevetel hívása
59/87
B I T MAN
CallableStatement (4) CallableStatement cs = conn.prepareCall ( "{ call szabad_helyek( ?, ?, ? ) }" );
IN paraméter OUT paraméter
cs.setString(1, "MA-723"); cs.registerOutParameter(2, java.sql.Types.BOOLEAN); cs.registerOutParameter(3, java.sql.Types.INTEGER); cs.execute(); OUT paraméter // eredmények feldolgozása, ha vannak boolean dohányzó = cs.getBoolean(2); int szabadHelyek = cs.getInt(3); OUT paraméterek
60/87
B I T MAN
CallableStatement (5) CallableStatement cs = conn.prepareCall( "{call updatePrices(?, ?)}"); cs.setString(1, "Colombian"); IN paraméterek, batch végrehajtás cs.setFloat(2, 8.49f); cs.addBatch(); cs.setString(1, "Italian"); cs.setFloat(2, 9.49f); cs.addBatch(); . . . cs.executeBatch();
61/87
B I T MAN
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(); // . . . OUT paraméterek byte x = cs.getByte(1); java.math.BigDecimal n = cs.getBigDecimal(2);
62/87
B I T MAN
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!
63/87
B I T MAN
CallableStatement (8) public void performFuncCall() { CallableStatement cs = null; double monthlySalary; Függvény hívás IN paraméter! try { 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(); System.out.println("Monthly salary is $"+monthlySalary+".\n"); } catch (SQLException e) { e.printStackTrace(); } } B I T MAN 64/87
Témakörök
JAVA «-» adatbázis-kezelés
JDBC alapok
Statement
PreparedStatement CallabeStatement
65/87
Tranzakció kezelés
B I T MAN
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:
– 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. 66/87
B I T MAN
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. 67/87
B I T MAN
Tranzakció kezelés (3) A tranzakciók kezelésének módját a Connection object-
en 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. 68/87
B I T MAN
Tranzakció kezelés (4) A commit() hatására a tarnzakció 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);
69/87
B I T MAN
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: con.releaseSavepoint(sp1); Ha egy automatikusan vagy expliciten törölt Savepoint-ra hivatkozunk, SQLException kivétel dobódik.
70/87
B I T MAN
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 71/87
B I T MAN
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) { } } 72/87
B I T MAN
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… B I T MAN 73/87
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…
74/87
B I T MAN
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, – és a phantom reads. 75/87
B I T MAN
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
76/87
B I T MAN
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…
77/87
B I T MAN
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:
78/87
connection.setTransactionIsolation( Connection.TRANSACTION_REPEATABLE_READ);
B I T MAN
Adatbázis Rendszerek II. Ellenőrző kérdések
B I T MAN
79/87
B I T MAN
Ellenőrző kérdések 1. 1. Milyen sorrendben jelennek meg egy Java programban az alábbi kifejezések? Kezdje a számozást a legkorábbival. STATEMENT CONNECTION RESULTSET DRIVER SQL parancs 2. Melyik (alapértelmezett) porton kapcsolódik a JDBC a MySQL szerverhez? A: 8080 B: 1121 C: 3306 D: 6603 80/87
B I T MAN
Ellenőrző kérdések 2. 3. Mi a paraméterek helyes sorrendje a JDBC-MySQL kapcsolat kiépítésénél? Port Password User Adatbázis Host 4. Melyik csomagot kell importálni JDBC-MySQL adatbázis kezeléshez? A: jdbc.mysql; B: java.mysql; C: mysql; D: java.sql; E: jdbc.sql; F: jdbc; 81/87
B I T MAN
Ellenőrző kérdések 3. 5. Egészítse ki a táblázatot! SQL parancs
SELECT 1. 2.
Végrehajtás 3.
executeUpdate(); 4.
Visszatérő típus 5. 6.
Logikai
6. Ha ? van egy kiadott parancsban, akkor az: A: Statement B: PreparedStatment C: CallableStatement D: Bármelyik kifejezés lehet 82/87
B I T MAN
Ellenőrző kérdések 4. 7. Egészítse ki a kódot! 1. 2. public static void CloseConn(){ if (conn != 3. null ) { 4. trii { conn. 5. close (); System.out.println("Sikeres lekapcsolódas"); 6. } catch (Exception ex) { System.err.println(ex.getMessage());} } }
83/87
B I T MAN
Ellenőrző kérdések 5. 8. Egészítse ki a kódot! public static void Select(){ 1. String sqlp = "select * from kategória order b kkód"; String nev="", id=""; try { 2. s = conn. crstmt (); s. execq (sqlp); 3. 4. rs = s.getrs (); while( rs.nex() ){ 5. id = rs.getString("Kkód"); 6. nev = rs.getString("Név").trim(); d.print (out+". adatsor: \t"+id+"\t"+nev); 7. } 8. } catch( Excep e) {System.out.println("Gond:"+e.getMessage());} } 84/87
B I T MAN
Ellenőrző kérdések 6. 9. Egészítse ki a kódot! public static String CallFunc(String datum){ String sqlp = "{? =1.call Bevetel(?)}"; String vm = ""; try { 2. CallableStatement cs = conn.prepc (sqlp); cs. reoup (1, j.s.t.ch ); 3. 4. cs.setString(2, datum); cs.execute(); vm = cs. getStri (1); 5. 6. cs. Close (); vm = "A "+datum+" napi bevétel: "+vm; } catch(Exception e) {vm = "Bevétel gond: "+e. getmes ();} 7. 1. 8. vm ret ; } 85/87
B I T MAN
Felhasznált irodalom Kovács László: PL/SQL, 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
86/87
B I T MAN
VÉGE V ÉGE 87/87
B I T MAN