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

fakultāteLietišķo datorsistēmu institūts

3. praktiskais darbsmācību priekšmetā“Lielās datubāzes”

Izstrādāja: Jānis Graumanis091RDB057

2012./13. māc. gads

SatursDarba nostādne............................................................................3Deduktīvās datubāzes piemērs.....................................................4Datubāzes deklarācija..................................................................5Izveduma mehānisms..................................................................5Deduktīvās datubāzes īstenošana.................................................5

tuProlog bibliotēkas pielietojošas Java programmas sagatavošana............................................................................5Faktu un likumu tabulas..........................................................8Prolog vaicājumu izpildei sagatavotie objekti........................9

Faktu un likumu ievade.............................................................15Vaicājumu izpilde......................................................................16Jauna likuma (anc_females) pievienošana................................19

Jaunpievienotā anc_females likuma pārbaude......................20Secinājumi.................................................................................20Izmantotā literatūra....................................................................21

Darba nostādne

Ceturtajā praktiskajā darbā tiek izstrādāta deduktīvā DB.Darba izpilde var tikt realizēta 3 dažādos veidos:1) deduktīvās datu bāzes realizēšanai var izveidot programmas PL/SQL vai Java valodās (fakti glabājas datu bāzē, likumi vai nu datu bāzes tabulās vai procedūrās). Var papildus izmanot kādu valodas PROLOG Java bibliotēku.2) deduktīvās datu bāzes realizēšanai var izmantot kādu valodas PROLOG programmu paketi ar SQL interfeisu ar DB;3) var izmantot kādu no deduktīvās datu bāzes programmu čaulām.

(Tika izvēlēts pielietot PROLOG Java bibliotēku)

Ja tiek izmantota PROLOG Java bibliotēka deduktīvās datu bāzes izstrādei:1. Jāizmanto relāciju – objektu datu bāzes struktūras un metodes.2. Jāizmanto dināmiskais SQL vai dināmiskais PL\SQL.3. Tiek definēts piemērs, kurš tiks realizēts deduktīvās datu bāzes veidā.4. Tiek definēts faktu glabāšanas veids.5. Tiek definēts likumu glabāšanas veids.6. Tiek definēts izveduma mehānisma realizēšanas veids.7. Relāciju-objektu datu bāzes sistēmā tiek izveidotas nepieciešamās tabulas, skati un metodes, ja nepieciešams, arī funkcijas un procedūras.8. Tiek veikta faktu datu ievade tabulās.9. Tiek izpildīti vairāki (vismaz 3) vaicājumi deduktīvai datu bāzei.10.Tiek pievienots jauns likums un jāparāda, ka programmatiskas izmaiņas nav jāveic.11. Secinājumi.

Deduktīvās datubāzes piemērsDarba izpildē tiek

realizēta deduktīvā datubāze cilvēku ģenealoģiskā koka izveidei.

Datubāze sastāv no šādiem prolog valodas faktiem:human(male, kaspars).human(female, linda).human(male, janis).human(male, peteris).human(female, inga).human(female, vizma).human(male, uldis).human(male, juris).human(male, dainis).

parent(kaspars, linda).parent(linda, janis).parent(janis, inga).parent(inga, vizma).parent(inga, uldis).parent(peteris, uldis).parent(vizma, juris).parent(uldis, dainis).

Darba izpildes gaitā tiks pievienoti pirmie trīs likumi (mother, sister, ancestor). Likums anc_females, tiks pievienots datubāzei pēc funkcionēšanas demonstrēšanas, lai izpildītu uzdevumu prasību 10. punktu.mother(X, Y) :- parent(X,Y), human(female, X).sister(X, Y) :- parent(Z,X), parent(Z,Y), X\==Y, human(female, X).

ancestor(X, Y) :- parent(X,Y).ancestor(X, Z) :- parent(X,Y), ancestor(Y,Z).anc_females(X, Z) :- ancestor(X,Z), human(female, X).

Datubāzes deklarācijaDeduktīvās datubāzes dati – fakti un likumi – tiks glabāti

atsevišķās tabulās. Viena tabula (fact_table) saturēs visus faktus un otra tabula (rule_table) saturēs visus likumus. Prolog dati tiks glabāti veselā veidā, kā teksta rindiņa.

Izveduma mehānismsProlog vaicājumu izvedumu veiks java bibliotēka tuProlog[1].

Darba izpildē tiek sagatavota java programma, kurai padodot prolog faktus, likumus un mērķi, tiek atgriezts izpildīta prolog vaicājuma rezultāts. Gan java programma, gan tās izmantotā prolog bibliotēka tiek ielādēti datubāzē.

Lai vaicājumu izpilde būtu pēc iespējas efektīvāka laikā, java programmā pielietotajam prolog dzinējam tiek padoti tikai tie fakti un likumi, kurus ir jāanalizē konkrētajā vaicājumā. Pareizo likumu un faktu atlasi, un attiecīgi java programmas izsaukumu veic sagatavotas PL/SQL valodas funkcijas.

Izmantotās Oracle datubāzes pielietotā java virtuālā mašīna maksimāli atbalsta java versiju 1.5, tādēļ, lai būtu iespējams veikt tuProlog bibliotēkas ielādi datubāzē, tika iegūts šīs bibliotēkas pirmkods un pārkompilēts ar java versiju 1.5.

Deduktīvās datubāzes īstenošanatuProlog bibliotēkas pielietojošas Java programmas sagatavošana

Prolog vaicājumu izpildi veiks java programma, kura tiks ielādēta datubāzē un iesaiņota (wrapped) kā PL/SQL funkcija. Tā dēļ, ka prolog vaicājumi atgriez nulle vai vairāk rezultātus java funkcijai ir jāatgriež masīvu. Atgriežamā masīva definēšana:create or replace type string_array as table of varchar2(200)

Prolog vaicājumu izpildi veiks izveidotās java klases TuPrologWrapper statiskās funkcijas.

public static java.sql.Array prologCompute(String theoryString, String goal) – šī funkcija veic paša prolog dzinēja (engine) pielietošanu un vaicājumu izpildi. To izsaucot ir jānorāda teksta rindas theoryString, kurai ir jāsatur visus analizējamos faktus un likumus, un goal, kurai ir jāsatur prolog vaicājumu. Šī funkcija atgriež teksta rindu masīvu. Katra teksta rinda ir sagatavota formā „X/aaa;Y/bbb”, kur vaicājumā tika padoti mainīgie X un Y, un to atbildes ir attiecīgi „aaa” un „bbb”.

public static java.sql.Array wrapInSqlArray(String typeName, Object elements) – šo funkciju pielieto sagatavotā funkcija prologCompute(..), lai veiktu atgriežamo teksta rindu pārveidi un datubāzē sagatavoto tipu string_array.

public static String getVarsFromGoal(String goal) – šī funkcija veic tai padotā prolog goal (vaicājuma) analīzi un atgriež tajā norādītos mainīgos kodētus teksta rindā un atdalītus ar semikolu. Padots vaicājums „some_goal(X, term, Y, 1).” tiktu atgriezts kā „X;Y”.

import java.sql.SQLException;import java.util.ArrayList;import java.util.List;

import alice.tuprolog.Prolog;import alice.tuprolog.SolveInfo;import alice.tuprolog.Theory;

public class TuPrologWrapper {public static java.sql.Array wrapInSqlArray(String typeName,

Object elements) throws java.sql.SQLException {oracle.jdbc.OracleDriver ora = new

oracle.jdbc.OracleDriver();java.sql.Connection conn = ora.defaultConnection();oracle.jdbc.OracleConnection oraConn =

(oracle.jdbc.OracleConnection) conn;java.sql.Array arr =

oraConn.createARRAY(typeName.toUpperCase(), elements);return arr;

}

public static String getVarsFromGoal(String goal){goal = goal.replaceAll(" ", "");goal = goal.substring(goal.indexOf('(') + 1,

goal.indexOf(')'));String[] parts = goal.split(",");goal = "";for(String part : parts){

if(part.length() == 1 && part.matches("[A-Z]")){goal += part + ";";

}}try{

goal = goal.substring(0, goal.lastIndexOf(';'));}catch(IndexOutOfBoundsException e){

return "";}return goal;

}

public static java.sql.Array prologCompute(String theoryString, String goal) throws SQLException{

List<String> result = new ArrayList<String>();String[] vars = getVarsFromGoal(goal).split(";"); //will

always be at least 1 long (checked in plsql)String sol = "";

try {Prolog engine = new Prolog();Theory theory = new Theory(theoryString);engine.setTheory(theory);SolveInfo res = engine.solve(goal);if(res.isSuccess()){

for(String var : vars){sol += var + "/" + res.getTerm(var) +

";";}sol = sol.substring(0, sol.length()-1);result.add(sol);sol = "";

while(engine.hasOpenAlternatives()){res = engine.solveNext();if(res.isSuccess()){

for(String var : vars){sol += var + "/" +

res.getTerm(var) + ";";}sol = sol.substring(0,

sol.length()-1);result.add(sol);sol = "";

}}

}} catch (Exception e) {

return wrapInSqlArray("string_array", new String[0]);

}

return wrapInSqlArray("string_array", result.toArray(new String[0]));

}

}

Sagatavotā java klase un tās pielietotā bibliotēka, tiek ielādēti datubāzē pielietojot programmu ‘loadjava’, ar termināļa komandām:loadjava -user janis -r tuprolog_java15.jarloadjava -user janis -r TuPrologWrapper.java

Datubāzē ielādētās TuPrologWrapper klases funkcijas prologCompute(..) un getVarsFromGoal(..), tiek iesaiņotas kā PL/SQL funkcijas, lai būtu iespējams veikt to izsaukumu iekš datubāzes.create or replace function prolog_solve (facts_rules in varchar2, goal_in in varchar2) return string_array aslanguage java name 'TuPrologWrapper.prologCompute(java.lang.String,java.lang.String) return java.sql.Array';

create or replace function vars_from_goal (goal in varchar2) return varchar2 aslanguage java name 'TuPrologWrapper.getVarsFromGoal(java.lang.String) return java.lang.String';

Faktu un likumu tabulasProlog fakti tiks glabāti datubāzē kā tekstu rindas tabulā

fact_table. Papildus pašam faktam, kā atsevišķa vērtība tiek sagatavota kolonna fakta nosaukumam, tā tiek izveidota, lai atvieglotu vaicājumā pielietojamo faktu meklēšanu.create sequence fact_table_sequencestart with 1increment by 1cache 20;

create table fact_table (id integer primary key,fact_name varchar2(20),fact_vals varchar2(200));

Prolog likumi datubāzē tiek glabāti tabulā rules_table. Katra likuma rinda tiek glabāta kā teksts. Likumu rindu secīgums tiks nodrošināts pieskatot, lai veicot likumu ievadi un nolasīšanu, tabulas id kolonna ir augoša. Papildus tiek sagatavotas kolonnas likuma nosaukumam un likuma rindā esošajiem termiem. Abas šīs kolonnas tiks pielietotas likumu meklēšanā.create sequence rule_table_sequencestart with 1increment by 1cache 20;

create table rule_table (id integer primary key,rule_name varchar2(20),rule_val varchar2(1000),contained_rules_facts string_array) nested table contained_rules_facts store as contained_rules_facts_table;

Prolog vaicājumu izpildei sagatavotie objektiDarbam ar faktiem un likumiem, un vaicājumu izpildi ir

sagatavoti divi objekti prolog un solve_result. Solve_result tiek automātiski izveidots un saglabāts objektam

prolog kā atribūts pēc vaicājuma izpildes. Solve_result satur izpildītā vaicājuma tekstu un atgriezto rezultātu masīvu. Pielietojot šos abus atribūtus ir iespējams izgūt visu nepieciešamo informāciju par vaicājumu.create or replace type solve_result as object (goal varchar2(100),returned_result string_array,constructor function solve_result(goal_in varchar2) return self as result);

create or replace type body solve_result AS constructor function solve_result(goal_in varchar2)

return self as result isbegin

self.goal := goal_in;return;

end;end;

Objekts prolog satur nepieciešamās funkcijas deduktīvām darbībām:

static procedure add_fact(fact in varchar2) – šī procedūra veic jauna fakta pievienošanu pareizajā tabulā.

static procedure add_rule(rows_in in rule_rows) – šī procedūra veic jauna likuma pievienošanu pareizajā tabulā, tā arī pārliecinās, ka likuma rindas ir ievadītas pareizā secībā. Likuma rindu pievienošanas procesā tiek arī veikta aizpilde tabulas kolonnām, kuras būs nepieciešamas likumu meklēšanā.

member procedure solve_goal(goal in varchar2) – šī procedūra veic prolog vaicājuma izpildi. Tā veic norādītā vaicājuma analīzi, sagatavo konkrētā vaicājuma redzeslokā esošos faktus un likumus. Sagatavotie likumi/fakti un pats vaicājuma teksts tiek padoti, iepriekš ielādētajai java programmai, kura izpilda prolog vaicājumu un atgriež rezultātu šai metodei. Java programmas atgrieztais rezultāts tiek saglabāts paša prolog objekta last_solve atribūtā.

constructor function prolog return self as result – izveido tukšu prolog objektu, gatavu vaicājuma izpildei.

static function extract_name(fact_rule in varchar2) return varchar2 – palīgmetode, kura izgūst nosaukumu no prolog likuma/fakta.

static function extract_all_names(fact_rule in varchar2) return string_array – palīgmetode, kura izgūst visu likumu un faktu nosaukumus no prolog likuma rindas. Tā tiek pielietota sagatavojot likumu meklēšanas palīg-kolonnas.

static procedure get_contained_rules_facts(name_in in varchar2, arr in out string_array) – palīgmetode, kura veic visa vaicājumā pārmeklējamo faktu un likumu sarakta izgūšanu. name_in drīkst būt tikai likuma nosaukums.

Darba izpildē nācās arī izveidot sinonīmu prolog_synonym, manas Oracle verisijas bug dēļ.

create or replace type rule_rows as table of varchar2(1000);

create or replace type prolog as object (last_solve solve_result,static procedure add_fact(fact in varchar2),static procedure add_rule(rows_in in rule_rows),member procedure solve_goal(goal in varchar2),constructor function prolog return self as result,static function extract_name(fact_rule in varchar2) return varchar2,static function extract_all_names(fact_rule in varchar2) return string_array,static procedure get_contained_rules_facts(name_in in varchar2, arr in out string_array));

create or replace synonym prolog_synonym for prolog; --because of a bug

create or replacetype body prolog AS

constructor function prolog return self as result isbegin

self.last_solve := null;return;

end;

static procedure add_fact(fact in varchar2) iss varchar2(20);begin

s := extract_name(fact);insert into fact_table values

(fact_table_sequence.nextval, s, fact);end;

static procedure add_rule(rows_in in rule_rows) iss varchar2(20);contained_arr string_array;begin

for i in 1 .. rows_in.count loopcontained_arr := extract_all_names(rows_in(i));s := extract_name(rows_in(i));insert into rule_table values

(rule_table_sequence.nextval, s, rows_in(i), contained_arr);end loop;

end;

member procedure solve_goal(goal in varchar2) isname varchar2(20);goal_var_str varchar2(20);sql_str varchar2(200);

type cursor_type is ref cursor;row_cursor cursor_type;str_row varchar2(1000);data_arr string_array;contained_rules_facts string_array;fact_where_str varchar2(300);rule_where_str varchar2(300);data_str varchar2(32767);begin

name := prolog.extract_name(goal);data_arr := string_array();goal_var_str := vars_from_goal(goal);

if(substr(goal,length(goal),length(goal)+1)!='.') thenreturn; --goal was invalid ... return

end if;

if(length(goal_var_str) is null) thenreturn; --goal was invalid ... return

end if;

sql_str := 'select a.fact_vals from fact_table a where a.fact_name = ''' || name || '''';

open row_cursor for sql_str;loop

fetch row_cursor into str_row;exit when row_cursor%NOTFOUND;data_arr.extend;data_arr(data_arr.count) := str_row;

end loop;

if(data_arr.count = 0) then

--passed goal is a rule and not a factcontained_rules_facts := string_array();

prolog_synonym.get_contained_rules_facts(name, contained_rules_facts);

for i in 1 .. contained_rules_facts.count loop if(i = 1) then

fact_where_str := ' where a.fact_name=''' || contained_rules_facts(i) || '''';

rule_where_str := ' where a.rule_name=''' || contained_rules_facts(i) || '''';

elsefact_where_str := fact_where_str || '

or a.fact_name=''' || contained_rules_facts(i) || '''' ;rule_where_str := rule_where_str || '

or a.rule_name=''' || contained_rules_facts(i) || '''' ;end if;

end loop;

--add facts to datasql_str := 'select a.fact_vals from fact_table a'

|| fact_where_str;

open row_cursor for sql_str;loop

fetch row_cursor into str_row;exit when row_cursor%NOTFOUND;data_arr.extend;data_arr(data_arr.count) := str_row;

end loop;

--add rule to datasql_str := 'select a.rule_val from rule_table a' ||

rule_where_str;open row_cursor for sql_str;loop

fetch row_cursor into str_row;exit when row_cursor%NOTFOUND;data_arr.extend;data_arr(data_arr.count) := str_row;

end loop;end if;

if(data_arr.count = 0) then--couldnt prepare data for solving ... goal was

invalid ... returnreturn;

end if;

--assemble the data string for solving data_str := '';for i in 1 .. data_arr.count loop

if(length(data_str) is null) thendata_str := data_arr(i);

else data_str := data_str || ' ' || data_arr(i);

end if;end loop;

--DBMS_OUTPUT.PUT_LINE('str - ' || data_str);

/*for i in 1 .. data_arr.count loopDBMS_OUTPUT.PUT_LINE(i || ' - ' || data_arr(i));

end loop;*/

self.last_solve := solve_result(goal, prolog_solve(data_str, goal));

end;

static function extract_name(fact_rule in varchar2) return varchar2 is

i integer;s varchar2(20);begin

i := instr(fact_rule, '(');s:=substr(fact_rule,0, i-1);return s;

end;

static function extract_all_names(fact_rule in varchar2) return string_array is

str varchar2(1000);s varchar2(20);i integer;j integer;k integer;arr string_array;begin

arr:= string_array();str := fact_rule;

str := replace(str, ':-', ',');str:= replace(str, ' ', '');str:= replace(str, '.', '');

while length(str) > 0 loopk:= instr(str, ',');i:= instr(str, '(');j:= instr(str, ')');if(k=1) or (i=1) or(j=1) then

str:=substr(str,2,length(str));continue;

end if;

if (k>0) and(i=0) thenstr:=substr(str,k,length(str));continue;

end if;

s:= '';

if(i=0) thenstr:= '';

elsif(i<j) and (k<i) thenstr:= substr(str,k,length(str));continue;

elsif(i<j) thens := prolog.extract_name(str);

elsestr:= substr(str,j+1,length(str));continue;

end if;

if(length(s)>1) thenarr.extend;arr(arr.count) := s;str:= substr(str,length(s)+1,length(str));continue;

end if;end loop;

return arr;end;

static procedure get_contained_rules_facts(name_in in varchar2, arr in out string_array) is

type cursor_type is ref cursor;row_cursor cursor_type;sql_str varchar2(200);str_row varchar2(20);prev_str_row varchar2(20);begin

sql_str := 'select b.* from rule_table a, table(a.contained_rules_facts) b where a.rule_name = ''' || name_in || '''';

open row_cursor for sql_str;<<outer_loop>>loop

fetch row_cursor into str_row;exit when row_cursor%NOTFOUND;prev_str_row := str_row;for i in 1 .. arr.count loop

if(arr(i) = str_row) thencontinue outer_loop;

end if;end loop;

arr.extend;arr(arr.count) := str_row;

get_contained_rules_facts(str_row, arr);

end loop;

close row_cursor;end;

end;

Faktu un likumu ievadeTā dēl, ka ir sagatavotas procedūras faktu un likumu ievadei, to izpildīšana ir triviāla.set serveroutput on;declare begin

prolog.add_fact('human(male, kaspars).');prolog.add_fact('human(female, linda).');prolog.add_fact('human(male, janis).');prolog.add_fact('human(male, peteris).');prolog.add_fact('human(female, inga).');prolog.add_fact('human(female, vizma).');prolog.add_fact('human(male, uldis).');prolog.add_fact('human(male, juris).');prolog.add_fact('human(male, dainis).');

prolog.add_fact('parent(kaspars, linda).');prolog.add_fact('parent(linda, janis).');prolog.add_fact('parent(janis, inga).');prolog.add_fact('parent(inga, vizma).');prolog.add_fact('parent(inga, uldis).');prolog.add_fact('parent(peteris, uldis).');prolog.add_fact('parent(vizma, juris).');prolog.add_fact('parent(uldis, dainis).');

prolog.add_rule(rule_rows('mother(X, Y) :- parent(X,Y), human(female, X).'));

prolog.add_rule(rule_rows('sister(X, Y) :- parent(Z,X), parent(Z,Y), X\==Y, human(female, X).'));

prolog.add_rule(rule_rows('ancestor(X, Y) :- parent(X,Y).','ancestor(X, Z) :- parent(X,Y), ancestor(Y,Z).'));

end;

Vaicājumu izpilde1. Šis prolog vaicājums atgriež visus cilvēkus, kuriem ‘inga’ ir

māte.

2. Šis vaicājums atgriež visus cilvēkus, kuriem ‘vizma’ ir māsa

3. Šis vaicājums atgriež visus ulda pirmstečus

4. Šis prolog vaicājums atgriež visas mātes un bērnus

Jauna likuma (anc_females) pievienošanadeclare begin

prolog.add_rule(rule_rows('anc_females(X, Z) :- ancestor(X,Z), human(female, X).'));end;

Jaunpievienotā anc_females likuma pārbaude

SecinājumiDeduktīvās datubāzes izstrādē tika pielietota java bibliotēka

tuProlog. Darba izstrādē tika izveidota java programma, kura pildīja prolog vaicājumus pielietojot šo bibliotēku. Izstrādātā java programma tika ielādēta datubāzē un ’iesaiņota’ PL/SQL funkcijā. Pēc prolog ‘dzinēja’ sagatavošanas bija tikai nepieciešams izveidot procedūras, kuras atlasa pareizos faktus un likumus, un padod tos vaicājumu pildošajai programmai.

Darba izstrādē bija problēmas ar derīgas prolog bibliotēkas atrašanu. Izņemot izvēlēto, izdevās atrast tikai vēl vienu bibliotēku „GNU Prolog for Java”. Šīs bibliotēkas programmēšanas interfeiss atļāva veikt faktu un likumu ielādi tikai norādot failu (java File objektu), kas bija problemātiski, jo faktu glabāšanai bija jāizmanto

datubāze. Bija problēmas arī ar gala rezultātā pielietoto bibliotēku tuProlog. Visi pieejamie bibliotēkas *.jar faili bija kompilēti ar java1.6 vai jaunāku versiju, bet OraDb11g maksimāli atbalsta tikai java1.5; tika veikta bibliotēkas pārkompilēšana no tās pirmkoda.

Izmantotā literatūra[1] tuProlog – (http://apice.unibo.it/xwiki/bin/view/Tuprolog/)- Oracle Database documentation (http://docs.oracle.com/cd/E11882_01/index.htm)- Prof. Jānis Eiduks „Mācību materiāli par intelektuālajām datu bāzes sistēmām” (http://datubaze.wordpress.com/macibu-kursi/db3/macibu-materiali-prieksmeta-progresivas-datu-bazesdb3/macibu-materiali-par-deduktivajam-datubazem/)