Objektorientierte Datenbanken

Beim vorigen Mal: Der Object Data Standard der ODMG-Group

Kurz: ODMG-Standard Die POET-Implementierung FastObjects (t7)

Heute: Transaktionen, Sperren ODMG-OQL

Lernziele: Anwendung und Bewertung des ODMG-Standards

Ralf Möller, FH-Wedel

Literatur

Geschachtelte Transaktionen

Transaction txn = new Transaction(db);txn.begin(); ... txn.begin(); ... txn.begin(); ... txn.commit(); ... txn.abort(); ...txn.commit();

Automatische Synchronisation bei Abort

Normalerweise bleiben unter FastObjects-ODMG geänderte Objekte bei Transaktionsabbruch im Hauptspeicher bestehen

Synchronisation mit Hauptspeicherzustand auf Wunsch möglich:...Properties props = new Properties();props.setProperty("restoreOnAbort", true);txn.setProperties(props);...

Sperren (Locks)

Implizite Sperren Vom System vergeben bei Zugriff auf Objekte Bei lookup Anforderung einer Lesesperre Bei Änderung Anforderung einer Schreibsperre Ggf. wartet Kontrollfluß bis Sperre verfügbar

Explizite Sperren Transaction txn = new Transaction(); txn.lock(Object o, int level)

Level: Transaction.READ, Transaction.WRITE, Transaction.DELETE

Ggf. Ausnahmebehandlung falls Sperre nicht verfügbar

Beispiel

Database db = new Database();db.open( . . . );Transaction txn = new Transaction( db );Product product = (Product) db.lookup( "The Bug Zapper" );System.out.println( product.getTitle() );// The product object is now locked at the READ level.// This was done automatically by the database// manager.// If you want to ensure that the object is not being// read in another transaction, you can attempt to// obtain a WRITE level lock.try { txn.lock( product, Transaction.WRITE );}catch ( LockNotGrantedException e ) {// the lock was not granted; handle// this as you wish}

Anwendung: Implementierung von Assoziationen

Beispiel: Mitarbeiter leitet Projekt Sei "leitet" eine N:1-Beziehung ohne

Navigationsbeschränkung Einführung von Instanzvariablen "leitet"

mit Collection-Typ in der Klasse Mitarbeiter Einführung einer Instanzvariablen "geleitet-von" mit Typ

Mitarbeiter in der Klasse Projekt Aufgabe: Assoziierung von Mitarbeiter m1 und Projekt p1 Die Instanzen m1 und p1 müssen gesperrt werden, bis

wechselseitige Referenz etabliert Genauer: Die Kollektion als Wert der Instanzvariablen

"leitet" des Mitarbeiters m1 muß gesperrt werden

Anfragesprachen: ODMG-OQL

Ausdrücke für atomare Werte konstante Zahlen: 1 konstante Zeichenkette: "Charly Brown" konstantes Zeichen: 'A' benanntes Objekt: krd

Vergleiche 1 = 3 "Charly Brown" < "Pig Pen" 'A' != 'a'

Operationen auf Zeichenketten

Konkatenation: + (oder ||)Elementtest: char in string Elementzugriff: string [ integer ]Teilzeichenkette: string [ integer : integer ]Länge einer Zeichenkette: count( string )Wildcard-Vergleich: string like pattern,

Muster (pattern) kann * enthalten (steht für beliebige Teilzeichenkette)

Anfragen für Objekte

Attributzugriff: object . attribute-name (auch ->)

Methodenaufruf: object . method-name [param] param = ( [ parameter-name (, parameter-name)* ] )

Typanpassung: ( class-name ) objectObjektkonstruktion: class-name ( [ attributes ] )

attributes = att-name : att-value (, att-name : att-value )*

is_defined( object-query ) is_undefined( object-query )

Anfragen für Tupel

Attributzugriff: tuple . attribute-nameTupelkonstruktion:

struct (att-name : att-value (, att-name : att-value)* )

Beispiele: struct(name: "Bond", firstname: "James") struct(name: p.name, firstname: p.firstname).name

Anfragen für Kollektionen

Elementzählung: count( collection ) Elementtest: value in collection Elementextraktion: element( collection )

Parameter collection muß einelementig sein Vergleich: =, != Eliminierung von Duplikaten: distinct( collection ) Einflachung: flatten( collection ) Quantoren: (for all | exists) variable

in collection : condition Aggregation: aggregate( collection )

aggregate = max, min, avg, sum

Anfragen für geordnete Kollektionen

Listenkonstruktion: list ( [ value (, value )* ] ) list ( [ value (.. value )* ] )

Arraykonstruktion: array ( [ value (, value )* ] ) array ( [ value (.. value )* ] )

Elementextraktion: first( list-val ), last( list-val ) list-val [ integer ]

Teillistenbildung: list-val [ integer : integer ]Konkatenation: +Konversion: listtoset( list-val )

Anfragen für ungeordnete Kollektionen

Mengenkonstruktion: set ( [ value (, value)* ] )

Multimengenkonstr.: bag ( [ value (, value)* ] )

Sonderform für Gruppierung: partitionOperationen:

Vereinigung: union Mengendifferenz: except Schnitt: difference

Tests: < | <= | > | >=

Typen

Zugriff auf Kollektionen und deren ElementeIn Java: Elemente vom Typ "Object"Cast-Operation notwendigMöglich: Deklaration von Typen in der

Enhancement-Optionsdatei ptj.optSchlußfolgerungen über Typen

Beispiel: flatten(set(bag(T))) = flatten(bag(list(T))) = flatten(list(bag(T))) = bag(T)

Boolesche Ausdrücke

Negation: notKonjunktion: and, andthen (Reihenfolge!)Disjunktion: or, orelse (Reihenfolge!)

Select-From-Where-Anfragen

select queryfrom var_def (, var_def )*[ where query ][ group by name: query (, name: query )* [ having (query (, query)* ) ]][ order by query [ asc | desc ] (, query [ asc | desc ])*

var_def = extent | var in extent | extent [as] var

Beispiel (1)

select a from a in AuthorExtentwhere exists p in a.publication: count(p.keywords) > 10

select p.publkeyfrom p in flatten(select a.publications from Authorextent a where a.name like "G*")

element(select a from a in Authorextent where a.name = "Dittrich")

Beispiel (2)

max( select p.accesses from p in PublicationExtent)

select author1: a, author2: b, publication: pfrom PublicationsExtent p, a in p.getAuthors(), b in p.getAuthors()where a.name < b.name

Beispiel (3)

select aucount, kwcount, partitionfrom publ in PublicationExtentgroup by aucount: acount(publ.getAuthors()), kwcount: count(publ.keywords)having count(partition) > 1

Ergebnistyp:set(struct(aucount: integer, kwcount: integer, partition: bag(struct(publ: Publication))))

Zusammenfassung, Kernpunkte

Geschachtelte TransaktionenSelbstverwaltete SperrenObject Query Language

Was kommt beim nächsten Mal?

Objektrelationale Datenbanken