Wykład 4 Obiektowość w obiektowo-relacyjnych bazach danych na przykładzie Oracle

Rodzaje obiektów Obiekty typów obiektowych Duże obiekty LOB Kod Javy składowany w bazie danych i wykonywany na serwerze bazy danych

Niezgodność typów (impedance mismatch) Nowe bazy danych są na ogół relacyjne, a nowe aplikacje klienckie obiektowe. Prawe wszystkie dane są aktualnie przechowywane w strukturach nie-obiektowych. Relacyjne bazy danych stanowią najlepszy kompromis: wydajność/naturalne modelowanie obiektów między poziomem aplikacyjnym a fizycznym. Jak zbliżyć do siebie oba niespójne względem siebie modele danych (bazy danych i obiektowej aplikacji): obiektowe-relacyjne bazy danych – od strony bazy danych, odwzorowania obiektowo-relacyjne ORM – od strony aplikacji. Relacyjne bazy danych mogą być projektowane i używane przez osoby, które nie są programistami.

Typ obiektowy Złożony typ danych definiowany przez użytkownika. Hermetyzuje strukturę danych łącznie z metodami potrzebnymi do operowania na strukturze danych. Wyślij Atrybut Id_zam Info_klient Pozycje Status Anuluj Wyśw_Status Metoda Zatrzymaj

Struktura typu obiektowego Specyfikacja typu Publiczny interfejs Deklaracje atrybutów Specyfikacje metod Ciało typu Prywatna implementacja Ciała metod

Tworzenie specyfikacji typu obiektowego Składnia CREATE TYPE nazwa_typu AS OBJECT [(atrybut1 typdanych, atrybut2 typdanych, . . .] [MEMBER procedura1 | funkcja1 spec, procedura2 | funkcja2 spec, . . .)]

Tworzenie ciała typu obiektowego Składnia CREATE TYPE BODY nazwa_typu AS [MEMBER procedura1 | funkcja1 body, procedura2 | funkcja2 body, . . .] END

Przykład SQL> CREATE TYPE name_type AS OBJECT( f_name VARCHAR2(25), l_name VARCHAR2(25), initials VARCHAR2(7), MEMBER FUNCTION full_name RETURN VARCHAR2, PRAGMA RESTRICT_REFERENCES(full_name, WNDS, RNDS, WNPS, RNPS ));

Przykład SQL> CREATE TYPE BODY name_type AS MEMBER FUNCTION full_name RETURN VARCHAR2 IS BEGIN RETURN (l_name || ' ' || f_name ); END full_name; END;

Przykład SQL> CREATE TYPE emp_type AS OBJECT( emp_id NUMBER(7), name name_type, -- typ obiektowy street VARCHAR2(25), city VARCHAR2(15), state CHAR(2), zip INTEGER, MEMBER FUNCTION get_name RETURN VARCHAR2, PRAGMA RESTRICT_REFERENCES(get_name, WNDS, RNDS, WNPS, RNPS), MEMBER PROCEDURE set_l_name (v_name VARCHAR2));

Przykład SQL> CREATE TYPE BODY emp_type AS MEMBER FUNCTION get_name RETURN VARCHAR2 IS BEGIN RETURN (name.l_name ||' '|| name.f_name); END; MEMBER PROCEDURE set_l_name (v_name VARCHAR2) name.l_name := v_name;

Rodzaje metod MEMBER – z niejawnym pierwszym parametrem SELF – definiowanego typu danych. Obejmuje metody służące do porównywania obiektów. STATIC – bez SELF; wywoływane type_name.method np. metody konstruktorów obiektów definiowane przez użytkowników. Implementowane w PL/SQL, Java, C.

Rodzaje metod Metody konstruktorów obiektów – jeden zdefiniowany przez system (parametrami są atrybuty obiektu), inne przez użytkownika. Metody porównywania: MAP – przez odwzorowanie układu wartości atrybutów na liczbę; ORDER – bezpośrednio wylicza wynik porównania dwóch obiektów < to -1, = to 0, > to 1.

MAP CREATE TYPE rectangle_typ AS OBJECT (len NUMBER, wid NUMBER, MAP MEMBER FUNCTION area RETURN NUMBER); CREATE TYPE BODY rectangle_typ AS MAP MEMBER FUNCTION area RETURN NUMBER IS BEGIN RETURN len * wid; END area; END;

ORDER CREATE TYPE location_type AS OBJECT (building_no NUMBER, city VARCHAR2(40), ORDER MEMBER FUNCTION match (l location_type) RETURN INTEGER); CREATE TYPE BODY location_type AS ORDER MEMBER FUNCTION match (l location_type) RETURN INTEGER IS BEGIN IF building_no < l.building_no THEN RETURN -1; ELSIF building_no > l.building_no THEN RETURN 1; ELSE RETURN 0; END IF; END; END;

Dziedziczenie (tylko jednokrotne) SQL> CREATE TYPE Person AS OBJECT ( first VARCHAR2(50), last VARCHAR2(50)) NOT FINAL; SQL> CREATE TYPE Emp UNDER Person ( salary NUMBER) FINAL; SQL> DECLARE x Emp:=Emp('Jan','Kowalski',10000); BEGIN DBMS_OUTPUT.Put_line(x.first||' '||x.last ||' '||x.salary); END; By default, an object type is declared as final and subtypes cannot be derived from it. You can change a final type to a not final type and vice versa with an ALTER TYPE statement. For example, the following statement changes person_typ to a final type: ALTER TYPE person_typ FINAL; You can alter a type from NOT FINAL to FINAL only if the target type has no subtypes. NOT FINAL – wymagane aby móc definiować podtypy.

Typ bez instancji NOT INSTANTIABLE Nie posiada konstruktora. Nie można tworzyć obiektów tego typu. CREATE TYPE Address_t AS OBJECT(...) NOT INSTANTIABLE NOT FINAL; CREATE TYPE USAddress_t UNDER Address_t(...); CREATE TYPE IntlAddress_t UNDER Address_t(...); Typ bez instancji może być definiowany jako podtyp typu z instancjami. Typ bez instancji nie może być FINAL. Typ abstrakcyjny Metoda bez implementacji NOT INSTANTIABLE Typ nie dostarcza implementacji metody. Typ, który zawiera metody bez implementacji, musi sam być NOT INSTANTIABLE. Metody mogą być specyfikowane jako NOT FINAL (domyślnie) bądź FINAL – bez możliwości zmiany w podtypie.

Polimorfizm Przedefiniując dziedziczone metody w podtypie mamy możliwość zdefiniowania innego sposobu wykonania metod na obiektach podtypu. Obiekt podtypu może być użyty w kodzie w miejsce obiektu nadtypu – definiując dla różnych podtypów różne działania. Polymorphism is the ability of a value in code to contain a value of either a certain declared type or any of a range of the declared type's subtypes. A method called on whatever value occupies the slot may execute differently depending on the value's type because the various types might implement the method differently.

Przykład - przesłanianie CREATE TYPE person_type AS OBJECT ( idno NUMBER, name VARCHAR2(30), phone VARCHAR2(20), MEMBER FUNCTION show RETURN VARCHAR2) NOT FINAL; CREATE TYPE BODY person_type AS -- function that can be overriden by subtypes MEMBER FUNCTION show RETURN VARCHAR2 IS BEGIN RETURN 'Id: ' || TO_CHAR(idno) || ', Name: ' || name; END; A subtype that overrides a member method must signal the override with the OVERRIDING keyword in the type definition. Giving a type multiple methods with the same name is called method overloading.

Przesłanianie cz. 2 OVERRIDING CREATE TYPE student_type UNDER person_type ( dept_id NUMBER, major VARCHAR2(30), OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2) NOT FINAL; CREATE TYPE BODY student_type AS OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2 IS BEGIN RETURN (self AS person_type).show || ' -- Major: ' || major ; END;

Informacje w słowniku danych Oracle Informacje o typach obiektowych znajdują się w USER_OBJECTS Informacje o metodach typów obiektowych znajdują się w USER_METHOD_PARAMS USER_METHOD_RESULTS USER_TYPE_METHODS

Tworzenie tabeli obiektowej i wywoływanie metod SQL> CREATE TABLE name_table OF name_type; SQL> INSERT INTO name_table VALUES('Marilyn','Monroe','MM'); SQL> SELECT nt.f_name, nt.full_name() FROM name_table nt; INSERT INTO name_table VALUES(name_type('Marilyn','Monroe','MM'));

Widoki tabeli obiektowej Tabela jedno-kolumnowa: każdy wiersz jest obiektem; można wykonywać operacje obiektowe. Tabela wielokolumnowa: każdemu atrybutowi obiektu odpowiada jedna kolumna.

Rodzaje obiektów Składowane, trwałe (wymagają wykonania INSERT lub UPDATE) Wierszowe (elementy tabeli obiektowej) Kolumnowe (zapisywane w kolumnie tabeli relacyjnej) Atrybutowe (zapisywane jako wartość atrybutu obiektu wierszowego) Nieskładowane, nietrwałe Tymczasowe – tworzone w RAM i tam używane: w kodzie PL/SQL w kodzie Javy

Metoda konstruktora obiektu SQL> CREATE TYPE tv_type AS OBJECT ( tv_category VARCHAR2(20), screen_size NUMBER(4)); DECLARE v_new_tv tv_type := tv_type('WEB tv', 32); v_alt_tv tv_type; BEGIN v_alt_tv := tv_type('Big Screen', 72); END; Obiekty tymczasowe – w bloku PL/SQL SQL> CREATE TABLE tv OF tv_type; SQL> INSERT INTO tv VALUES(tv_type('Color tv', '28'));

SELECT na tabeli obiektowej Wynikiem zbiór wierszy (tabela relacyjna): SELECT * FROM name_table p WHERE p.l_name LIKE 'M%'; Wynikiem zbiór obiektów (tabela obiektowa): SELECT VALUE(p) FROM name_table p WHERE p.l_name LIKE 'M%'; „Kanoniczna” reprezentacja obiektu w SQL*Plus - napis: -- NAME_TYPE('Marilyn','Monroe','MM') DECLARE . . . p1 emp_typ; p2 emp_typ; . . . BEGIN SELECT VALUE(p) INTO p1 FROM person_tab p WHERE p.l_name = 'ALLEN'; p2 := p1; ... END;

INSERT do tabeli obiektowej Bezpośrednio: BEGIN INSERT INTO name_table VALUES('Marilyn','Monroe','MM'); END; Z użyciem konstruktora typu obiektowego: BEGIN INSERT INTO name_table VALUES(name_type('Marilyn','Monroe','MM')); END; CREATE TABLE department (dept_name varchar2(20), manager emp_typ, location VARCHAR2(20)); BEGIN INSERT INTO department VALUES('Education',emp_typ(7788,'John','Deer',..),.., 'Seattle',...); END;

UPDATE na tabeli obiektowej BEGIN UPDATE name_table p SET p.l_name = 'Janusz' WHERE p.l_name = 'Jan'; END; Z użyciem konstruktora typu obiektowego: BEGIN UPDATE name_table p SET p = name_type('Janusz','Kowalski','JK') WHERE p.l_name = 'Jan'; END; Brak hermetyzacji

DELETE na tabeli obiektowej BEGIN DELETE FROM name_table p WHERE p.l_name = 'Janusz'; END;

Funkcja VALUE – wartością obiekt SELECT VALUE(p) FROM person_obj_table p; Można ograniczyć do obiektów z podtypu: SELECT VALUE(p) FROM person_obj_table p WHERE VALUE(p) IS OF (part_time_student_type); -- lub SELECT VALUE(p) FROM person_obj_table p WHERE VALUE(p) IS OF (ONLY part_time_student_type); Można użyć do UPDATE: UPDATE person_obj_table p SET VALUE(p) = person_type(12, 'Bob Jones', '1-800-555-1243') WHERE p.idno = 12; Reprezentuje obiekt zapisany w tabeli obiektowej

Tabela relacyjna CREATE TABLE Emp1(    Empno NUMBER PRIMARY KEY,    Name Name_type,   -- kolumna typu obiektowego    Sal NUMBER,    Kier REFERENCES Emp1);

OID, REF Każdy obiekt wierszowy jest jednoznacznie identyfikowany przez swój systemowy, obiektowy identyfikator OID, 16 bajtowy – stanowiący dodatkową, indeksowaną, jednoznaczną kolumnę w tabeli obiektowej (opcja OBJECT IDENTIFIER IS SYSTEM GENERATED w CREATE TABLE – opcja domyślna). Gdy istnieje klucz główny, można jego wartości użyć jako OID (opcja OBJECT IDENTIFIER IS PRIMARY KEY w CREATE TABLE). Referencja REF – logiczny wskaźnik do obiektu wierszowego konstruowany z OID obiektu i metadanych. Dotyczy składowanych obiektów

Typ referencyjny CREATE TYPE Dept_Type AS OBJECT( Name VARCHAR2(10), Loc VARCHAR2(50)); CREATE TYPE Emp_Type AS OBJECT( Name VARCHAR2(20), Sal Number, Dept_ref REF Dept_Type ); CREATE TABLE Obj_Emp OF Emp_Type (Dept_ref SCOPE IS Obj_Dept); CREATE TABLE Obj_Dept OF Dept_Type; CREATE TABLE Rel_emp( Id NUMBER PRIMARY KEY, Name VARCHAR2(20), Sal Number, Dept_ref REF Dept_Type SCOPE IS Obj_Dept); Zamiast klucza obcego referencja

Użycie referencji SELECT o.name, o.Dept_Ref.name FROM obj_emp o; NAME DEPT_REF.NAME -------------------- ------------------------- KOWALSKI KADRY

Użycie referencji w kodzie PL/SQL DECLARE x REF Dept_Type; BEGIN    SELECT REF(o) INTO x FROM obj_dept o WHERE o.name='KADRY';    INSERT INTO obj_emp VALUES('KOWALSKI',2000,x); END; Operatory: REF(o) – referencja do obiektu o, DEREF(x) – obiekt o referencji x.

Tworzenie tabeli obiektowej z obiektami różnych podtypów CREATE TABLE person_obj_table OF person_type; INSERT INTO person_obj_table VALUES (person_type(12, 'Bob Jones', '111-555-121')); INSERT INTO person_obj_table VALUES (student_type(5, 'Joe Lan', ‘6555-131', 12, 'HISTORY')); INSERT INTO person_obj_table VALUES (employee_type(55, 'Jane Smith', ‘6555-776', 100, 'Jennifer Nelson')); INSERT INTO person_obj_table VALUES (part_time_student_type(52, 'Kim Patel', '1555-1232', 14, 'PHYSICS', 20));

Kolekcje Atrybut typu obiektowego lub kolumna tabeli może być typu kolekcji: 1. VARRAY – typ tablicy jednowymiarowej (jak wektor) o ustalonym maksymalnym rozmiarze; 2. TABLE – typ tabeli zagnieżdżonej o nie ustalonym maksymalnym rozmiarze.

Przykład CREATE TYPE Projekt AS OBJECT ( Num_proj NUMBER(3), Tytuł VARCHAR2(35), Koszt NUMBER(7,2)); CREATE TYPE Lista AS VARRAY(3) OF Projekt; CREATE TABLE Wydziały ( Id_wydz NUMBER(2), Nazwa VARCHAR2(15), Budżet NUMBER(11,2), Projekty Lista);

Przykład c.d. INSERT INTO Wydziały VALUES(1,'Informatyka',100000, Lista(Projekt(1,'Analiza',123), Projekt(2,'Projekt',456))); SELECT w.Projekty FROM Wydziały w WHERE w.Nazwa = ‘Informatyka’; Projekty ------------------------------------------------------------------------------- LISTA(PROJEKT(1,'Analiza',123),PROJEKT(2,'Projekt',456))

Kolekcje w PL/SQL CREATE OR REPLACE PROCEDURE Wypisz AS    lis Lista; BEGIN    FOR z IN (SELECT * FROM Wydzialy) LOOP       DBMS_OUTPUT.Put_line('Proj. Wydziału: '||z.Nazwa);       lis:=z.Projekty;       FOR i IN 1..lis.Count LOOP  DBMS_OUTPUT.Put_line(lis(i).Num_proj||' '||lis(i).Tytul);       END LOOP;    END LOOP; END; Dostęp do elementów kolekcji

Cykliczność powiązań CREATE TYPE Dept_Type; -- niepełna specyfikacja typu Dept_Type CREATE TYPE Emp_Type AS OBJECT(    Name VARCHAR2(20),    Sal NUMBER,    Dept_ref REF Dept_Type);  CREATE TYPE Pracownicy AS VARRAY(100) OF REF Emp_Type;

Cykliczność powiązań – c.d. CREATE TYPE Dept_Type  -- powtórna, pełna specyfikacja typu Dept_Type AS OBJECT(    Name VARCHAR2(10),    Loc VARCHAR2(50),    Kadra Pracownicy); CREATE TABLE Obj_Dept OF Dept_Type; CREATE TABLE Obj_Emp OF Emp_Type (Dept_ref SCOPE IS Obj_Dept); Bez konstrukcji klucz główny-klucz obcy można tworzyc odpowiadające im powiązania wskaźnikowe

Przykład tabeli zagnieżdżonej CREATE TYPE people_type AS TABLE OF person_type; CREATE TABLE people_tab ( group_no NUMBER, people_column people_type ) NESTED TABLE people_column STORE AS people_column_nt; -- można tworzyć indeksy na tabeli people_column_nt -- można też utworzyć typ obiektowy z atrybutem typu tabeli zagn. INSERT INTO people_tab VALUES ( 100, people_type( person_type(1, 'John Smith', '1-800-555-1212'), person_type(2, 'Diane Smith', NULL))); Dostęp do tabeli zagnieżdżonej jest przez tabelę, której jest ona częścią. Domyślny konstruktor tabeli zagnieżdżonej

Składowanie obiektów Każdy obiektowy typ danych określa drzewo, w którego liściach znajdują się: atrybuty prostych typów danych jak NUMBER, VARCHAR2 lub REF; atrybuty typów kolekcji; Atrybuty typów obiektowych rozwijają się w poddrzewa odpowiadające ich typom, jak również w poddrzewa wszystkich podtypów ich typów. Tabela obiektowa jest reprezentowana przez tabelę relacyjną, której kolumny odpowiadają atrybutom tego drzewa plus kolumny odpowiadające atrybutom drzew wszystkich podtypów danego typu.

Składowanie obiektów Oracle dodaje dodatkowe kolumny do tworzonej tabeli relacyjnej: dla generowanego przez system OID obiektu; dla każdego reprezentowanego typu obiektowego – czy NULL (kolumna: TRUE, FALSE); dla każdego reprezentowanego typu posiadającego podtypy kolumnę określającą podtyp aktualnego obiektu (typeid). VARRAY jest zapisywane jako pojedyncza wartość BLOB (jeśli się zmieści w wierszu w bloku na dysku to INLINE). Dla kolumny typu tabeli zagnieżdżonej jest określona jedna tabela relacyjna z wierszami wszystkich tabel zagnieżdżonych zapisywanej w tej kolumnie.

Przykład CREATE TYPE Person AS OBJECT ( first VARCHAR2(50), last VARCHAR2(50)) NOT FINAL; CREATE TYPE Emp UNDER Person ( salary NUMBER) FINAL; CREATE TYPE Stud UNDER Person ( StudId NUMBER) FINAL; CREATE TABLE Osoby OF Person; Oracle reprezentuje wewnętrznie tabelę Osoby przez tabelę: OsobyRel (OID, CzyPustyObiekt, TypObiektu, first, last, salary, StudId)

Perspektywy obiektowe Alternatywnie, można samemu zdefiniować relacyjną bazę danych jako podstawę składowania zawartości tabel obiektowych i udostępniać ją jako obiektową za pomocą perspektyw obiektowych. Zdefiniowanie wymaganych typów obiektowych w oparciu o atrybuty odpowiadające istniejącym kolumnom tabel relacyjnych. Zdefiniowanie perspektyw obiektowych w postaci zapytań określających jak wydobywać dane z tabel relacyjnych. Określenie jednoznacznych identyfikatorów umożliwiających tworzenie wskaźników do obiektów w perspektywie (np. istniejący klucz główny). W przypadku złożonej perspektywy można użyć wyzwalaczy INSTEAD OF do określenia sposobu modyfikacji danych w perspektywie obiektowej. Aplikacje mogą działać na perspektywach obiektowych tak jakby to były tabele obiektowe. Albo korzysta się z reprezentacji systemowej tabel obiektowych (jako tabel relacyjnych) albo samemu się definiuje te reprezentacje. Czyli poprzez tabele relacyjne można określić składowanie tabel obiektowych Operacje biznesowe i więzy spójności definiowane na poziomie obiektowym.

Przykład 1 CREATE TABLE emp_table (empnum NUMBER (5), ename VARCHAR2 (20), salary NUMBER (9,2), job VARCHAR2 (20)); CREATE TYPE employee_t AS OBJECT (empno NUMBER (5), ename VARCHAR2 (20), salary NUMBER (9,2), job VARCHAR2 (20)); CREATE VIEW emp_view OF employee_t WITH OBJECT IDENTIFIER (empno) AS SELECT e.empnum, e.ename, e.salary, e.job FROM emp_table e; Tworzenie obiektowego poziomu zewnętrznego bazy danych

Przykład 2: REFERENCJE w perspektywie obiektowej CREATE TYPE dept_t AS OBJECT ( deptno NUMBER, deptname VARCHAR2(20), address address_t); CREATE VIEW dept_view OF dept_t WITH OBJECT IDENTIFIER (deptno) AS SELECT d.deptno, d.deptname, address_t(d.deptstreet,d.deptcity,d.deptstate,d.deptzip) AS deptaddr FROM Dept d; CREATE TYPE emp_t AS OBJECT ( empno NUMBER, ename VARCHAR2(20), salary NUMBER, deptref REF dept_t); CREATE OR REPLACE VIEW emp_view OF emp_t WITH OBJECT IDENTIFIER(empno) AS SELECT e.empno, e.empname, e.salary, MAKE_REF(dept_view, e.deptno) FROM Emp e; CREATE TABLE dept ( deptno NUMBER PRIMARY KEY, deptname VARCHAR2(20), deptstreet VARCHAR2(20), deptcity VARCHAR2(10), deptstate CHAR(2), deptzip VARCHAR2(10)); CREATE TYPE address_t AS OBJECT ( street VARCHAR2(20), city VARCHAR2(10), state CHAR(2), zip VARCHAR2(10)); CREATE TYPE dept_t AS OBJECT ( deptno NUMBER, deptname VARCHAR2(20), address address_t ); SELECT e.empname, e.deptref.deptname FROM emp_view;

Podtabela (DB2, Postgres) CREATE TABLE demo_table ( id INTEGER PRIMARY KEY, txtdata VARCHAR(20)); CREATE TABLE demo_sub_table ( new_col VARCHAR(10)) UNDER demo_table; Wiersze wstawione do nad-tabeli demo_table, nie są widoczne przez select na pod-tabeli. Wiersze wstawione do pod-tabeli są widoczne przez select na nad-tabeli.

Duże obiekty LOB Atrybut typu obiektowego Kolumna w tabeli Wartość zmiennej w PL/SQL Foto (BLOB) Przepis (CLOB) Film (BFILE)

Anatomia obiektu LOB Lokalizator LOB Wartość LOB DECLARE lobloc BLOB; BEGIN SELECT col1 INTO lobloc FROM LOB_Table WHERE col2=123; END; Lokalizator LOB Wartość LOB

Wewnętrzne obiekty LOB Foto (BLOB) Przepis (CLOB)

Tabela z obiektami LOB SQL> CREATE TABLE employee 2 (emp_id NUMBER, 3 emp_name VARCHAR2(35), 4 resume CLOB, 5 picture BLOB);

Zewnętrzne obiekty LOB - zapisywane w pliku systemu operacyjnego Film (BFILE)

Obiekt bazy danych - katalog DIRECTORY lob_path = '/oracle/lob/' Film (BFILE)

DIRECTORY Fizyczny katalog jest tworzony pod systemem operacyjnym z uprawnieniami odczytu dla procesów Oracle. Pliki w tym katalogu nie mogą być ani zmieniane ani usuwane przez system Oracle. CREATE DIRECTORY Img AS ‘/oracle/lob’;

Posługiwanie się obiektami LOB Pakiet DBMS_LOB Wsparcie SQL - tabele, funkcje EMPTY_CLOB(), ... Katalog DIRECTORY, funkcja BFILENAME

Wstawianie obiektów LOB SQL> INSERT INTO employee VALUES 2> (7897,'Jan Kowalski','Znakomity aktor', NULL); SQL> INSERT INTO employee VALUES 2> (7898,'Marilyn Monroe', EMPTY_CLOB(), 3> BFILENAME('IMG','MARILYN.IMG')); Funkcja Bfilename('VIDEOS','J.IMG')) zwraca lokalizator dużego obiektu przechowywanego w pliku J.IMG. SQL> UPDATE employee SET resume = 2> (SELECT resume FROM employee 3> WHERE emp_name='Default') 4> WHERE emp_id = 4508;

Dopisywanie do obiektów LOB w PL/SQL DECLARE lobloc CLOB; -- lokalizator LOB text VARCHAR2(2000); amount NUMBER; offset INTEGER; BEGIN text := 'tekst do wpisania do CLOB'; SELECT resume INTO lobloc -- lokalizator LOB FROM employee WHERE emp_id = 5887 FOR UPDATE; offset := DBMS_LOB.GETLENGTH(lobloc) + 1; amount := length(text); DBMS_LOB.WRITE (lobloc, amount, offset, text); COMMIT; DBMS_OUTPUT.PUT_LINE('Wpisano ' || to_char(amount) ||' znaków'); END;

Usuwanie obiektów LOB Usunięcie wiersza z obiektem LOB: SQL>DELETE FROM person_tab 2 WHERE pname = 'Opie Griffith'; Usunięcie obiektu LOB w wierszu: SQL>UPDATE person_tab SET resume = EMPTY_CLOB() 2 WHERE pname = 'Laura Roshto'; SQL> DELETE FROM lob_table_1 WHERE key = 21; SQL> DROP lob_table_1; SQL> TRUNCATE lob_table_1; SQL> UPDATE lob_table_1 SET blob_col = EMPTY_BLOB() 2 WHERE key = 12;

Pakiet DBMS_LOB Modyfikacje Tylko-odczyt COMPARE FILEGETNAME INSTR GETLENGTH READ SUBSTR FILEEXISTS FILEISOPEN APPEND COPY ERASE TRIM WRITE FILECLOSE FILECLOSEALL FILEOPEN

READ i WRITE PROCEDURE READ ( lobsrc IN BFILE|BLOB|CLOB, amount IN OUT BINARY_INTEGER, offset IN INTEGER, buffer OUT RAW|VARCHAR2 ) PROCEDURE WRITE ( lobdst IN OUT BLOB|CLOB, amount IN OUT BINARY_INTEGER, offset IN INTEGER := 1, buffer IN RAW|VARCHAR2 ) -- RAW dla BLOB Obiekt BFILe można tylko wczytac. Nie można go zmieniac na poziomie serwera bazy danych (tylko w systemie plików).

Programowanie obiektowe w bazie danych - Java składowana w bazie danych Kod Javy może być zapisywany w bazie danych oraz może być realizowany na serwerze bazy danych tak jak kod języka SQL – w ramach tej samej sesji i tej samej transakcji. Obiekty Javy tworzone przy wykonywaniu kodu nie są składowane w bazie danych (tylko kod). Z kodu SQL lub PL/SQL można wywoływać tylko metody statyczne klas Javy. Z kodu Javy jest możliwość sięgania do bazy danych przez JDBC.

import java. sql. ; import java. io. ; import oracle. jdbc. driver import java.sql.*; import java.io.*; import oracle.jdbc.driver.*; public class GenericDrop { public static void dropIt (String object_type, String object_name)  throws SQLException {    // Połącz się z bazą danych Oracle używając sterownika JDBC    Connection conn = new OracleDriver().defaultConnection();    // Zbuduj instrukcję SQL    String sql = "DROP " + object_type + " " + object_name;    try {      Statement stmt = conn.createStatement();      stmt.executeUpdate(sql);      stmt.close();     }    catch (SQLException e) {System.err.println(e.getMessage());}  } }

Pierwsza metoda loadjava -user scott/tiger GenericDrop W SQL*Plus: CREATE PROCEDURE DropIt( obj_type VARCHAR2, obj_name VARCHAR2) AS LANGUAGE JAVA NAME 'GenericDrop.dropIt(java.lang.String, java.lang.String)'; CALL DropIt('TABLE', 'Emp');

Druga metoda CREATE AND COMPILE JAVA SOURCE NAMED "Hello" AS public class hello {    public static String world() {       return "Hello World"; } }; CREATE FUNCTION HelloWorld RETURN VARCHAR2 AS LANGUAGE JAVA NAME 'hello.world() return java.lang.string'; myString VARCHAR2; CALL HelloWorld() INTO :myString; PRINT myString;