uzdevums · web viewpriekš programmēšanās java valodā vispirms ir jāinstalē...
TRANSCRIPT
Saturs
1. Uzdevums.................................................................................................3
2. Java klases izveide...................................................................................4
3. Java klases ielādē datu bāzes sistēma.....................................................7
3.1. Programmas loadJava izmantošana................................................................7
3.2. Programmas createJava izmantošana.............................................................8
3.3. Java klašu metadatu izgūšana.........................................................................9
4. Datu bāzes interfeisa Java Database Connectivity (JDBC) izmantošanās pamatprincipi.......................................................................................11
5. Java klases metožu izmantošana SQL komandu realizēšanā..............14
6. Java klases programma datu ievadei un izvadei no datubāzes tabulās17
7. Java procedūras izsaukšanā no trigera................................................23
Secinājumi.......................................................................................................27
Literatūra.........................................................................................................28
1. Uzdevums3. Java programmēšanas valodas izmantošana DB serverī.
Java programmēšanas valodas izmantošana datu bāzes serverī. (darbs obligāts). Izpildes termiņš: 17. novembris.
Kursa “Lielās datu bāzes” (DB2) darbi jāsūta pa e-pastu uz adresi [email protected]
1. Nelielas Java klases programmas (bez savienojuma ar datu bāzei) definēšana (fails *.java), kompilēšana (javac.exe) un izpilde (java.exe).
2. Java klases programmas definēšana un ielāde datu bāzes sistēmā (programmas loadjava un komandas create Java izmantošana) . Java klases metodes izsaucošo PL/SQL funkciju izveide un izpilde. Java klašu metadatu apskate datu bāzes vārdnīcā.
5. Datu bāzes interfeiss Java Database Connectivity (JDBC), tā izmantošanas pamatprincipi.
4. Java klases metožu izmantošanas SQL komandu realizēšanai.
5. Java klases programmu uzrakstīšana datu ievadei tabulā un datu izgūšanai no tabulas. Java klases datu ievades un izgūšanas metožu izsaukšana.
6. Secinājumi (kas labs, kas slikts, kas noskaidrots).
2
2. Java klases izveidePriekš programmēšanās Java valodā vispirms ir jāinstalē Java izpildes vide
“Java Developer Kit” no Oracle interneta lapas. Kad tā ir ieinstalētā, tad ir jāpievieno JDK pie sistēmas mainīgajiem, lai varētu vienkārši kompilēt Java programmas izmantojot komandrindu.
Priekš sistēmas mainīgo rediģēšanas Windows 8.1 operētājsistēma ir jānospiež ar labo pogu uz “MyComputer” jāizvēlās “properties”, “Advanced system settings”. Šajā logā ir jānospiež uz pogas “Environment Variables…” un “New…”. Un tajā ir jāizveido jauns Java sistēmas mainīgais ar noradītu ceļu līdz JDK failam.
Tagad var sākt programmēt Java valodā. Priekš tā ir jāizveido teksta fails ar paplašinājumu .java. To var atvērt ar jebkuru teksta redaktoru, piemērām notepad++.
Izveidosim programmu, kurā ņem divus komandrindas argumentus un saskaita tos kopā un uz ekrānā parādā to summu.
class SummProgram{
public static void main(String [] args){
System.out.println("Programma, kura summe divus ievaditos skaitlus");
if (args.length==2){
int summ =0;
for (int i=0;i<args.length;i++){
try{
summ+=Integer.parseInt(args[i]);
}
catch (Exception e){
System.out.println("Nepareizs "+1+". arguments '" +args[i]+"' tas nav skaitlis!");
}
2.1. att. JDK sistēmas mainīgā definēšanā Windows 8.1 operetājsistēmā
3
System.out.println("Summe "+i+". skaitli "+args[i]);
}
System.out.println("Summa ir: "+summ);
}
else{
System.out.println("Nepareiz argumentu skaits!");
}
}
}
Visām Java programmām ir jāatrodas iekšā klasē, šajā gadījumā “SummProgram”. Pirmā metodē kurā izpildās Java programmā ir galvenā (main) metode, kuru definē kā “public static void main(String [] args)”. Šī metodē kā argumentu ņem simbolu virkņu masīvu “args”, kurš satur konsolē pie programmās izsaukumā pierakstīto argumentu masīvu.
Šī “args” masīvā saturs tiek summēts kopā, pirms tam pārveidojot simbolu virknes par veselajiem skaitļiem ar metodi “Integer.ParseInt()”. Jā neiznāk pārveidot simbolu virknes par skaitļiem, tad try – catch blokā tiek noķerts izņēmums un izvadīts draudzīgs kļūdas paziņojums: “Nepareizs i-tais arguments”. Gadījumā, jā komandrindā doto argumentu skaits nav 2, tiek izvadīts paziņojums: “Nepareizs argumentu skaits!”.
Šo programmu kompilē izmantojot komandrindu, priekš tā sākumā ar komandu “cd” tiek aiziets līdz programmas koda atrašanās vietai un ar komandu “javac SummProgram.java”, tā tiek kompilēta. Programma tiek palaistā ar komandu “java SummProgram 6 5”, kur pēdējie divi skaitļi ir komandrindas argumenti, kurus nodod programmai aprēķināšanai.
2.2. att. Pirmās programmās izpildes rezultāts
4
Kā redzams programmā izvadīja visas ievadītās vērtībās (6 un 5) un to summu 11 (6+5=11).
Jā programmai kā argumentu iedod nevis skaitli, bet gan kādu nesaderīgu datu tipu, tad tiek izmests izņēmumā paziņojums.
Šoreiz otrais arguments bija vārds “Kristaps”, kuru nav iespējams pārveidot par skaitli, tāpēc tiek izvadīts izņēmumā paziņojums “Nepareizs 1. arguments ‘Kristaps’”.
2.3. att. Pirmā programmā ar nepareiziem ievaddatiem
5
3. Java klases ielādē datu bāzes sistēma
3.1. Programmas loadJava izmantošanaLoadJava programma ļauj ielādēt Java klasi Oracle datubāzē izmantojot
komandrindas interfeisu. Tas ļauj uzrakstīt Java kodu uz lokālās mašīnas, tur to notestēt un tikai tad to ielādēt datubāze priekš izmantošanās.
Priekš loadJava programmas izmantošanās piemērā izveidosim Java klasi, kura saturēs statisko metodi, kas ļauj apmainīt simbolu virknes burtu secību no sākumā uz beigām.
class Reverse
{
public static String reverse(String str)
{
String rez = "";
for (int i=str.length()-1;i>=0;i--)
{
rez+=str.charAt(i);
}
return rez;
}
}
Tagad pielietosim loadJava programmu no komandrindās. Neskatoties uz to kā klases ievade tiks veikta uz RTU datubāzes serveri, vienalga ir vajadzīgs dators ar uzliktu Oracle datubāzi, jo tikai tajā ir programma loadJava.
LoadJava izpildes komanda iekšā komandrindā ir sekojošā:
Loadjava –u DB_121RDB737/DB_121RDB737@//85.254.218.228/’DITF11’ –v –r –t Reverse.java
Priekš tā protams ir jāatrodas tajā pašā direktorija, kur atrodas Reverse.java fails. LoadJava programmas darbībā ir attēlotā 3.1. attēlā.
6
Tagad, kad mūsu izveidotā Java klase ir ielādētā Oracle datubāzē, vajag izveidot PL/SQL funkciju, kurā izsauks to.
CREATE OR REPLACE FUNCTION FUNC_REVERSE(S1 VARCHAR2)
RETURN VARCHAR2 AS LANGUAGE JAVA NAME
'Reverse.reverse(java.lang.String) return java.lang.String';
Izsaucot šo funkciju SQL SELECT vaicājuma var pārbaudīt tās darbību. Uzzināsim kā izskatās mans vārds “Kristaps” uzrakstīts no beigām uz sākumu.
SELECT FUNC_REVERSE('Kristaps') FROM DUAL;
3.2. Programmas createJava izmantošanaCreateJava programma ļauj izveidot Java klasi uzreiz iekšā datubāzes sistēmā
un izpildīt to tāpat kā ielādēto no ārpusēs klasi. Priekš šīs programmās piemērā izveidosim klasi ar vienu metodi, kurā summēs trīs skaitļus.
CREATE OR REPLACE JAVA SOURCE NAMED "SUMMA" AS
public class Summa
3.4. att. Programmas loadJava izpildes rezultāts
3.5. att. Java funkcijas darbībās rezultāts
7
{
public static int summet(int i1, int i2, int i3)
{
return i1+i2+i3;
}
};
Tagad ir jāizveido PL/SQL funkcija, kurā izsauks šo Java klases “Summa” funkciju “summet”.
CREATE OR REPLACE FUNCTION FUNC_SUMMET(I1 NUMBER, I2 NUMBER, I3 NUMBER)
RETURN NUMBER AS LANGUAGE JAVA NAME 'Summa.summet(int, int, int) return int';
Šī PL/SQL funkcija “FUNC_SUMMET” kā argumentus ņem trīs NUMBER datu tipa mainīgos, kuri tiek uzreiz nodoti Java funkcijai “summet”.
Funkcija “FUNC_SUMMET()” tiek izsauktā iekšā SQL SELECT vaicājumā.
SELECT FUNC_SUMMET(13,20,11) FROM DUAL;
Rezultātā tiek izvadīts skaitlis 44, kas ir summa no skaitļiem 13, 20, 11.
3.3. Java klašu metadatu izgūšanaPriekš Java klašu metadatu izgūšanas ir jāņem tos ierakstus no
“USER_OBJECTS” tabulas, kuru tips “OBJECT_TYPE” tips ir “JAVA SOURCE”. No šīs tabulas tiek ņemti “OBJECT_ID”, “OBJECT_NAME”, “OBJECT_TYPE” un “CREATED” lauki. Šie lauki parādā objekta id, nosaukumu, tipu un laiku, kad tas tika izveidots.
SELECT OBJECT_ID, OBJECT_NAME, OBJECT_TYPE, CREATED
FROM USER_OBJECTS
WHERE OBJECT_TYPE ='JAVA SOURCE';
3.6. att. Java funkcijas “summet” darbības rezultāts
8
3.7. att. Java klašu metadati
9
4. Datu bāzes interfeisa Java Database Connectivity (JDBC) izmantošanās pamatprincipi
JDBC ir interfeiss priekš no datubāzes neatkarīgas pieslēgumā veidošanas starp Java programmu un dažādām datubāzēm. To var lietot Java lietojumos, appletos un servletos.
Priekš JDBC interfeisa demonstrējumā izveidosim vienkāršu Java programmu, kura pieslēgsies manai Oracle datubāzei no RTU datubāžu servera un iegūs metadatus par visām šīs datubāzes lietotājā tabulām.
Pirms var sākt darbu ar JDBC interfeisu, sākumā ir jāielādē no Oracle mājaslapas “ojdbc6.jar” fails, kurš satur JDBC dzini. Priekš programmas rakstīšanās tiek izmantota Eclipse integrēta izstrādes vide. Tajā tiek izveidots jauns projekts vārdā “DB”.
Šīm projektam vispirms ir jāpievieno JDBC dziņa JAR fails “ojdbc6.jar”. Priekš tā tiek aiziets uz projekta “Properties” -> “Java Build Path” -> “Libraries”. Tur tiek nospiests uz pogas “Add External JARS…” un no failu sistēmas tiek atrasts ielādētais JAR fails.
Tagad var sākt programmēt pašu programmu, kura veiks pieslēgšanos datubāzei. Šī programma saturēs tikai vienu klasi ar main metodi.
import java.sql.*;
public class JDBClass {
public static String URL = "jdbc:oracle:thin:@85.254.218.228:1521:DITF11";
public static String UN = "DB_121RDB737";
4.8. att. JDBC dziņa pievienošana Eclipse projektam
10
public static String PASS ="DB_121RDB737";
public static Connection conn;
public static void main(String [] args)
{
System.out.println("Pieslegsanas datubazei");
try
{
conn = DriverManager.getConnection(URL, UN, PASS);
System.out.println("Veiksmigi piesledzas datubazei!");
Statement komanda=conn.createStatement();
ResultSet rez = komanda.executeQuery("SELECT TABLE_NAME FROM USER_TABLES");
System.out.println("Datubazes METADATI ir:");
while (rez.next())
{
System.out.println(rez.getString("TABLE_NAME"));
}
conn.close();
}
catch (SQLException e)
{
System.out.println("Kluda: "+e.getMessage());
}
}
}
Šī klase ir ļoti vienkārša, tā ar “import” komandu pievieno java.sql.* bibliotēkas, kuras satur vajadzīgās klases un metodes, priekš darbībās ar JDBC interfeisu. Pēc tam iekšā klasē “JDBClass” tiek definēti vairāki statiskie mainīgie: pieslēguma simbolu virkne “URL”, lietotājvārds “UN”, parole “PASS” un pieslēgumā
11
objekts “conn”. Šie mainīgie ir statiski tāpēc kā “main” funkcija, kura tos izsauc ari ir statiskā.
Galvenā “main” funkcija satur pašu pieslēgumu datubāzei, tas ir ievietots try-catch blokā, lai varētu noķert “SQLException” tipa izņēmumu gadījumus. Java programmēšanas valodā parasti visus datu nolasīšanās ielādēs koda fragmentus ir jāieliek izņēmumu apstrādes blokos.
Pēc tam tiek izveidots savienojums ar datubāzi ar kodu “conn = DriverManager.getConnection(URL, UN, PASS);”. Un tajā tiek izpildīts sekojošs SQL SELECT vaicājums.
SELECT TABLE_NAME FROM USER_TABLES
Iegūtais rezultāts ar cikla palīdzību “while (rez.next())” tiek izvadīts uz ekrānā. Rezultātā mēs iegūstām visās datubāzes lietotājā tabulu sarakstu.
4.9. att. Java programmas izgūtie datubāzes metadati
12
5. Java klases metožu izmantošana SQL komandu realizēšanā
JDBC interfeisu ir arī iespējams izmantot iekšā Oracle datubāzē glabājamajās Java klasēs priekš darbībās ar datubāzes tabulām. Tādā veidā var veikt SQL SELECT, INSERT INTO, DROP un citās operācijās.
Priekš vaicājumā realizācijas tiks izmantotā bibliotēkas datubāzes tabulā “GRAMATAS”, kuras shēma ir attēlota 5.1. attēlā.
Priekš piemērā tiks izveidotā Java klase, kurā darbosies Oracle DB serverī un pieslēdzoties šīm serverim veiks vienkāršu vaicājumu. Šīs vaicājums saskaitīs cik daudz grāmatu ir uzrakstījis noteikts rakstnieks.
SELECT COUNT(*) DAUDZUMS
FROM RAKSTNIEKI R INNER JOIN GRAMATAS G ON
G.ID_RAKSTNIEKS = R.RAKSTNIEKA_ID
WHERE R.VARDS = '<vards>' AND R.UZVARDS = '<uzvards>';
Tajā vietā kur ir uzrakstīts <vards> un <uzvards> Java klases kodā tiks ielikts rakstnieka vārds un uzvārds, kurus metode ņems kā argumentus.
CREATE OR REPLACE JAVA SOURCE NAMED "RAKSTN" AS
import java.sql.*;
import oracle.jdbc.*;
public class GetRakstnieki
{
public static int getRakstnBookCount(String vards, String uzvards) throws SQLException
{
int result=0;
5.1. att. Tabulās “GRAMATAS” shēma
13
Connection conn = DriverManager.getConnection("jdbc:default:connection:");
String sql = "SELECT COUNT(*) DAUDZUMS FROM RAKSTNIEKI R INNER JOIN GRAMATAS G ON G.ID_RAKSTNIEKS = R.RAKSTNIEKA_ID WHERE R.VARDS = '"+vards+"' AND R.UZVARDS = '"+uzvards+"'";
Statement stmt = conn.createStatement();
ResultSet rez = stmt.executeQuery(sql);
while (rez.next())
{
result = Integer.parseInt(rez.getString("DAUDZUMS"));
}
conn.close();
return result;
}
};
Galvenā atšķirība ir citādāka pieslēguma simbolu virkne “jdbc:default:connection:”, jo šoreiz pieslēgums notiek pie tās pašas datubāzes, kurā izsauks šo metodi, tāpēc nav nepieciešams norādīt nē lietotājvārdu, ne paroli, ne citus pieslēguma parametrus.
Šoreiz netika izmantots try-catch bloks un iespējamais izņēmums tika vienkārši pārmests tālāk apstrādei JVM un datubāzes sistēmai ar kodu “throws SQLException”. Tālāk tiek izveidots pieslēguma “conn” objekts un tajā tiek veikts SQL vaicājums un rezultāts, kas satur vienu ciparu tiek atgriezts kā metodes atgriežamā vērtībā.
Tālāk ir atkal jāuzraksta PL/SQL funkcija, kura izsauks šīs Java klases metodi.
CREATE OR REPLACE FUNCTION FUNC_DAUDZUMS(S1 VARCHAR2, S2 VARCHAR2)
RETURN NUMBER AS LANGUAGE JAVA NAME 'GetRakstnieki.getRakstnBookCount(java.lang.String, java.lang.String) return int';
Tagad var izveidoto funkciju izsaukt un pārbaudīt iegūto rezultātu. Diemžēl man SQL Developer vidē neiznāca izmantot “CALL” operatoru priekš funkcijas izsaukšanās. Tomēr, meklējot internetā, tika atrasts vel viens veids kā neizmantojot SQL SELECT vaicājumu izsaukt PL/SQL funkciju.
DECLARE
RESULT NUMBER;
14
BEGIN
RESULT:=FUNC_DAUDZUMS('Andrejs','Pumpurs');
DBMS_OUTPUT.PUT_LINE(RESULT);
END;
Lai redzētu šī koda rezultātu sākumā SQL Developer vidē ir jāieslēdz DBMS_OUTPUT konsoli, nospiežot “VIEW” un “DBMS_OUTPUT”. Tālāk ar pluss pogu ir jāieslēdz konsoli priekš vajadzīga datubāzes pieslēgumā.
Tādu pašu rezultātu arī iegūts izsaucot šo funkciju iekšā SQL SELECT vaicājumā.
SELECT FUNC_DAUDZUMS('Andrejs','Pumpurs') FROM DUAL;
5.2. att. Funkcijas darbības rezultāts DBMS Output konsolē
5.3. att. Funkcijas rezultāts izmantojot SQL SELECT vaicājumu
15
6. Java klases programma datu ievadei un izvadei no datubāzes tabulās
Izmantosim iepriekšēja nodaļā apskatītas metodes, lai izveidotu Java klasi priekš datu ievades un izvades no Oracle datubāzes. Šī klase saturēs divas metodes vienu priekš ierakstā ievadēs datubāzē un otrā priekš ierakstā izvadēs no datubāzes.
Priekš piemērā izveidosim Java klasi “JavaIO”, kurā saturēs metodes priekš viena ierakstā ievades tabulā “GRAMATAS” un otrā metodē priekš vienā ierakstā izvadēs no šīs pašās tabulās.
Priekš šo komandu realizēšanās tiks izmantotās divas tabulās no pirmajos praktiskajos darbos izveidotās bibliotēkas datubāzes: “GRAMATAS” un “RAKSTNIEKI”. Šo tabulu shēmas ir attēlotās attēlos 6.1. un 6.2.
Pirmā metodē “insertGramatu” kā argumentus ņems jaunās grāmatās nosaukumu, rakstnieka vārdu un uzvārdu, valsti un gadu. Tā kā tabulā “GRAMATAS” satur lauku priekš ārējās atslēgās uz tabulu “RAKSTNIEKI”, kur glabājās dati par visiem rakstniekiem. Tad pirms ierakstā ievadēs tabulā ar SQL SELECT vaicājumu tiek iegūts atbilstošā rakstniekā ID. Pietam šīs pats vaicājums
6.1. att. Tabulās “GRAMATAS” shēma
6.2. att. Tabulās “RAKSTNIEKI” shēma
16
iegūst lielāko tabulas “GRAMATAS” “GRAMATAS_ID” laukā vērtību un palielinot to par viens iegūst nākamo primāras atslēgas vērtību.
Tālāk šīs iegūtas primārās atslēgās un ārējās atslēgās vērtībās tiek izmantotās priekš datu ievades. Java klase “JavaIO” ar pirmo metodi “insertGramatu” ir sekojošā.
CREATE OR REPLACE JAVA SOURCE NAMED "INSERT_JAVA" AS
import java.sql.*;
import oracle.jdbc.*;
public class JavaIO
{
public static void insertGramatu(String nosaukums, String vards, String uzvards, String valsts, int gads)
{
System.out.println("Pieslegsanas datubazei");
try
{
Connection conn = DriverManager.getConnection("jdbc:default:connection:");
Statement komanda=conn.createStatement();
//ResultSet rez = komanda.executeQuery("SELECT TABLE_NAME FROM USER_TABLES");
String sql_1 = "SELECT (SELECT MAX(G1.GRAMATAS_ID) FROM GRAMATAS G1) LAST_ID, R.RAKSTNIEKA_ID " +
"RAKSTNIEKA_ID FROM GRAMATAS G INNER JOIN RAKSTNIEKI R ON R.RAKSTNIEKA_ID=G.ID_RAKSTNIEKS WHERE R.VARDS = '"+vards+"' AND R.UZVARDS= '"+uzvards+"' GROUP BY R.RAKSTNIEKA_ID";
Statement stmt = conn.createStatement();
//Iegust datus
ResultSet rez = stmt.executeQuery(sql_1);
int next_id =0;
int rakstn_id=0;
while (rez.next())
{
17
next_id= Integer.parseInt(rez.getString("LAST_ID"));
rakstn_id =Integer.parseInt(rez.getString("RAKSTNIEKA_ID"));
}
next_id+=1;
//Ieraksta datus
String sql_2 = "INSERT INTO GRAMATAS VALUES(?,?,?,?,?)";
PreparedStatement pstmt = conn.prepareStatement(sql_2);
pstmt.setInt(1, next_id);
pstmt.setString(2, vards);
pstmt.setInt(3,rakstn_id);
pstmt.setString(4, valsts);
pstmt.setInt(5, gads);
pstmt.executeUpdate();
conn.close();
}
catch (Exception e)
{
}
}
//Seit Bus metode prieks datu izvades
};
Kopumā šī metode ne ar ko daudz neatšķiras no iepriekš apskatītajam metodēm. Tikai šoreiz INSERT INTO SQL kods tika veidots nevis ar simbolu virkņu apvienošanu ar + operatoru, bet gan izmantojot “PreparedStatement” klases objektu. Bez tā INSERT INTO izteiksme tika palaistā nevis ar “executeQuery” metodi, bet gan izmantojot “executeUpdate” metodi.
Protams tagad ir jāizveido PL/SQL metode priekš Java klases metodes izsaukšanās.
18
CREATE OR REPLACE PROCEDURE PROC_INSERT_GRAMATA(S1 VARCHAR2, S2 VARCHAR2, S3 VARCHAR2, S4 VARCHAR2, I1 NUMBER)
AS LANGUAGE JAVA NAME 'JavaIO.insertGramatu(java.lang.String, java.lang.String, java.lang.String, java.lang.String, int)';
Tagad ir jāizsauc šo metodi iekšā anonīmajā PL/SQL blokā un jāpaskatās vai tika izveidots attiecīgs ieraksts tabulā “GRAMATA”.
BEGIN
PROC_INSERT_GRAMATA('Viegli','Imants','Ziedonis','Latvija',1993);
END;
Kā ir redzams šī procedūra neņem “GRAMATAS_ID” un “ID_RAKSTNIEKS” vērtībās, jo tas tiek iegūtās ar SQL SELECT vaicājumā palīdzību.
Tagad šajā pašā klasē pēc komentārā “//Seit Bus metode prieks datu izvades” izveidosim vel vienu Java metodi, šoreiz priekš datu izvadēs no tabulās “GRAMATAS” un “RAKSTNIEKI”.
Šī metodē kā argumentu ņems “GRAMATS_ID” lauka vērtību un atgriezīs informāciju par grāmatu un tās autoru simbolu virknes veidā: “Tika atrasta gramata “‘gramatas_nosaukums’”, to uzrakstija ‘rakstnieka_vards’ ‘rakstnieka_uzvards’, ta tika izdota ‘izdosanas_gads’ gada.”
Rezultātā izveidota Java metode “findGramatu” ir sekojoša:
//Seit Bus metode prieks datu izvades
public static String findGramatu(int id)
{
String result = "";
Connection conn;
6.3. att. Tabulā “GRAMATAS” ar ievietoto ierakstu ar “GRAMATS_ID” 31
19
try
{
conn = DriverManager.getConnection("jdbc:default:connection:");
//ResultSet rez = komanda.executeQuery("SELECT TABLE_NAME FROM USER_TABLES");
String sql = "SELECT G.NOSAUKUMS nosaukums, R.VARDS vards, R.UZVARDS uzvards, G.GADS gads "+
"FROM GRAMATAS G INNER JOIN RAKSTNIEKI R ON G.ID_RAKSTNIEKS=R.RAKSTNIEKA_ID "+
"WHERE G.GRAMATAS_ID = "+id;
Statement stmt = conn.createStatement();
//Iegust datus
ResultSet rez = stmt.executeQuery(sql);
String nosaukums="";
String vards="";
String uzvards="";
int gads = 0;
while (rez.next())
{
nosaukums = rez.getString("nosaukums");
vards = rez.getString("vards");
uzvards = rez.getString("uzvards");
gads = Integer.parseInt(rez.getString("gads"));
}
result ="Tika atrasta gramata \""+nosaukums+"\", to uzrakstija "+vards+" "+uzvards+", ta tika izdota "+gads+" gada.";
conn.close();
}
catch (Exception e)
{
System.out.println("Exception! "+e.getMessage());
}
20
return result;
}
Šai metodei tiek izveidotā jaunā PL/SQL funkcija, kurā izsauks šo Java metodi.
CREATE OR REPLACE FUNCTION FUNC_FIND_GRAMATA( I1 NUMBER) RETURN VARCHAR2
AS LANGUAGE JAVA NAME 'JavaIO.findGramatu(int) return java.lang.String';
Un beigās izsauksim šo funkciju izmantojot SQL SELECT vaicājumu, lai iegūtu pirms tām ar Java metodi iegūto ierakstu.
SELECT FUNC_FIND_GRAMATA(30) FROM DUAL;
Funkcijas izmantošanās rezultāts ir attēlots 6.4. attēlā.
6.4. att. Funkcijas “FUNC_FIND_GRAMATA” darbības rezultāts
21
7. Java procedūras izsaukšanā no trigeraTrigeris ir darbībā kuru datubāze automātiski izpilda pēc kādā tabulas
notikumā: jaunā ierakstā pievienošanās, ierakstā dzēšanās vai izmaiņās un citiem notikumiem. Trigeros var izsaukt datubāzēs glabājamās PL/SQL procedūrās. Un tā kā šīs PL/SQL procedūrās var izsaukt Java procedūrās tad trigeros var veikt sarežģītus algoritmus izmantojot arī JDBC interfeisu.
Izveidosim trigeri kurš katru jauni pievienoto ierakstu no tabulās “GRAMATAS” saglabās tabulā “GRAMATAS_BACKUP” un ģenerēs priekš šīs rezerves tabulās jaunu ID vērtību. Šo funkcionalitāti varētu izmantot priekš visu jauno ierakstu ierakstīšanās datu noliktavā.
Vispirms tiks izveidotā jaunā tabulā “GRAMATAS_BACKUP”, kur arī tiks saglabāti visi jaunie ieraksti. Šai tabulai ir lauks “GRAMATAS_ID” kurš kalpos par šīs tabulās primāro atslēgu, bet lauks “GRAMATAS_SOURCE_ID” saturēs primāro atslēgu no tabulās “GRAMATAS”.
CREATE TABLE GRAMATAS_BACKUP
(
GRAMATAS_ID NUMBER PRIMARY KEY,
GRAMATAS_SOURCE_ID NUMBER,
NOSAUKUMS VARCHAR(60),
ID_RAKSTNIEKS NUMBER,
VALODA VARCHAR(20),
GADS NUMBER
);
Tagad izveidosim pašu Java procedūru priekš ierakstu rezerves kopiju veidošanās. Tā veiks pieslēgumu pie pamatā datubāzes, ar SQL vaicājumu no tabulās “GRAMATAS_BACKUP” noteiks nākamās primārās atslēgās vērtību un ierakstīs jauno rindu šajā tabulā.
CREATE OR REPLACE JAVA SOURCE NAMED "TRIGGER_JAVA" AS
import java.sql.*;
import oracle.jdbc.*;
public class JavaTrigger
{
public static void javaTrigger(int gramatas_id, String nosaukums, int id_rakstnieks, String valoda, int gads)
{
22
Connection conn;
try
{
conn = DriverManager.getConnection("jdbc:default:connection:");
System.out.println("Veiksmigi piesledzas datubazei!");
String sql = "SELECT MAX(G.GRAMATAS_ID) new_id FROM GRAMATAS_BACKUP G";
Statement stmt = conn.createStatement();
//Iegust datus
ResultSet rez = stmt.executeQuery(sql);
int new_id = 0;;
while (rez.next())
{
new_id = Integer.parseInt(rez.getString("new_id"))+1;
}
//Ieraksta datus
String sql_1 = "INSERT INTO GRAMATAS_BACKUP VALUES(?,?,?,?,?,?)";
PreparedStatement pstmt = conn.prepareStatement(sql_1);
pstmt.setInt(1, new_id);
pstmt.setInt(2, gramatas_id);
pstmt.setString(3, nosaukums);
pstmt.setInt(4,id_rakstnieks);
23
pstmt.setString(5, valoda);
pstmt.setInt(6, gads);
pstmt.executeUpdate();
conn.close();
}
catch (Exception e)
{
}
}
};
Pēc tam tiek izveidotā PL/SQL procedūra priekš šīs metodes izsaukšanās.
CREATE OR REPLACE PROCEDURE PROC_INSERT_GRAMATA(I1 NUMBER, S1 VARCHAR2, I2 NUMBER, S2 VARCHAR2, I3 NUMBER)
AS LANGUAGE JAVA NAME 'JavaTrigger.javaTrigger(int,java.lang.String, int, java.lang.String, int)';
Visbeidzot tiek izveidots AFTER INSERT tipa trigeris tabulai “GRAMATAS”, kurš izsauc PL/SQL procedūru “PROC_INSERT_GRAMATA”. Šī procedūrā katrai jaunai tabulās “GRAMATAS” rindai izsauks šo procedūru.
CREATE OR REPLACE TRIGGER BACKUP_GRAMATU
AFTER INSERT
ON GRAMATAS
FOR EACH ROW
BEGIN
PROC_INSERT_GRAMATA(:new.GRAMATAS_ID,:new.NOSAUKUMS,:new.ID_RAKSTNIEKS,:new.VALODA,:new.GADS);
END;
24
Kad ir izveidots trigeris, var veikt tā pārbaudi. Priekš tā ir jāieraksta tabulā “GRAMATAS” jaunu ierakstu un jāpaskatās, vai tas paradīsies tabulā “GRAMATAS_BACKUP”. Veicot trigera pārbaudi izradījās kā tās nestrādāja kā vajag, problēmā bijā tajā kā Java procedūra nevarēja iegūt nākamā ID vērtību no tukšās tabulās un tāpēc nācās tabulā “GRAMATAS_BACKUP” manuāli pievienot vienu ierakstu. Pēc tā trigeris strādāja kā vajag.
INSERT INTO GRAMATAS VALUES (31,'Novembris',5,'Latvija',2003);
Jauni pievienotais ieraksts vienlaikus parādījās gan tabulā “GRAMATAS”, gan “GRAMATAS_BACKUP”.
7.1. att. Tabulas “GRAMATAS” trigeris “BACKUP_GRAMATU”
7.2. att. Tabulā “GRAMATAS” ar jauno ierakstu
7.3. att. Tabulā “GRAMATAS_BACKUP” ar, izmantojot trigeri, generēto ierakstu
25
SecinājumiPraktiskā darbā gaitā tika izveidotas vairākās Oracle datubāzes procedūras un
funkcijas izmantojot Java programmēšanās valodu. Sākumā tika uzprogrammētā viena Java programma, kura nekādā veidā nesadarbojas ar datubāzi vienkārši priekš šīs programmēšanās valodas pamatu demonstrēšanās. Pēc tam tika izmēģināti divi atšķirīgi Java klašu izveides veidi Oracle datubāze: izmantojot loadJava programmu un izmantojot createJava programmu. Tomēr galvenā praktiskā darbā daļā sastāvēja no JDBC interfeisa iespēju izmantošanās priekš darbā ar Oracle datubāzi.
Sākot pildīt šo praktisko darbu, lielāko problēmu izraisīja tas kā Oracle XE datubāze, kura tika izmantota iepriekšējo praktisko darbu izpildei nesaturēja JVM. Tāpēc šis darbs tika veikts uz RTU datubāzes servera. Pietam tādēļ arī Oracle XE komplektā negāja loadJava programmā, tādēļ priekš tās izmēģinājuma, nācās uzlikt uz cita datorā Oracle 11g datubāzi. Tas aizņēma daudz laikā, tomēr deva vel vairāk pieredzēs Oracle datubāzes konfigurācijā un uzlikšanā. Tādēļ loadJava programmā tika izmantotā tikai vienā uzdevumā un pārējos tika izmantotā manuprāt ērtākā createJava programma.
Kopumā darbs ar Java programmēšanas valodu bija īsta atpūta pēc iepriekšēja darbā izmantotās PL/SQL, kura manuprāt nav tā pati ērtākā valodā. Ar Java valodu esmu pazīstams jau sen, esmu lasījis vairākas grāmatās šajā valodā un izvelēs priekšmets šogad man ir Java programmēšanas valoda. Tāpēc darbs ar Java valodu man nesagādāja nekādas grūtībās.
Visas Java klases priekš šī darbā sākumā tika uzrakstītās uz Eclipse izstrādes vides. Un pieslēdzās pie datubāzes attālināti. Tikai pēc tam, kad tas tika pietiekami iztestētas, tas tika ar createJava programmu ievietotās Oracle datubāzē, izmainot JDBC pieslēguma veidu, lai tas pieslēgtos tekošai datubāzei. Un atlika tikai uzrakstīt vajadzīgās PL/SQL funkcijas priekš šo Java metožu izsaukšanās. Tādā veidā manuprāt ir ērtāk rakstīt Java programmas, jo Eclipse dot daudz lielākās kļūdu atrašanās un labošanās iespējās nekā SQL Developer.
Pēc visu vajadzīgo uzdevumu izpildēs vienalga izradījās kā praktiskā darba atskaitē ir īsākā nekā iepriekšējos darbos. Tāpēc tika uzrakstīta vel viena papildus nodaļā, kur tika demonstrēta Java valodas klases izmantošanā Oracle datubāzes trigeru veidošanai.
26
Literatūra1. Materiāli no http://www.datubaze.wordpress.com
2. Materiāli no www.ortus.rtu.lv
3. Materiāli no https://docs.oracle.com/cd/B28359_01/java.111/b31225/chthree.htm#CACJJHGI
4. Materiāli no https://docs.oracle.com/javase/tutorial/jdbc/
5. Materiāli no https://docs.oracle.com/cd/A57673_01/DOC/server/doc/SCN73/ch15.htm
27