saturs web viewuzdevumu izvēlējos izpildīt ar izstrādes vidi jdeveloper 12c (12.1.2.0.0)...

1

RĪGAS TEHNISKĀ UNIVERSITĀTEDatorzinātnes un informācijas tehnoloģijas fakultāte

Lietišķo datorsistēmu institūts

Mācību priekšmets“Lielu datu bāzu tehnoloģija ”

Java tehnoloģiju izmantošana datu bāzes sistēmā

Izstrādāja: Rihards Bušs3. kurss

2013. gads

2

Saturs

Saturs..............................................................................................................................2Uzdevuma nostādne.......................................................................................................31.Divu saistītu relāciju tabulu izveide............................................................................4

Tabulu aizpilde ar datiem...........................................................................................52.Vienkārša JAVA klases izveidošana...........................................................................6

JAVA klases ielāde datubāzē ar LOADJAVA...........................................................6Izpilde.........................................................................................................................7JAVA klases ielāde datubāzē ar CREATE JAVA.....................................................7Izpilde.........................................................................................................................8

3.JAVA klašu izveide datu apmaiņai ar datubāzi...........................................................9Datu apmaiņa ar tabulu „Alus_razotaji”....................................................................9Rezultātu iegūšana....................................................................................................12Datu apmaiņa ar tabulu „Alus”................................................................................13Rezultātu iegūšana....................................................................................................17Datu apmaiņa relāciju-objektu tabulai ar kolekciju.................................................19Rezultātu iegūšana....................................................................................................23

4.Darbs ar izstrādes vidi JDeveloper............................................................................25Datu bāzes struktūru realizēšana..............................................................................25Relāciju tabulas izveidošana un datu izguve ar JAVA.............................................27JAVA programmu izveide ar JDeveloper................................................................40

5.JAVA metodes izsaukšana objektu metodē un trigerī...............................................436.Java glabājamās procedūras izsaukšana no JAVA programmas ārpus DB...............46Secinājumi....................................................................................................................52

3

Uzdevuma nostādne

Servera programmēšanmantošana: valodas Java iespēju izmantošana

relāciju un relāciju-objektu datu bāzes struktūrām.

Darba uzdevums:Dotais praktiskais darbs ļauj studentiem novērtēt savu zināšanu līmeni un veikt darba izstrādi, realizējot daļu vai visus norādītos uzdevumus.1. Izveidot divas saistītas relāciju DB tabulas (ar datiem).2. Izveidot vienkāršu Java klasi, bez datu apmaiņas ar datu bāzi, veikt tās ielādi datu bāzē (LOADJAVA …, create Java …), veikt tās izpildi.3. Izveidot Java klasi (-es), kura veic datu apmaiņu (SELECT, INSERT) ar datu bāzi, veikt tās ielādi un iegūt rezultātus.4. Valodas Java programmu un datu bāzes struktūru realizēšana ar Integrated Development Environment (IDE) izstrādes vides (JDeveloper, NetBeans, Eclipse, …) palīdzību.5. Java metodes izsaukšana PL/SQL objektu metodē un trigerī.6. Java glabājamās procedūras izsaukšana no Java programmas ārpus datu bāzes (lietojuma programmas).

4

1. Divu saistītu relāciju tabulu izveide

Uzdevuma izpildi sāksim ar divu saistītu relāciju tabulu izveidi. Vispirms izveidosim relāciju tabulu „Alus_razotaji”. Tabula saturēs šādas vērtības: Primāro atslēgu - ražotāja identifikatoru (ID), ražotāja nosaukumu (Nosaukums), valsti (Valsts) un pilsētu (Pilseta), kurā notiek alus ražošana. Šī tabula būs sasaistīta ar otro tabulu, un šo tabulu vienojošā vērtība būs ražotāja identifikators (ID).

CREATE TABLE Alus_razotaji (ID number,Nosaukums varchar2(30),Valsts varchar2(30),Pilseta varchar2(30),CONSTRAINT razotajs_pk PRIMARY KEY (ID));

Tagad izveidosim otru tabulu „Alus”. Šī tabula šādas vērtības – alus identifikatoru (Alus_ID), alus nosaukumu (Alus_ID), alkohola saturs ‰ (Stiprums), tilpums (Tilpums), pudeles cena (Cena) un ražotāja identifikators (Raz_ID). Tabulā tiek noteikta ārējā atslēga Raz_ID = ID, ar kuru tiek izveidota sasaiste ar pirmo tabulu „Alus_razotaji”.

CREATE TABLE Alus ( Alus_ID number PRIMARY KEY,Alus_nos varchar2(30),Stiprums number,Tilpums number,Cena number,Raz_ID number,CONSTRAINT fk_razotajs FOREIGN KEY (Raz_ID) REFERENCES Alus_razotaji(ID));

5

Tabulu aizpilde ar datiem

Kad tabulas izveidotas, aizpildām tās ar datiem.

Vispirms aizpildīsim tabulu „Alus_razotaji”. Tabulās ievietosim datus par četriem alus ražotājiem no dažādām pasaules valstīm.

BEGININSERT INTO Alus_razotaji VALUES (1, 'Aldaris', 'Latvija', 'Riga');INSERT INTO Alus_razotaji VALUES (2, 'Rothaus AG', 'Vacija', 'Grafenhausen');INSERT INTO Alus_razotaji VALUES (3, 'Modelo', 'Meksika', 'Mexico City');INSERT INTO Alus_razotaji VALUES (4, 'Svyturys', 'Lietuva', 'Klaipeda');END;

Visbeidzot aizpildīsim otru tabulu „Alus”.

BEGININSERT INTO Alus VALUES (1, 'Aldaris Luxus', 5.2, 500, 0.79, 1);INSERT INTO Alus VALUES (2, 'Aldaris Zelta', 5.2, 500, 0.55, 1);INSERT INTO Alus VALUES (3, 'Tannerzapfle', 5.1, 330, 1.00, 2);INSERT INTO Alus VALUES (4, 'Hefeweize Zapfle', 5.4, 330, 1.10, 2);INSERT INTO Alus VALUES (5, 'Negra Modelo', 5.4, 330, 1.10, 3);INSERT INTO Alus VALUES (6, 'Corona Extra', 4.6, 330, 1.13, 3);INSERT INTO Alus VALUES (7, 'Modelo Especial', 4.5, 355, 1.15, 3);INSERT INTO Alus VALUES (8, 'Modelo Especial', 4.5, 355, 1.15, 3);INSERT INTO Alus VALUES (9, 'Svyturys Ekstra', 5.2, 500, 1.00, 4);INSERT INTO Alus VALUES (10, 'Svyturys Gintarinis', 4.7, 500, 1.20, 4);END;

Uzdevumu gaitā izveidosim vēl vairākas tabulas (to skaitā arī relāciju objektu tabulu), taču to izveidi un darbības paskaidrosim pie attiecīgā uzdevuma, kurā to izmantosim.

6

2. Vienkārša JAVA klases izveidošana

JAVA klases ielāde datubāzē ar LOADJAVA

Pastāv divi varianti kā ielādēt JAVA klasi datubāzē. Pirmais no tiem ir izmantot programmu LOADJAVA, bet otrais - CREATE JAVA komandu. Izmēģināsim abus variantus.

Izveidosim vienkāršu JAVA klasi Starts, kas atgriezīs sekojošu tekstu: „30% no savas dzīves cilvēks pavada miegā, bet 70% nomodā, cerot izgulēties :)”.

To izdarīsim izveidojot teksta failu „Starts”, kas saturēs JAVA klases definējumu (programmas tekstu), un kura paplašinājumu *.txt nomainīsim uz *.java. Failu ar JAVA definējumu savukārt ielādēsim datubāzē, izmantojot programmu LOADJAVA, kas veiks kompilāciju izveidojot JAVA CLASS objektu.

Faila „Starts.java” saturs:

CREATE OR REPLACE JAVA SOURCE NAMED "Starts" ASpublic class Starts{public static String Aiziet() {return "30% no savas dzives cilveks pavada miega, bet 70% nomoda, cerot

izguleties! :)"; }}

LOADJAVA programmu palaidīsim no komandrindas ar šādiem parametriem „-user”, norādot lietotājvārdu „SYSTEM” un paroli „testss”, parametru „-v”, kas atbild par LOADJAVA rezultātu izvadi, „-r” automātiskai nokompilēšanai, „-t” – norāda, ka savienojums ar datubāzi notiek izmantojot THIN dzini, kā pēdējais parametrs tiek norādīts ceļš (path) uz *.java failu.

Kā varam novērot, komanda ir izpildījusies veiksmīgi (Sources Loaded: 1). Savukārt kļūdu nav (Errors: 0).

Nākamais solis ir izveidot PL/SQL funkciju, kas izsauks JAVA metodi.

CREATE OR REPLACE FUNCTION Aiziet RETURN varchar2 ASLANGUAGE JAVA NAME 'Starts.Aiziet() return

java.lang.String';

7

Datu bāzes un JAVA buferu inicializācijai nepieciešams izsaukt sekojošas komandas.

SET SERVEROUTPUT ON;CALL DBMS_JAVA.SET_OUTPUT(2000);

Izpilde

Visbeidzot varam izsaukt nupat izveidoto funkciju ar sekojošu komandu:

SELECT Aiziet FROM DUAL;

JAVA klases ielāde datubāzē ar CREATE JAVA

Pastāv arī otrs variants, ielādēt JAVA klasi datubāzē izmantojot komandu CREATE JAVA, ko ievadīsim SQL*Plus. Izmēģināsim to izdarīt arī šādi. Šoreiz centīsimies izgūt šādu tekstu „Ja piekto dienu pēc kārtas negribās strādāt, tātad ir piektdiena!”

CREATE OR REPLACE JAVA SOURCE NAMED "Starts" ASpublic class Starts{public static String Aiziet() {return "Ja piekto dienu pec kartas negribas stradat, tatad ir piektdiena!"; }}

Nākamais solis tāpat kā LOADJAVA programmas gadījumā ir izveidot PL/SQL funkciju, kas izsauks JAVA metodi.

8

CREATE OR REPLACE FUNCTION Aiziet RETURN varchar2 ASLANGUAGE JAVA NAME 'Starts.Aiziet() return

java.lang.String';

Izpilde

Tagad vien atliek iegūt rezultātu.

SELECT Aiziet FROM DUAL;

Vai arī izsaucošās PL/SQL funkcijas aktivizēšana ar CALL izsaukumu. Šoreiz izsauksim funkciju un saglabāsim tās rezultātu mainīgajā „Aforisms”, taču pēctam izvadīsim šo mainīgo.

Variable Aforisms varchar2(100);CALL Aiziet() into :Aforisms;PRINT Aforisms;

9

3. JAVA klašu izveide datu apmaiņai ar datubāzi

Pirmajā uzdevumā izveidojām divas saistītas relāciju tabulas – „Alus_razotaji” un „Alus”, vispirms izveidosim datu apmaiņu ar šīm tabulām. Taču, tā kā sākotnējās laboratorijas darba prasības mazliet atšķīrās no prasībām, kuras tika ievietotas 2013. gada 7. decembrī, šajā uzdevumā izmantosim arī relāciju-objektu tabulu, kuras izveidi aprakstīsim mazliet vēlāk šī uzdevuma izpildes gaitā.

Sākotnēji izveidosim datu apmaiņu ar pirmajā uzdevumā izveidoto tabulu „Alus_razotaji”.

Datu apmaiņa ar tabulu „Alus_razotaji”

Kā jau iepriekš, vispirms izveidosim JAVA klases definējumu. Šo definējumu saglabāsim atsevišķā *.java failā „Brewery.java”.

Paredzēsim trīs metodes. Pirmā no tām – „apskatit()” ļaus apskatīt ievadītos datus tabulā „Alus_razotaji”. Otrā metode – „pievienot”, ļaus pievienot jaunu ierakstu tabulā „Alus_razotaji”, norādot ievadāmās vērtības. Savukārt trešā metode – printResults nepieciešama kā palīgmetode datu izvadei.

Sīkāki skaidrojumi komentāru veida norādīti pašā JAVA klases failā zemāk. Uzmanībā jāpievērš tam, ka jānotver visi izņēmumi (exceptions). Metodē pievienot() tie lietots princips, ka sākumā tiek sagatavots pats SQL vaicājums un tikai pēc tam tiek padoti parametri datu ievadei atbilstošajās vietās.

Faila „Brewery.java” saturs:

import java.sql.*;import java.io.*;

public class Brewery {

public static void apskatit () throws SQLException { String sql = "SELECT * FROM Alus_razotaji";//vaicajums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement pstmt = conn.prepareStatement(sql); ResultSet rset = pstmt.executeQuery();// SQL vaicājuma izpildīšana printResults(rset); //Izsaucam metodi, kas izvadīs rezultātu - printResults() rset.close(); pstmt.close(); //Savienojuma aizvēršana } catch (SQLException e) {System.err.println(e.getMessage()); //Kļūdu izvadīsana

10

} }

public static void pievienot(int ID, String Nosaukums, String Valsts, String Pilseta) throws SQLException { String sql = "INSERT INTO Alus_razotaji VALUES (?, ?, ?, ?)"; //Pats SQL vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement st = conn.prepareStatement(sql); st.setInt(1, ID); st.setString(2, Nosaukums); st.setString(3, Valsts); st.setString(4, Pilseta); st.executeUpdate(); // SQL vaicājuma izpildīšana st.close(); // Savienojuma aizvēršana } catch (SQLException e) { //Kļūdu izvadīsana

System.err.println(e.getMessage());}

}

static void printResults (ResultSet rset) throws SQLException { String buffer = ""; //Buferis izvadei try { ResultSetMetaData meta = rset.getMetaData(); //Meta-datu iegūšana int cols = meta.getColumnCount(), rows = 0; // Kolonu skaita noteikšana, rindu skaita inicializēšana for (int i = 1; i <= cols; i++) //sakam ciklu {int size = meta.getPrecision(i); String label = meta.getColumnLabel(i);// Kolonnas virsraksts if (label.length() > size) size = label.length(); while (label.length() < size) label += " "; buffer = buffer + label + " "; } // Virsrakstu izvade buffer = buffer + "\n"; while (rset.next()) { rows++; for (int i = 1; i <= cols; i++) { int size = meta.getPrecision(i); String label = meta.getColumnLabel(i); String value = rset.getString(i); if (label.length() > size) size = label.length(); while (value.length() < size) value += " "; buffer = buffer + value + " "; } buffer = buffer + "\n"; } if (rows == 0) buffer = "No data found!\n"; System.out.println(buffer); } // Rezultātu izvadīsana catch (SQLException e) { System.err.println(e.getMessage()); //Kļūdu izvadīsana

11

} }

}

Java klases failu „Brewery.java” pēc otrajā uzdevumā aprakstītā paņēmiena un ar tiem pašiem parametriem ielādēsim datubāzē izmantojot programmu LOADJAVA

loadjava.bat –user SYSTEM/testss –v –r –t C:/java/Brewery.java

Kā varam novērot, kļūdu nav (Errors: 0), savukārt Sources loaded: 1, kas nozīmē, ka viss izpildījies veiksmīgi un JAVA klase „Brewery” ielādēta datubāzē.

Kad JAVA klase ielādēta datubāzē, izveidosim paketi „Brewery” ar procedūrām – pievienot un apskatit. Izsaucot metodi apskatit() nav janorāda nekādi parametri, savukārt metodei pievienot() iekavās jānorāda ievadāmās vērtības – ražotāja identifikācijas numuru, ražotāja nosaukumu, valsti un pilsētu, kurā norisinās ražošana.

CREATE OR REPLACE PACKAGE Brewery ASPROCEDURE pievienot(ID number, Nosaukums varchar2, Valsts varchar2, Pilseta varchar2);PROCEDURE apskatit;END Brewery;

Tagad izveidosim paketes „Brewery” ķermeni (body).

CREATE OR REPLACE PACKAGE BODY Brewery ASPROCEDURE pievienot(ID number, Nosaukums varchar2, Valsts varchar2, Pilseta varchar2) AS LANGUAGE JAVANAME 'Brewery.pievienot(int, java.lang.String, java.lang.String, java.lang.String)';

PROCEDURE apskatit AS LANGUAGE JAVANAME 'Brewery.apskatit()';END Brewery;

12

Rezultātu iegūšana

Datu bāzes un JAVA buferu inicializācijai pirms metodēm nepieciešams izsaukt sekojošas komandas, tas nodrošina izvades ieslēgšanu un izvades garumu.


Pirmo izsauksim metodi apskatit(). Tā nodrošinās datu izvadi no tabulas „Alus_razotaji”

CALL Brewery.apskatit();

Kā varam novērot, no tabulas „Alus_razotaji” veiksmīgi ir izvadījušies visi pirmajā uzdevumā pievienotie dati.

Tagad izsauksim metodi pievienot(), iekavās norādot parametrus ar ievadāmajām vērtībām. Pievienosim alus ražotāju Diageo, kur ražotne atrodas Anglijā, Londonā un piešķirsim identifikācijas numuru 5.

CALL Brewery.pievienot(5, 'Diageo', 'Anglija', 'Londona');

Lai pārliecinātos, ka pievienošana ir izdevusies veiksmīgi, vēlreiz izsauksim metodi apskatit();

CALL Brewery.apskatit();

13

Kā varam novērot, tabula ir papildināta ar nupat pievienoto ierakstu.

Datu apmaiņa ar tabulu „Alus”

Arī šoreiz vispirms izveidosim JAVA klases definējumu. Šo definējumu saglabāsim atsevišķā *.java failā „Beer.java”.

Paredzēsim piecas metodes. Pirmā no tām – „apskatit()” ļaus apskatīt ievadītos datus tabulā „Alus”. Otrā metode ir līdzīga pirmajai metodei (apskatit_raz()) tikai ļauj apskatīt konkrēta alus ražotāja alus klāstu, kā parametru norādot ražotāja identifikatoru. Trešā metode – „pievienot()”, ļaus pievienot jaunu ierakstu tabulā „Alus_razotaji”, norādot ievadāmās vērtības. Ceturtā metode ļauj dzest() ierakstu no tabulas „Alus”, parametrā norādot Alus nosaukumu, kuru vēlamies dzēst. Savukārt pēdējā,- piektā metode – printResults nepieciešama kā palīgmetode datu izvadei.

Sīkāki skaidrojumi komentāru veida norādīti pašā JAVA klases failā zemāk. Uzmanībā jāpievērš tam, ka jānotver visi izņēmumi (exceptions).


public class Beer {

public static void apskatit () throws SQLException { String sql = "SELECT * FROM Alus";//vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement pstmt = conn.prepareStatement(sql); ResultSet rset = pstmt.executeQuery();// SQL vaicājuma izpildīšana printResults(rset); //Izsaucam metodi, kas izvadīs rezultātu - printResults() rset.close(); pstmt.close(); //Savienojuma aizvēršana } catch (SQLException e) {System.err.println(e.getMessage()); //Kļūdu izvadīšana } }

public static void apskatit_raz (int Raz_ID)

14

throws SQLException { String sql = "SELECT * FROM Alus WHERE Raz_ID = ?";//vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement apstmt = conn.prepareStatement(sql); apstmt.setInt(1, Raz_ID); ResultSet rset = apstmt.executeQuery();// SQL vaicājuma izpildīšana printResults(rset); //Izsaucam metodi, kas izvadīs rezultātu - printResults() rset.close(); apstmt.close(); //Savienojuma aizvēršana } catch (SQLException e) {System.err.println(e.getMessage()); //Kļūdu izvadīšana } }

public static void pievienot(int Alus_ID, String Alus_nos, float Stiprums, float Tilpums, float Cena, int Raz_ID) throws SQLException { String sql = "INSERT INTO Alus VALUES (?, ?, ?, ?, ?, ?)"; //Pats SQL vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement st = conn.prepareStatement(sql); st.setInt(1, Alus_ID); st.setString(2, Alus_nos); st.setFloat(3, Stiprums); st.setFloat(4, Tilpums); st.setFloat(5, Cena); st.setInt(6, Raz_ID); st.executeUpdate(); // SQL vaicājuma izpildīšana st.close(); // Savienojuma aizvēršana } catch (SQLException e) { //Kļūdu izvadīšana


}

public static void dzest(String Alus_nos) throws SQLException { String sql = "DELETE FROM Alus WHERE Alus_nos = ?";//vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:");//savienojums ar datubazi PreparedStatement dpstmt = conn.prepareStatement(sql); dpstmt.setString(1, Alus_nos); dpstmt.executeUpdate(); dpstmt.close(); }

15

catch (SQLException e) {System.err.println(e.getMessage()); } }

static void printResults (ResultSet rset) throws SQLException { String buffer = ""; //Buferis izvadei try { ResultSetMetaData meta = rset.getMetaData(); //Meta-datu iegūšana int cols = meta.getColumnCount(), rows = 0; // Kolonu skaita noteikšana, rindu skaita inicializēšana for (int i = 1; i <= cols; i++) //sakam ciklu {int size = meta.getPrecision(i); String label = meta.getColumnLabel(i);// Kolonnas virsraksts if (label.length() > size) size = label.length(); while (label.length() < size) label += " "; buffer = buffer + label + " "; } // Virsrakstu izvade buffer = buffer + "\n"; while (rset.next()) { rows++; for (int i = 1; i <= cols; i++) { int size = meta.getPrecision(i); String label = meta.getColumnLabel(i); String value = rset.getString(i); if (label.length() > size) size = label.length(); while (value.length() < size) value += " "; buffer = buffer + value + " "; } buffer = buffer + "\n"; } if (rows == 0) buffer = "No data found!\n"; System.out.println(buffer); } // Rezultātu izvadīšana catch (SQLException e) { System.err.println(e.getMessage()); //Kļūdu izvadīšana } }

}

Java klases failu „Beer.java” pēc otrajā uzdevumā aprakstītā paņēmiena un ar tiem pašiem parametriem ielādēsim datubāzē izmantojot programmu LOADJAVA

loadjava.bat –user SYSTEM/testss –v –r –t C:/java/Beer.java

16

Kā varam novērot, kļūdu nav (Errors: 0), savukārt Sources loaded: 1, kas nozīmē, ka viss izpildījies veiksmīgi un JAVA klase ielādēta datubāzē.

Kad JAVA klase ielādēta datubāzē, izveidosim paketi „Beer” ar procedūrām – pievienot(), apskatit(), apskatit_raz(), dzest(). Izsaucot metodi apskatit() nav janorāda nekādi parametri, savukārt metodei pievienot() iekavās jānorāda ievadāmās vērtības – ražotāja identifikācijas numuru, ražotāja nosaukumu, valsti un pilsētu, kurā norisinās ražošana. Līdzīgi jārīkojās arī izsaucot apskatit_raz() metodi, jo parametrā jānorāda ražotāja identifikators, kura alus klāstu vēlamies apskatīt, savukārt izsaucot dzest() metode jānorāda alus nosaukums, kuru vēlamies dzēst.

CREATE OR REPLACE PACKAGE Beer ASPROCEDURE pievienot(Alus_ID number, Alus_nos varchar2, Stiprums number, Tilpums number, Cena number, Raz_ID number);PROCEDURE apskatit;PROCEDURE apskatit_raz(Raz_ID number);PROCEDURE dzest(Alus_nos varchar2);END Beer;

Tagad izveidosim paketes „Beer” ķermeni (body).

CREATE OR REPLACE PACKAGE BODY Beer ASPROCEDURE pievienot(Alus_ID number, Alus_nos varchar2, Stiprums number, Tilpums number, Cena number, Raz_ID number) AS LANGUAGE JAVANAME 'Beer.pievienot(int, java.lang.String, float, float, float, int)';

PROCEDURE apskatit AS LANGUAGE JAVANAME 'Beer.apskatit()';

PROCEDURE apskatit_raz(Raz_ID number) AS LANGUAGE JAVANAME 'Beer.apskatit_raz(int)';

PROCEDURE dzest(Alus_nos varchar2) AS LANGUAGE JAVANAME 'Beer.dzest(java.lang.String)';END Beer;

17




Pirmo izsauksim metodi apskatit(). Tā nodrošinās datu izvadi no tabulas „Beer”.

CALL Beer.apskatit();

Kā varam novērot, izvadītie dati sakrīt ar ievadītajiem datiem pirmajā uzdevumā.

Kā otro metodi izsauksim metodi pievienot(). Pievienosim divus alus, ko ražo nupat iepriekšējā tabulā ar pievienot metodi izveidotais uzņēmums „Diageo”. Izsaucot pievienot() metodi, tai parametros norādīsim Alus nosaukumus – „Guiness” un „Tusker”, to alkohola saturu – 4.2‰, Tilpumu 440 un attiecīgi 500ml, cenas 1.09Ls un 1.20Ls un ražotāja identifikatoru 5 – ražotājam „Diageo”.

CALL Beer.pievienot(11, 'Guinness', 4.2, 440, 1.09, 5);CALL Beer.pievienot(12, 'Tusker', 4.2, 500, 1.20, 5);

18

Kad jaunie dati pievienoti, atkārtoti izsauksim apskatit() metodi, lai pārliecinātos, ka viss ir pievienojies veiksmīgi.


Kā varam novērot, ir izvadījušies arī nupat pievienotie dati, līdz ar to varam apgalvot, ka viss ir nostrādājis pareizi.

Kā Trešo metodi izsauksim metodi apskatit_raz(). Tā nodrošinās datu izvadi no tabulas „Beer”, taču šoreiz parametrā norādīsim Ražotāja identifikatoru, lai izvadītu tikai konkrētā ražotāja alus klāstu. Apskatīsimies alus klāstu ražotājam „Modelo” ar identifikatoru „3”.

CALL Beer.apskatit_raz(3);

Kā varam novērot, ir izvadījušās 4 vērtības, kas atbilst ražotājam „Modelo” un, ja to salīdzinam pret metodes apskatit() izvadi augšējā attēlā, varam redzēt, ka tik tiešām no visām vērtībām ir 4, kuram ražotāja identifikators (Raz_ID) ir 3.

Pirms izsauksm nākamo – dzēšanas metodi, vēlreiz pārliecināsimies kāda izskatās tabula pirms dzēšanas.


19

Visbeidzot izsauksim metodi dzest(), lai izdzēstu vērtību no tabulas „Beer”. Šoreiz dzēsīsim ierakstu alum ar nosaukumu „Guinness”,

CALL Beer.dzest('Guinness');

Lai pārliecinātos, ka dzest() metode nostrādājusi pareizi, vēlreiz izsauksim metodi apskatit().


Tik tiešām ir dzēsies ieraksts, kura alus nosaukums bija „Guiness” (tā identifikators bija 11, kas augšējā attēlā trūkst). To uzskatāmi varam redzēt arī salīdzinot attēlu, kas ievietots pirms metodes dzest() izsaukšanas ar attēlu pēc izsaukšanas.

Datu apmaiņa relāciju-objektu tabulai ar kolekciju

Tā kā sākotnējās laboratorijas darba prasības mazliet atšķīrās no prasībām, kuras tika ievietotas 2013. gada 7. decembrī, šajā uzdevumā izmantosim arī relāciju-objektu tabulu. Izveidosim datu apmaiņu arī ar šo objektu-tabulu, kurā iekļauta tabula ar objektu kolekciju. Darbā ar relāciju objektu tabulu JAVA klases definējums metodēs ir mazliet atšķirīgs, arī dzēšana no tabulas ar objektu kolekciju bija ievērojami sarežģītāka.

Lai izveidotu objektu tabulu, vispirms izveidosim tipu Motorlaiva, kas saturēs šādas vērtības: motorlaivas marku, tās modeli, identifikatoru, ražošanas gadu un cenu.

20

CREATE OR REPLACE TYPE Motorlaiva AS OBJECT(Marka varchar2(30),Modelis varchar2(30),Identifikators varchar2(4),Gads number(4),Cena number(7,2));

Tagad veiksim jauna tipa definēšanu tipam Tips_Motorlaivas, kas saturēs objektus Motorlaiva

CREATE OR REPLACE TYPE TIPS_Motorlaivas AS TABLE OF Motorlaiva;

Pēc tam izveidosim tabulu „Piestatne”, kas saturēs Piestatnes nosaukumu, pilsētu, kurā atrodas piestātne un nupat izveidoto tipu – Tips_Motorlaivas kā kolekciju.

Arī šoreiz izveidosim JAVA klases definējumu. Šo definējumu saglabāsim atsevišķā *.java failā „Laivas.java”.

Šoreiz paredzēsim 2 metodes un tās būs paredzētas datu apmaiņai ar objektu kolekciju. Pirmā no tām – „pievienot()”, ļaus pievienot jaunu motorlaivu tabulā „Piestatne”, norādot ievadāmās vērtības. Otrā metode – dzest() ļaus dzēst konkrētu motorlaivu no tabulas „Piestatne”, norādot parametru Identifikators no objektu kolekcijas.

Sīkāki skaidrojumi komentāru veida norādīti pašā JAVA klases failā zemāk. Uzmanībā jāpievērš tam, ka jānotver visi izņēmumi (exceptions). Šajā gadījumā ievade tabulā bija mazliet sarežģītāka, kā pie dzēšanas metodes izveides nācās vairāk piedomāt.

21


public class Laivas {

public static void pievienot(String Nosaukums, String Pilseta, String Marka, String Modelis, String Identifikators, int Gads, int Cena)

throws SQLException {String sql = "INSERT INTO Piestatne VALUES

(?,?,TIPS_Motorlaivas(Motorlaiva(?,?,?,?,?)))"; // SQL vaicājumstry { Connection conn = DriverManager.getConnection("jdbc:default:connection:");

//Savienojums ar datubāziPreparedStatement st = conn.prepareStatement(sql);st.setString(1, Nosaukums);st.setString(2, Pilseta);st.setString(3, Marka);st.setString(4, Modelis);st.setString(5, Identifikators);st.setInt(6, Gads);st.setInt(7, Cena);st.executeUpdate(); //st.close();}catch (SQLException e) {


}

public static void dzest(String Identifikators) throws SQLException { String sql = "DELETE FROM Piestatne WHERE ROWID =ANY (SELECT a.ROWID FROM Piestatne a, Table(ML) b WHERE b.Identifikators = ?)";//vaicajums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:");//savienojums ar datubazi PreparedStatement pstmt = conn.prepareStatement(sql); pstmt.setString(1, Identifikators); pstmt.executeUpdate(); sql = "DELETE FROM Piestatne WHERE ROWID =ANY (SELECT a.ROWID FROM Piestatne a, Table(ML) b WHERE b.Identifikators = ?)"; pstmt.setString(1, Identifikators); pstmt.executeUpdate(); pstmt.close(); } catch (SQLException e) {System.err.println(e.getMessage()); } }}

22

Java klases failu „Laivas.java” pēc otrajā uzdevumā aprakstītā paņēmiena un ar tiem pašiem parametriem ielādēsim datubāzē izmantojot programmu LOADJAVA

loadjava.bat –user SYSTEM/testss –v –r –t C:/java/Laivas.java

Kā varam novērot, kļūdu nav (Errors: 0), savukārt Sources loaded: 1, kas nozīmē, ka viss izpildījies veiksmīgi un JAVA klase ielādēta datubāzē.

Kad JAVA klase ielādēta datubāzē, izveidosim paketi „Laivas” ar procedūrām – pievienot(), dzest(). Metodei pievienot() iekavās jānorāda ievadāmās vērtības – Piestātnes nosaukums, Pilsēta, savukārt objektu kolekcijā ievietojamajām vērtībām– laivas marka, modelis, identifikators, gads un cena. Izsaucot dzest() metode jānorāda Identifikators motorlaivai, kuru vēlamies dzēst.

CREATE OR REPLACE PACKAGE Laivas ASPROCEDURE pievienot(Nosaukums varchar2, Pilseta varchar2, Marka varchar2, Modelis varchar2, Identifikators varchar2, Gads number, Cena number);PROCEDURE dzest(Identifikators varchar2);END Laivas;

Tagad izveidosim paketes „Laivas” ķermeni (body).

CREATE OR REPLACE PACKAGE BODY Laivas ASPROCEDURE pievienot(Nosaukums varchar2, Pilseta varchar2, Marka varchar2, Modelis varchar2, Identifikators varchar2, Gads number, Cena number) AS LANGUAGE JAVANAME 'Laivas.pievienot(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, int)';

PROCEDURE dzest(Identifikators varchar2) AS LANGUAGE JAVANAME 'Laivas.dzest(java.lang.String)';END Laivas;

23




Tā kā nupat izveidotajā tabulā nav vērtību, pirmo izsauksim metodi pievienot (). Parametros norādīsim vērtības tabulas aizpildei.

CALL Laivas.pievienot('Kempings Jurmala', 'Jurmala', 'Bush', 'Stormbringer', 'B201', 2011, 10191);CALL Laivas.pievienot('Kempings Jurmala', 'Jurmala', 'Storebro', 'Solo Aqua Cabin', 'S196' , 1965, 9900);CALL Laivas.pievienot('Kempings Jurmala', 'Jurmala', 'Fish', '360', 'F201', 2012, 18835);CALL Laivas.pievienot('Persejas', 'Koknese', 'Latrex', '355', 'L211', 2013, 700);

Tā kā šajā gadījumā mums nav izveidota metode, kas izgūs datus no objektu tabulas, lai pārliecinātos, ka dati ir ievadījušies pareizi, izsauksim parastu SQL vaicājumu, lai to noskaidrotu.

SELECT * FROM Piestatne;

24

Relāciju-objektu tabulas gadījumā tabulai ar kolekciju datu ievades apraksts JAVA klases definējumā bija mazliet sarežģītāks. Neskatoties uz to, varam novērot, dati ir pievienojušies veiksmīgi.

Tagad izsauksim otru izveidoto metodi – dzest(), kurai parametrā norādīsim laivas identifikatoru no kolekcijas ierakstam, kuru vēlamies dzēst. Šajā gadījumā dzēsīsim ierakstu laivai ar identifikatoru „L211”;

CALL Laivas.dzest(‘L211’);

Lai pārliecinātos, ka metode ir izpildījusies pareizi, atkal izsauksim parastu SQL vaicājumu, lai pārliecinātos, ka ieraksts tik tiešām ir dzēsies.

SELECT * FROM Piestatne;

Kā varam novērot, tik tiešām ir dzēsies ieraksts laivai ar identifikatoru „L211”, ko padevām parametrā metodei dzēst(). To uzskatāmi var redzēt salīdzinot abus attēlus augšā, - pirms un pēc komandas izpildes. Jāpiebilst, ka arī dzēšanas metodes apraksts JAVA klases definējumā bija sarežģītāks nekā standarta relāciju objektu tabulas gadījumā.

25

4. Darbs ar izstrādes vidi JDeveloper

4. uzdevuma prasības bija izmantot kādu no izstrādes vidēm (IDE) Java programmas un datubāzes struktūru realizēšanai. Uzdevumu izvēlējos izpildīt ar izstrādes vidi JDeveloper 12c (12.1.2.0.0) versiju, ko ieguvu no ORACLE mājaslapas.

Zemāk redzams ekrāna attēlojums no JDeveloper 12c instalācijas.

Vispirms izmantosim JDeveloper vidi datubāzes struktūras realizēšanai. Izveidosim divas tabulas līdzīgi kā iepriekšējos uzdevumos, tikai šoreiz izmantosim tikai JDeveloper vidi. Viena no tabulām būs parasta relāciju tabula, bet otra relāciju-objektu tabula. Izveidosim JAVA klases datu apmaiņai ar datubāzi. Tā kā vispirms veidosim datubāzes struktūru, uzsākot darbu ar Oracle JDeveloper, izvēlēsimies lomu (role) – Database Developer.

Datu bāzes struktūru realizēšana

Vispirms jāizveido savienojums ar ORACLE datubāzi.

26

Kad savienojums izveidots, izvēlēsimies strādāt ar SQL_Worksheet (Tools > Database > SQL_Worksheet), kur veiksim visas tālākās darbības.

27

Relāciju tabulas izveidošana un datu izguve ar JAVA

Sāksim ar relāciju tabulas „Riepas” izveidošanu. Izveidojas SQL vaicājumu un lai to izpildītu nospiežam „Run” jeb izpildei speciāli paredzēto ikonu.

create table Riepas(R_ID number PRIMARY KEY,Marka varchar2(30),Modelis varchar2(30),Platums varchar2(30),Slodze number(2),Slodzes_ind varchar2(1),Sezona varchar2(10),Cena number);

Kad iegūts paziņojums par tabulas izveidošanu, varam par to pārliecināties apskatoties datu pārskatā, vai jaunā tabula ir pievienojusies pie kopējā tabulu saraksta labajā malā (Tables), savukārt uzspiežot uz konkrētās tabulas varam iegūt sīkāku aprakstu par konkrētu tabulu.

28

Nākamais, ko izdarīsim būs JAVA klases definējuma apraksts. Arī šoreiz realizēsim trīs metodes – apskatit(), pievienot() un papildmetodi printResults() rezultātu izvadei.

CREATE OR REPLACE JAVA source named "Riepa" asimport java.sql.*;import java.io.*;import oracle.jdbc.*;

29

public class Riepa {

public static void apskatit () throws SQLException { String sql = "SELECT * FROM Riepas";//vaicajums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement pstmt = conn.prepareStatement(sql); ResultSet rset = pstmt.executeQuery();// SQL vaicājuma izpildīšana printResults(rset); //Izsaucam metodi, kas izvadīs rezultātu - printResults() rset.close(); pstmt.close(); //Savienojuma aizvēršana } catch (SQLException e) {System.err.println(e.getMessage()); //Kļūdu izvadīsana } }

public static void pievienot(int R_ID, String Marka, String Modelis, String Platums, int Slodze, String Slodzes_ind, String Sezona, int Cena) throws SQLException { String sql = "INSERT INTO Riepas VALUES (?, ?, ?, ?, ?, ?, ?, ?)"; //Pats SQL vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement st = conn.prepareStatement(sql); st.setInt(1, R_ID); st.setString(2, Marka); st.setString(3, Modelis); st.setString(4, Platums); st.setInt(5, Slodze); st.setString(6, Slodzes_ind); st.setString(7, Sezona); st.setInt(8, Cena); st.executeUpdate(); // SQL vaicājuma izpildīšana st.close(); // Savienojuma aizvēršana } catch (SQLException e) { //Kļūdu izvadīsana


}

static void printResults (ResultSet rset) throws SQLException { String buffer = ""; //Buferis izvadei try { ResultSetMetaData meta = rset.getMetaData(); //Meta-datu iegūšana

30

int cols = meta.getColumnCount(), rows = 0; // Kolonu skaita noteikšana, rindu skaita inicializēšana for (int i = 1; i <= cols; i++) //sakam ciklu {int size = meta.getPrecision(i); String label = meta.getColumnLabel(i);// Kolonnas virsraksts if (label.length() > size) size = label.length(); while (label.length() < size) label += " "; buffer = buffer + label + " "; } // Virsrakstu izvade buffer = buffer + "\n"; while (rset.next()) { rows++; for (int i = 1; i <= cols; i++) { int size = meta.getPrecision(i); String label = meta.getColumnLabel(i); String value = rset.getString(i); if (label.length() > size) size = label.length(); while (value.length() < size) value += " "; buffer = buffer + value + " "; } buffer = buffer + "\n"; } if (rows == 0) buffer = "No data found!\n"; System.out.println(buffer); } // Rezultātu izvadīsana catch (SQLException e) { System.err.println(e.getMessage()); //Kļūdu izvadīsana } }

}

Tāpat kā iepriekšējo SQL vaicājumu, arī JAVA klases aprakstu rakstam tajā pašā SQL_worksheet un izpildam palaižot komandu „RUN”. Kļūdu nav, - viss ir lieliski.

Lai pārliecinātos, ka viss ir izveidojies pareizi, apskatīsimies vai jaunā klase ir redzama zem „Java Classes”. Protams, ka tā ir redzama arī kopējā sarakstā.

31

Visbeidzot varam ķerties pie paketes „Riepa apraksta”. Izsaucot metodi pievienot būs nepieciešams kā parametrus norādīt Riepas identifikatoru (R_ID), marku, modeli, riepas platumu, slodzi, slodzes indeksu, sezonu, kurā riepas paredzētas, to cenu. Uzreiz definēsim arī paketes „Riepa” ķermeni jeb body.

CREATE OR REPLACE PACKAGE Riepa ASPROCEDURE pievienot(R_ID number, Marka varchar2, Modelis varchar2, Platums varchar2, Slodze number, Slodzes_ind varchar2, Sezona varchar2, Cena number);PROCEDURE apskatit;END Riepa;

CREATE OR REPLACE PACKAGE BODY Riepa ASPROCEDURE pievienot(R_ID number, Marka varchar2, Modelis varchar2, Platums varchar2, Slodze number, Slodzes_ind varchar2,Sezona Varchar2, Cena Number) AS Language JavaNAME 'Riepa.pievienot(int, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, int)';

PROCEDURE apskatit AS LANGUAGE JAVAName 'Riepa.apskatit()';END Riepa;

32

Lai pārliecinātos, ka gan pakete „Riepa”, gan paketes ķermenis ir izveidojies pareizi, apskatīsimies, vai mēs varam tos ieraudzīt zem kopējā pakešu un pakešu ķermeņu saraksta.

Bez šaubām, viss ir izveidojies pareizi.

Nākamais, ko nepieciešams izdarīt ir Datu bāzes un JAVA buferu inicializācija pirms metožu izsaukšanas. Tas nodrošina izvades ieslēgšanu un izvades garumu.

SET SERVEROUTPUT ONCall Dbms_Java.Set_Output(2000);

Tagad atliek vien izsaukt nupat izveidotās metodes. Vispirms izsauksim metodi pievienot, tai iekavās norādot pievienojamās vērtības.

Call Riepa.pievienot(1, 'Bridgestone', 'Blizaak Dm-z3', '225/60', 105, 'R', 'Ziemas', 120);Call Riepa.pievienot(2, 'Nokian', 'Hakkapellitta 5', '235/55', 103, 'T', 'Ziemas', 160);Call Riepa.pievienot(3, 'Dunlop', 'WinterSport 3D', '235/65', 104, 'H', 'Ziemas', 650);Call Riepa.pievienot(4, 'Michelin', 'Primacy HP', '215/50', 95, 'V', 'Vasaras', 60);

33

Kad pievienot() metode ar pievienotajām vērtībām parametros izpildīta, atliek vien pārliecināties, ka dati pievienoti veiksmīgi.

Call Riepa.apskatit();

Kā varam novērot, visi dati tika pievienoti un izvadīti pareizi.

Relāciju-objektu tabulas izveidošana un datu izguve ar JAVA

Šoreiz izveidosim relāciju-objektu tabulu.

Vispirms izveidosim tipu Sniega_motocikls, kas saturēs šādas vērtības – sniega motocikla marku, modeli un ražošanas gadu.

CREATE OR REPLACE TYPE Sniega_motocikls AS Object(Marka varchar2(30),Modelis varchar2(30),Gads number(4));

34

Lai pārliecinātos, ka tips izveidojies pareizi, apskatīsimies vai tas ir redzams kopīgajā tipu sarakstā.

Jā, kā varam novērot, tips ir veiksmīgi izveidojies un redzams kopīgajā tipu sarakstā.

Tagad izveidosim tabulu Sniega motocikli, kas saturēs jaunizveidotā tipa objektus sniega motocikls.

CREATE TABLE Sniega_motocikli OF Sniega_motocikls;

Lai pārliecinātos, ka tabula izveidojusies pareizi, apskatīsimies, vai tā redzama kopīgajā tabulu sarakstā. Tā kā tabulas ir ļoti daudz, neizdevās uztaisīt ekrānuzņēmumu no visu tabulu skata, tāpēc izvēlējos mūsu tabulu – Sniega_motocikli un ekrāna attēlojumā redzama tabulas struktūra.

35

Kad tabula izveidota, varam definēt JAVA klasi jau ierastajā veidā, izveidojot tās definējumu un izvēloties „RUN”.

CREATE OR REPLACE JAVA source named "Snow_moto" asimport java.sql.*;import java.io.*;import oracle.jdbc.*;

public class Snow_moto {

public static void pievienot(int ID, String Marka, String Modelis, int Gads) throws SQLException { String sql = "INSERT INTO Sniega_motocikli VALUES (?, ?, ?, ?)"; //Pats SQL vaicājums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); // Izveidojam savienojumu ar datubāzi PreparedStatement st = conn.prepareStatement(sql); st.setInt(1, ID); st.setString(2, Marka);

36

st.setString(3, Modelis); st.setInt(4, Gads);; st.executeUpdate(); // SQL vaicājuma izpildīšana st.close(); // Savienojuma aizvēršana } catch (SQLException e) { //Kļūdu izvadīsana


}

public static void dzest(int ID) throws SQLException { String sql = "DELETE FROM Sniega_motocikli WHERE ID = ?";//vaicajums try { Connection conn = DriverManager.getConnection("jdbc:default:connection:");//savienojums ar datubazi PreparedStatement dpstmt = conn.prepareStatement(sql); dpstmt.setInt(1, ID); dpstmt.executeUpdate(); dpstmt.close(); } catch (SQLException e) {System.err.println(e.getMessage()); } }

}

37

Lai pārliecinātos, ka JAVA klase izveidojusies pareizi, varam apskatīties, vai tā pievienota kopējam sarakstam. Rezultātā varam redzēt, ka viss tik tiešām ir kārtībā.

Visbeizot definēsim paketi un tās ķermeni „Snow_moto”. Tajā būs divas metodes – pievienot() – vērtību pievienošanai, kā parametrus norādot pievienojamās vērtības un dzest() – kur kā parametru norādīsim dzēšamo identifikatoru.

CREATE OR REPLACE PACKAGE Snow_moto ASPROCEDURE pievienot(ID number, Marka varchar2, Modelis varchar2, Gads number);PROCEDURE dzest(ID number);END Snow_moto;

CREATE OR REPLACE PACKAGE BODY Snow_moto ASPROCEDURE pievienot(ID number, Marka varchar2, Modelis varchar2, Gads number) AS Language JavaNAME 'Snow_moto.pievienot(int, java.lang.String, java.lang.String, int)';

PROCEDURE dzest(ID number) AS LANGUAGE JAVAName 'Snow_moto.dzest(int)';END Snow_moto;

38

Lai pārliecinātos, ka pakete „Snow_moto” un tās ķermenis ir veiksmīgi izveidojies, apskatīsimies, kas redzams kopējā pakēšu un to ķermeņu sarakstā.

Kā varam novērot, tik tiešām viss ir izveidojies pareizi.

Tagad varam izsaukt metodi pievienot(), kā parametrus norādot pievienojamās vērtības.

Call Snow_moto.pievienot(1, 'Artic Cat', 'ZR 600', 2002);Call Snow_moto.pievienot(2, 'Polaris', 'IQ Touring', 2009);Call Snow_moto.pievienot(3, 'Yamaha', 'Venture XL', 2006);Call Snow_moto.pievienot(4, 'Ski-Doo', 'Tundra', 2010);

39

Lai pārliecinātos, ka dati pievienojušies veiksmīgi, izsauksim SQL vaicājumu, kas izvadīs tabulas saturu. Izvadīsim datus gan kā parastas relāciju tabulas gadījumā, gan kā relāciju objektus.

SELECT VALUE(S) FROM Sniega_motocikli S;SELECT * FROM Sniega_motocikli;

Kā varam novērot, dati ir pievienojušies veiksmīgi.

Tagad pamēģināsim izsaukt metodi dzest(), kā parametru norādot dzēšamā sniega motocikla identifikatoru. Šajā gadījumā pamēģināsim dzēst ierakstu, kur sniega motocikla identifikators ir „3”.

CALL Snow.moto.dzest(3);

40

Lai pārliecinātos, ka ieraksts patiešām ir dzēsies, atkārtoti izpildīsim SQL vaicājumu, lai iegūtu tabulas saturu.

SELECT VALUE(S) FROM Sniega_motocikli S;SELECT * FROM Sniega_motocikli;

Kā varam novērot, ieraksts ar identifikatoru „3” tik tiešām ir dzēsies. To uzskatāmi var redzēt augšā esošajos attēlos pirms un pēc metodes izsaukšanas un izpildes.

JAVA programmu izveide ar JDeveloper

Ņemot vēra, ka JAVA programmas izveide ar IDE rīku tiek realizēta arī 6. uzdevumā, šoreiz pamēgināsim izveidot pavisam vienkāršu JAVA programmu vērtību ievadīšanai un izvadīsanai bez datu apmaiņas ar datubāzi.

Izveidosim jaunu JAVA klasi Book (šaja klasē tiks definēti paši klases mainīgie, konstruktora funkcija kā arī get un set metodes. Sīkākus skaidrojumus par to, kas šeit notiek norādīsim pašā JAVA klases definējumā:

package client;

public class Book { private String nosaukums; // Definējam klases mainīgos

41

private String autors; private int lapaspuses; public Book(String a, String b, int c) //Definēsim konstruktora funkciju {nosaukums = a; autors = b; lapaspuses = c;} public String getNosaukums() {return nosaukums;} //Metodes Setteri un Getteri public String getAutors() {return autors;} public int getLapaspuses() {return lapaspuses;} public void setNosaukums(String x) {nosaukums = x;} public void setAutors(String y) {autors = y;} public void setLapaspuses(int z) {lapaspuses = z;}}

Izveidosim otru JAVA klasi BookTest, šī klase saturēs Main metodi. Vispirms aizpildīsim masīvu ar datiem, taču pēctam veiksim datu izvadi.

package client;

public class BookTests { public static void main(String[] args) { //galvenā Main metode, ko varēs izpildīt Book masivs[] = new Book[5]; // izveidojam masīvu masivs[0] = new Book("Vinnija puka piedzivojumi", "Alans Aleksandrs Milns", 192); masivs[1] = new Book("Pasakas par ziediem", "Anna Sakse", 296); masivs[2] = new Book("Kakisa dzirnavas", "Karlis Skalbe", 52); masivs[3] = new Book("Zala Zeme", "Andrejs Upits", 813); masivs[4] = new Book("Meistars un Margarita", "Mihails Bulgakovs", 432);// Norādam, kā tiek aizpildīti massīva dati System.out.println("Masiva[] dati:"); //Virsraksts izvadei for (Book c : masivs) //izsaucam ciklu System.out.println("Gramatas nosaukums: " + c.getNosaukums() + " Autors: " + c.getAutors() + " LPP: " + c.getLapaspuses()); //Izvadam datus izmantojot Getter metodi

42

}}

Visbeidzot varam palaist (“RUN) izpildei klasi “BookTests”, jo tā satur Main funkciju un izvadīs masīva datus.

Kā varam novērot, dati ir izvadījušies pareizi.

43

5. JAVA metodes izsaukšana objektu metodē un trigerī

Lai izpildītu 5. uzdevumu izveidosim vēl vienu papildus relāciju tabulu, tā saturēs šādas vērtības – Alus_identifikatoru, Alus_nosaukumu, Veco cenu un Jauno cenu. Izpildot šo uzdevumu izmantosim arī 1. uzdevumā izveidoto tabulu Alus.

CREATE TABLE Cenu_lapa(Alus_ID number,Alus_nos varchar2(30),Veca_cena number,Jauna_cena number);

Tagad izveidosim JAVA klases definējumu atsevišķā failā „DBTrigger.java”. Tas saturēs vienu metodi, kas ievietos vērtības jaunizveidotajā tabulā „Cenu_lapa”.


public class DBTrigger {public static void newPrice (int Alus_ID, String Alus_nos, float Veca_cena,

float Jauna_cena)throws SQLException {Connection conn = DriverManager.getConnection("jdbc:default:connection:");

//Savienojums ar datubāziString sql = "INSERT INTO Cenu_lapa VALUES (?, ?, ?, ?)"; //SQLtry {

PreparedStatement statement = conn.prepareStatement(sql);statement.setInt(1, Alus_ID);statement.setString(2, Alus_nos);statement.setFloat(3, Veca_cena);statement.setFloat(4, Jauna_cena);statement.executeUpdate(); //SQL izpildestatement.close();} catch (SQLException e) {System.err.println(e.getMessage()); }

//izvadam kļūdas, ja tādas eksistē}

}

Tagad definēsim jaunu procedūru „newPrice”.

CREATE OR REPLACE PROCEDURE newPrice (Alus_ID number, Alus_nos varchar2, Veca_cena number, Jauna_cena number)

44

AS LANGUAGE JAVANAME 'DBTrigger.newPrice(int, java.lang.String, float, float)';

Definēsim trigeri, kas nostrādās un izsauks nupat izveidoto procedūru pie šāda gadījuma, - ja atjaunojot cenas tabulai Alus, jaunā cena ir par 5% lielāka par veco cenu, ievietosim Alus_ID, Nosaukumu un gan veco, gan jauno cenu jaunajā tabulā.

CREATE OR REPLACE TRIGGER Alus_trigAFTER UPDATE OF Cena ON AlusFOR EACH ROWWHEN (NEW.Cena > 1.05 * Old.Cena)CALL newPrice(:new.Alus_ID, :old.Alus_nos, :old.Cena, :new.Cena)

Visbeidzot atliek pārbaudīt vai nupat izveidotais trigeris veic savu darbu un tabulā „Cenu_lapa” tiek ievietotas vērtības, kas atbilst nosacījumiem.

Pirms atjaunosim cenas un pārbaudīsim, vai metode strādā, apskatīsimies, kādu informāciju šobrīd satur tabula „Alus’. Informāciju izgūt no datubāzes mums palīdzēs iepriekš izveidotā metode Beer.apskatit().

Atjaunosim alus cenas, palielinot tās par 6 santīmiem.

UPDATE Alus SET Cena = Cena + 0.06;

45

Apskatīsimies, vai cenas ir atjaunojušās tabulā „Alus”. Izsauksim metodi Beer.apskatit().

Kā varam novērot, cenas tik tiešām ir palielinājušās par 6 santīmiem.

Tagad apskatīsimies, kas notiek ar jaunizveidoto tabulu Cenu_lapa.

SELECT * FROM Cenu_lapa;

Kā varam novērot, par 5% cena ir palielinājusies tikai 9 ierakstiem, kuru identifikatori, alus nosaukumi, vecā cena un jaunā cena ir ierakstīta nupat izveidotajā tabulā.

Varam secināt, ka JAVA metodes izsaukšana trigerī ir izdevusies un nostrādājusi pareizi.

46

6. Java glabājamās procedūras izsaukšana no JAVA programmas ārpus DB

Šī uzdevuma izpildīšanai izmantosim pirmajā uzdevumā izveidoto tabulu Alus_razotaji. Uzdevumu izpildīsim izmantojot izstrādes vidi JDeveloper, tādējādi izpildot arī 4. uzdevuma prasību izstrādāt JAVA programmu ar IDE rīku, taču šoreiz izvēlēsimies citu lomu (role), - JAVA Developer.

Programmas uzdevums būs izsaucot JAVA glabājamo procedūru atgriezt ražotāja nosaukumu, kā parametru norādot ražotāja identifikatoru. Ņemot vēra, ka mums galvenais uzdevums būs atgriezt vērtību (nosaukumu) un mums nav void metode, procedūras vietā lietosim funkciju, kas pēc savas būtības īpaši neatsķiras no procedūras. Java glabājamo funkciju izsauksim no JAVA programmas, ko veidosim ar JDeveloper, un tā kā tas notiks ārpus datu bāzes lietojuma programmas, veidosim savienojumu ar datubāzi ORACLE. Vispirms izveidosim pašu JAVA glabājamo funkciju. Lai to varētu izdarīt, vispirms jāizveido JAVA klases definējums. Sīkāki skaidrojumi par notiekošo kā komentāri norādīti pašā JAVA klases definējumā:


public class BeerBeer { public static String getBreweryInfo (int Raz_ID) //funckijai kā parametu norādīsim ražotāja identifikatoru throws SQLException { String sql = "SELECT Nosaukums FROM Alus_razotaji WHERE ID = ?";//SQL vaicājums String toReturn = ""; try { Connection conn = DriverManager.getConnection("jdbc:default:connection:"); PreparedStatement apstmt = conn.prepareStatement(sql); apstmt.setInt(1, Raz_ID); //nododam Raz_ID kā parametru ResultSet rset = apstmt.executeQuery();// SQL vaicājuma izpildīšana if (rset.next()) { toReturn = rset.getString(1); //Atgriezīsim ražotāja nosaukumu, ko iegūsim no SQL izpildes rset.close(); apstmt.close(); return toReturn; }else{ return toReturn; //Nepieciešamība kaut ko atgriezt arī, ja IF neizpildās } } catch (SQLException e) { System.err.println(e.getMessage()); //Kļūdu izvadīsana toReturn = "Exx";

47

return toReturn; } }}

Java klases failu „BeerBeer.java” pēc otrajā uzdevumā aprakstītā paņēmiena un ar tiem pašiem parametriem ielādēsim datubāzē izmantojot programmu LOADJAVA

loadjava.bat –user SYSTEM/testss –v –r –t C:/java/BeerBeer.java

Kā varam novērot, kļūdu nav (Errors: 0), savukārt Sources loaded: 1, kas nozīmē, ka viss izpildījies veiksmīgi un JAVA klase ielādēta datubāzē. Bez šaubām, ielādi varējām veikt arī ar JDeveloper, taču šoreiz izdarīju to ar LOADJAVA programmu, jo izvēlēta loma JDevelop izstrādes vidē šobrīd ir Java Developer nevis Database Developer.

Kad JAVA klase ielādēta datubāze, nākamais solis kā jau iepriekšējos uzdevumos ierasts ir pakešu izveidošana ar funkciju.Vispirms izveidosim pašu paketi “BeerBeer”. Tai parametra ir Raz_ID numurs, tacu tā atgriež mums vajadzīgo ražotāja nosaukumu.

CREATE OR REPLACE PACKAGE BeerBeer ASFUNCTION getBreweryInfo(Raz_ID number) RETURN varchar2;END BeerBeer;

Tagad izveidosim arī paketes ķermeni.

CREATE OR REPLACE PACKAGE BODY BeerBeer ASFUNCTION getBreweryInfo(Raz_ID number) RETURN varchar2 AS Language JavaNAME 'BeerBeer.getBreweryInfo(int) return java.lang.String';END BeerBeer;

48

Pirms mēģināsim izsaukt nupat izveidoto funkciju ar JAVA, pamēģināsim iegūt rezultātu ar SQL*Plus. Izveidosim mainīgo ražotājs, kur saglabāsim izpildāmās funkcijas rezultātu, taču pēctam izsauksim šo mainīgo, lai noskaidrotu, vai iegūstam to, kas nepieciešams

var razotajs varchar2(80);exec :razotajs := beerbeer.getBreweryInfo(3);print razotajs

Kā varam novērot, tik tiešam izsaucot glabājamo funkciju iegūstam ražotāja nosaukumu, kas ir tas, kas mums vajadzīgs.

Nākamais solis ir pašas JAVA programmas izveide, kas veidos savienojumu ar datubāzi un izsauks mūsu glabajamo funkciju. Programmu veidosim ar JDeveloper.

package client;

import java.sql.*;

public class JDBCPiemers { // Norādam URL draiverim un datu bāzei static final String JDBC_DRIVER = "oracle.jdbc.OracleDriver"; static final String DB_URL = "jdbc:oracle:thin:@localhost:1521:ORCL"; // Izveidojam norādi uz datu bāzes lietotājvārdu un paroli static final String USER = "SYSTEM"; static final String PASS = "testss"; private String sql;

public static void main(String[] args) throws ClassNotFoundException, SQLException { Connection conn = null; CallableStatement stmt = null; try { //Reģistrējam JDBC draiveri Class.forName("oracle.jdbc.driver.OracleDriver"); System.out.println("Izveidojam savienojumu ar datubazi ..."); conn = DriverManager.getConnection(DB_URL, USER, PASS); // Vaicājuma izveide System.out.println("Komandas veidosana...");

49

String SQL = "{CALL ? := BeerBeer.getBreweryInfo (?)}"; //Izsaucam JAVA glabājamo funkciju, nodosim ražotāja identifikatoru, atgriezīsim ražotaju stmt = conn.prepareCall(SQL); int Raz_ID = 4; //Norādam vērtību, kas nodota parametrā stmt.registerOutParameter(1, java.sql.Types.VARCHAR); //Norādam izgūstamo vērtību stmt.setInt(2, Raz_ID); System.out.println("Izpildam JAVA glabajaamo proceduru ..."); // Vaicājuma izpilde stmt.execute(); //Izgustam Alus_razotaja nosaukumu ar getXXX metodi. String Razotajs = stmt.getString(1); System.out.println("Izvadam rezultatus ..."); System.out.println("Identifikatoram NR. " +Raz_ID + " atbilst Alus_Razotajs ar nosaukumu '" + Razotajs + "'" ); stmt.close(); conn.close(); } catch(SQLException se) { //Kludu apstrade JDBC se.printStackTrace(); } catch(Exception e) { //Kludu apstrade klasei Class.forName e.printStackTrace(); } finally { // Bloks, lai aizvērtu resursus try {if(stmt!=null) stmt.close(); } catch(SQLException se2) {} try {if(conn!=null) conn.close(); } catch(SQLException se) {se.printStackTrace(); } //finally bloka beigas } // try beigas System.out.println("Darbu beidzam."); }}

50

Visbeidzot varam palaist programmu JDBCPiemers uz izpildi (“RUN”).

Kad programma palaista, skatamies izpildes rezultātus:

51

Kā varam novērot, esam izguvuši vēlamos rezultātus un Identifikatoram Nr.4 atbilst Alus_razotajs ar nosaukumu 'Svyturis'; Varam uzskatīt, ka uzdevums izpildīts pareizi.

Lai pārliecinātos, ka ID 4 tik tiešām atbilst ražotajam 'Svyturis', vēlreiz izsauksim iepriekš izveidoto metodi Brewery.apskatit();

52

Secinājumi

4. laboratorijas darba izstrādē tika izmantots atsevišķs portatīvais dators un studentiem brīvi pieejamā Windows 8 64 bit operētājsistēma no Microsoft MSDNAA, ORACLE 11g R2 versija. Kā izstrades vides riks (IDE) tika izmantota JDeveloper 12c (12.1.2.0.0) versija. Darbs tika izstrādāts līdzīgi pirmajiem trim laboratorijas darbiem, vispirms izveidojot teksta dokumentu, kur tika saglabāts viss SQL kods, regulāri saglabāti ekrāna attēli no SQL*Plus un JDeveloper izstrādes rīka, bet apraksti rakstīti tikai pašās beigās, kad jau bija tikts galā ar visiem uzdevumiem, un sataisīti visi ekrānuzņēmumi. Kopumā šī laboratorijas darba izstrāde aizņēma ievērojami vairāk laika nekā visi pārējie darbi kopā. Darba izstrādei tika veltītas apmēram 80h laika. Tas galvenokārt saistīts ar to, ka JAVA vide nebija pierasta un bija nepieciešams izskatīt daudz interneta materiālu, lai saprastu, kā vislabāk un pareizāk izpildīt uzdevumus. Jāpiebilst, ka ļoti piedomāju arī pie ievadītajiem datiem, negribējās, lai tie tiktu ievadīti tikai „kekša” pēc, līdz ar to visa ievadītā informācija tika pārdomāta un veidota atbilstoši reālai situācijai, datu precizitātei un . Iespējams, ka datu precizitāte padarīja darba izstrādi vismaz par piektdaļu ilgāku, bet radīja daudz lielāku aizrautību un prieku gan darba izstrādes laikā, gan to pabeidzot. Darba izstrādi sāku kādu laiku pirms atjaunoto prasību ievietošanas 2013. gada 7. decembrī, līdz ar to vietām papildināju uzdevumus ar paveikto pirms skaidrāku prasību definēšanas (pievienoju relāciju objektu-tabulas, datu apmaiņu ar šīm tabulām, datubāzi un dažas lietas papildus prasībam.) Neskatoties uz to, lielu uzmanību pievērsu tam, lai izpildītu arī visas pēc 7. decembra laboratorijas darba atjaunotās prasības. Darba izstrādes gaitā radās vairāki sarežģījumi un kļūdas, kas ievērojami paildzināja darba izstrādi, piemēram, sākotnēji centos arī pašu tabulu izveidi veidot ar JAVA klasēm, bet nonācu pie secinājuma, ka nav nozīmes veltīt atsevišķu klasi un definējumu tam, kas tiek izpildīts tikai vienreiz. Atsevišķos jautājumos konsultējos ar ORACLE un JAVA programmētājiem forumos. Tāpat liela aizķeršanās sanāca arī pie 6. uzdevuma, kur tikai darba izstrādes laikā un vairākas reizes to pārstrādājot, sapratu, kas īsti prasīts. Sākotnēji izveidoju PL/SQL glabājamo procedūru, ko izsaucu no atsevisķas programmas, bet tikai pēctam sāku domāt, ka tas nebija gluži tas, kas prasīts un sāku to pārveidot par JAVA glabājamo procedūru un vēlāk nonācu pie secinājuma, ka mana gadījumā noderīgāk būs lietot funkciju procedūras vietā. Beigu beigās viss izdevās. Darba izstrādes laikā nonācu arī pie secinājuma, ka izmantojot IDE rīku darbs ar ORACLE datubāzi ir vieglāks, krietni ērtāks, kaut vai no tā viedokļa, ka ērti varam pārskatīt visas izveidotās struktūras, tabulas, tipus, utt. Darbu ļoti atviegloja arī tas, ka ar IDE rīku viss notika vienuviet, nebija jāizmanto konsole JAVA klašu kompilācijai un ielādei datubāzē, kā arī SQL kods bija viegli labojams un to nevajadzēja atkārtoti iekopēt. Tiesa gan, pa laikam saņēmu Jdeveloper kļūdas paziņojumus par to, ka ir notikusi nezināma kļūme un jautājumu, vai vēlos turpināt darbu ar programmu. Kad jautājums tika uzdots kādu 10. reizi, atzīmēju, kavēlos šo paziņojumu ignorēt un turpināt strādāt. Vienā gadījumā programma bez brīdinājuma aizvēras. Izstrādājot šo laboratorijas darbu tika iegūta pieredze darbā ar JAVA programmēšanu programmu izveidi, procedūrām, metodēm kā arī izpētīts izstrādes rīks JDeveloper. Kopumā vēlējos pateikt lielu paldies par šo kursu. Bija liels prieks iegūt jaunas un pilnveidot esošās zināšanas izpildot laboratorijas darbus, kas ļāva pamatīgak un praktiski izmēgināt lekcijā noklausīto. Patiešām liels prieks.

saturs web viewuzdevumu izvēlējos izpildīt ar izstrādes vidi jdeveloper 12c (12.1.2.0.0)...

Documents