diff --git a/WEGA/contrib/ingres/dbs/ing_src/teil2/amx b/WEGA/contrib/ingres/dbs/ing_src/teil2/amx new file mode 100644 index 0000000..19c1ee6 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/ing_src/teil2/amx @@ -0,0 +1,1086 @@ +.ds RH \f3AMX\f1 +.ds CH - % - +.ds LH Anwendung +.ds RF \f3UNIX\f1 +.bp +.NH 2 +.ft B +AMX ** +.ft R +.LP +.sp 10 +.NH 3 +.ft B +Einleitung +.ft R +.LP +AMX (Access Method - an eXtended interface) ist ein +Werkzeug, das direkt auf die \*(yy\ Zugriffsmethoden +abbildet. Es ist leicht erlernbar, einfach anzuwenden und +erzeugt laufzeiteffektive Programme. Gegen\o'u"'ber dem +Datenbanksystem \*(yy\ bzw. der EQUEL Komponente sind AMX-Programme +bedeutend schneller. Mit AMX k\o'o"'nnen +sowohl rekursive Zugriffe zu Daten programmiert, als auch +Recherchen mit \o'A"'nderungen frei gemischt und +Abfragen implementiert werden, die die M\o'a"'chtigkeit +der relationalen Abfragesprachen \o'u"'bersteigen (Baum-, +St\o'u"'cklistenverarbeitung usw.). +.LP +AMX baut auf dem \*(yy\ System auf. Es ist m\o'o"'glich mit +\*(yy\ erstellte Daten mit AMX weiterzuverarbeiten und +umgekehrt. Dieser komplexe Ansatz gestattet zwischen AMX, +EQUEL und dem Datenbanksystem \*(yy\ frei zu wechseln. +.NH 3 +.ft B +Entwurf +.ft R +.LP +AMX ist eine Datenbanksprache, die in eine h\o'o"'here +Programmier\%sprache eingebettet ist. Als Einbettungsstrategie +bietet sich einer der vier klassischen Ans\o'a"'tze an: +.IP (1) +prozedurale Einbettung in die h\o'o"'here +Program\%miersprache \o'u"'ber eine call-Schnittstelle: +.DS C +call database("database_action as string"); +.DE +Die Datenbankaktion wird zur Laufzeit interpretiert, +eine Modifikation des \o'U"'bersetzers der h\o'o"'heren +Programmiersprache entf\o'a"'llt. Ein besonderes Problem +ist die Verwendung gemeinsamer Variablen und die +Pr\o'u"'fung der Zul\o'a"'ssigkeit der Datenbankaktionen. +z.B: SYSTEM-R, ADABAS, IMS +.IP (2) +einfache Erweiterungen der h\o'o"'heren +Programmiersprache um Elemente der Datenbanksprache +.IP +Eine Modifikation des \o'U"'bersetzers der h\o'o"'heren Pro- +grammiersprache ist notwendig, auch wenn der Aufwand +durch Angleichung der Syntax der Datenbanksprache an +die der h\o'o"'heren Programmiersprache minimiert werden +kann. Die Zul\o'a"'ssigkeit der Datenbankaktionen kann +bei diesem Ansatz zur \o'U"'bersetzungszeit \o'u"'berpr\o'u"'ft +werden. +.br +z.B: COBOL-DML des DBTG Netzwerkdatenmodells +.IP (3) +syntaktische Erweiterung der h\o'o"'heren +Programmiersprache um Elemente der Datenbanksprache ohne +Modifikation des \o'U"'bersetzers der h\o'o"'heren +Programmiersprache +.IP +Die Datenbankaktionen werden in dem +Anwendungsprogramm durch ein besonderes Pr\o'a"'fixsymbol +gekennzeichnet, die durch einen zu konstruierenden +Vor\o'u"'bersetzer (Preprozessor) syntaktisch und +semantisch \o'u"'berpr\o'u"'ft und in Prozeduraufrufe der +h\o'o"'heren Programmiersprache \o'u"'bersetzt werden. +Nachteilig erscheint die Verwendung zweier Semantiken +durch den Benutzer. +.br +z.B: EQUEL/INGRES +.IP (4) +Datenbankprogrammiersprache: Erweiterung einer +h\o'o"'heren Programmiersprache um das Datenmodell einer +Datenbanksprache +.IP +Dieser Ansatz erfordert eine grunds\o'a"'tzliche +Modifikation bzw. Neukonstruktion des \o'U"'bersetzers der +h\o'o"'heren Programmiersprache. +.br +z.B: MODULA-R +.LP +F\o'u"'r AMX wurde der 3. Ansatz gew\o'a"'hlt. Er garantiert mit +einem geringen Implementierungsaufwand die Realisierung +aller Forderungen, die an eine Einbettung zu stellen sind. +Der Preprozessor ist in YACC und C implementiert und damit +\*(xx\ portabel. Die Verwendung von YACC als Werkzeug zur +Compilergenerierung bringt einige Probleme in der Meldung +von erkannten Fehlern mit sich. Nach Erkennung eines +Fehlers wird die \o'U"'bersetzung erst nach drei als richtig +erkannten syntaktischen Einheiten (Token, Morpheme) +fortgesetzt, so dass eine zweite \o'U"'bersetzung Fehler erzeugen +kann, die in der ersten nicht erzeugt wurden. Die zu jedem +Fehler mit ausgegebene Zeilennummer ist nicht immer exakt. +Sie kann sich auf eine der vorherigen Zeilen beziehen, wenn +der Fehler am Zeilenende erkannt wurde. YACC liest immer +eine syntaktische Einheit voraus, wird ein Fehler +festgestellt, ist in dem oben genannten Fall der Zeilenz\o'a"'hler +aber schon um eins (oder mehr, bei Zeilen ohne syntaktische +Einheiten) hochgez\o'a"'hlt. Bei syntaktischen Fehlern, die +YACC selbst generiert, ist eine Angabe der Fehlerursache +\o'a"'usserst schwierig. Aufgrund der einfachen Syntax von AMX +wurde auf eine detaillierte Fehlererkennung verzichtet und +der Anwender muss den erzeugten Fehler +.DS C +"syntax error" +.DE +selbst deuten. +.LP +Ein Datenbanksystem l\o'a"'sst sich in zwei grosse Komplexe +gliedern, den logischen Datenbankprozessor +.ft B +(LDBP) +.ft R +und den +physischen Datenbankprozessor +.ft B +(PDBP). +.ft R +Der LDBP ist +zust\o'a"'ndig f\o'u"'r das \o'U"'bersetzen bzw. +Parsen +.ft B +(P) +.ft R +der Datenbank\%aktion +und deren Optimierung +.ft B +(O). +.ft R +Der PDBP erh\o'a"'lt eine Folge von +Auftr\o'a"'gen (query evaluation plan - +.ft B +QEP +.ft R +) zur Abarbeitung der +Datenbankaktion unter Einbeziehung der Daten der Datenbank. +Unter dem Gesichtspunkt dieser Klassifizierung l\o'a"'sst sich +die Einbettungsstrategie wie folgt verfeinern: +.DS I + +---------+----------+ + | L D P B | | + +------+------+ PDBP | + | P | O | | + +------+------+------+ + | | | | + a |####################| + | | | | + b |======|#############| + | | | | + c |=============|######| + | | | | + d |====================| + | | | | + +------+------+------+ + LEGENDE + #: zur Laufzeit + =: zur \o'U"'bersetzungszeit +.DE +.IP a- +Die \o'U"'bersetzung, Optimierung und interpretative +Abarbeitung der Datenbankaktionen zur Laufzeit ist +die nat\o'u"'rliche Form der zum Datenbanksystem +geh\o'o"'rigen Abfragesprache. Sie ist geeignet f\o'u"'r +ad hoc-Abfragen. +.IP b- +Die \o'U"'bersetzung ohne Optimierung ist geeignet f\o'u"'r +st\o'a"'ndig wiederkehrende datenunabh\o'a"'ngige +Datenbankaktionen. +.IP c- +Die \o'U"'bersetzung mit Optimierung ist geeignet f\o'u"'r +st\o'a"'ndig wiederkehrende datenabh\o'a"'ngige +Datenbankaktionen, da der QEP fest determiniert ist. +.IP d- +Die Umgehung des PDBP erfordert vom \o'U"'bersetzer die +Konstruktion nicht nur des QEP sondern auch eines +speziellen PDBP f\o'u"'r die konkreten Datenbankaktionen +in Form eines ausf\o'u"'hrbaren Programms. Diese +Variante ist f\o'u"'r schnelle Anwendungen (Erfassung und +\o'A"'nderung) bzw. Massendatenverarbeitung geeignet. +.LP +F\o'u"'r AMX wurde die Variante d) gew\o'a"'hlt. Eine wesentliche +Erh\o'o"'hung der Abarbeitungsgeschwindigkeit f\o'u"'r +Datenbankaktionen in AMX gegen\o'u"'ber \*(yy\ ist eingetreten, die +gew\o'a"'hlte Variante hat jedoch auch entscheidende Nachteile. +Die erzeugten AMX Programme sind abh\o'a"'ngig von der Struktur +der Datenbank, alle verwendeten datenbankspezifischen Namen +(der Datenbank, der Relationen und der Dom\o'a"'nen) m\o'u"'ssen zur +\o'U"'bersetzungszeit bekannt also konstant sein. +Beispielsweise kann mit AMX kein allgemeines Druckprogramm +konstruiert bzw. neue Relationen erzeugt werden. Dass ein AMX +Programm keine Relationen erzeugen kann, ist aus Anwendersicht +eine schwer einsehbare Tatsache. Der AMX Compiler holt sich +alle Informationen zu den Relationen und Dom\o'a"'nen aus den +Systemkatalogen der Datenbank und entlastet somit den +Anwender von der Angabe dieser Details und den Fehlern, die an +dieser Stelle gemacht werden k\o'o"'nnen. Eventuell ben\o'o"'tigte +permanente oder tempor\o'a"'re Relationen m\o'u"'ssen vor der +\o'U"'bersetzung des AMX Programms mit dem \*(yy\ System erzeugt +werden (siehe CREATE(QUEL)). Durch diesen Ansatz ist eine +weitgehende Quelltextunabh\o'a"'ngigkeit von der Struktur der +Datenbank gesichert, eine \o'A"'nderung der Speicherstruktur +einer Relation erfordert keine \o'A"'nderung des AMX +Quellprogramms, wohl aber dessen neue \o'U"'bersetzung. +.LP +F\o'u"'r die vorliegende Version +von AMX gelten einige Einschr\o'a"'nkungen: +.IP - +Das Pufferschema der \*(yy\ Zugriffsmethoden +ordnet jeder Relation maximal einen Puffer zu. F\o'u"'r +die rekursive Verarbeitung einer Relation ist ein +solcher Ansatz ungeeignet, da jede neue Rekursion den +Puffer \o'u"'berschreibt und ein st\o'a"'ndiges Nachlesen des +alten Pufferinhaltes bei Verlassen der Rekursion +erforderlich ist. Die Zuordnung von maximal einem +Puffer zu einer Relation ist ein Entwurfsprinzip der +internen Ebene des Datenbankystems \*(yy\, eine +\o'A"'nderung des Pufferschemas ist nicht angebracht. +.IP - +Beschr\o'a"'nkung der Variablentypen f\o'u"'r den Austausch +von Daten zwischen der Datenbanksprache und der +h\o'o"'heren Programmiersprache. +.IP - +Die verwendeten Relationen d\o'u"'rfen keine Sichten +(views) sein und d\o'u"'rfen keine definierten +In\%te\%gri\%t\o'a"'ts\%be\%din\%gun\%gen bzw. anderweitig vergebene Zugriffsrechte +besitzen. +.IP - +Konvertierungen zwischen numerischen und +Zeichenkettenwerten (und umgekehrt) werden nicht unterst\o'u"'tzt. +.IP - +Numerische Konvertierungen erfolgen ohne Unter- bzw. +\o'U"'berlaufkontrolle. +.IP - +Vergleiche von Zeichenkettenwerten zwischen Dom\o'a"'nen +und Variablen werden in der L\o'a"'nge der Dom\o'a"'ne +ausgef\o'u"'hrt, z.B. liefert der Variablenwert "Automat" +den Wert "Auto" f\o'u"'r die Datenbankaktion, wenn die +zugeh\o'o"'rige Dom\o'a"'ne den \*(yy\ Typ "c4" hat. +.LP +AMX garantiert die Integrit\o'a"'t der Datenbank, d.h. die +Konsistenz der Systemkataloge und der Indizes. Bei der +Zugriffs\%pfadoptimierung werden die vorhandenen Indizes voll +herangezogen. \o'A"'nderungen sind nur in Nutzerrelationen +ge\%stattet, die Systemkataloge und Indizes werden durch AMX +aktualisiert. +.LP +Es ist geplant, einen SORT-Operator f\o'u"'r die +Datenbankaktionen bereitzustellen, um in Recherchen doppelte Tupel +auszuschliessen und eine Hilfe f\o'u"'r die Verbindung zweier +Relationen (join) zu geben. +.NH 3 +.ft B +Umgebung +.ft R +.LP +AMX ist an die \*(xx\ Programmiersprache C gebunden, es +erzeugt aus dem Input ein g\o'u"'ltiges C-Programm, das mit dem +C-Compiler weiter verarbeitet werden muss. Es besteht aus +einem Compiler (Preprozessor) und einer Laufzeitbibliothek +"liba.a". \o'A"'hnlich EQUEL werden AMX Anweisungen durch die +Kennzeichnung von zwei Nummernzeichen "##" am Zeilenanfang +in das C-Programm eingebettet. Der AMX Compiler verarbeitet +nur solche gekennzeichneten Zeilen, aufgrund dieser +Arbeitsweise is es notwendig, die in AMX Anweisungen verwendeteten +C-Variablen mit dem Kennzeichen zu deklarieren. In der +vorliegenden Version werden C-Variable vom Typ: +.DS I + - short + - int + - long + - float + - double + - char * + - char [] +.DE +unterst\o'u"'tzt. Jede Variable ist global zu deklarieren. +.LP +Im AMX Programm muss die Eintrittsfunktion "amx()" +benannt werden, da der AMX Compiler ein "main()" generiert, +um die notwendigen Datenbankinitialisierungen vornehmen zu +k\o'o"'nnen. +.LP +AMX generiert Code f\o'u"'r die Schnittstelle des internen +Datenbankschemas von \*(yy\, d.h. von Seiten des +C-Programms sind einige Konventionen dieser Schnittstelle +einzuhalten. Alle ausf\o'u"'hrbaren Programme m\o'u"'ssen vom \*(yy\ +Superuser angeeignet (owner, group) und mit dem Mode "6xxx" +.DS I + - "4000" set user id on execution + - "2000" set group id on execution +.DE +versehen sein, um die Datenbankfiles lesen und schreiben zu +k\o'o"'nnen. Eine weitere Besonderheit ist das \o'A"'ndern des +aktuellen Verzeichnisses (current directory) in das +Verzeichnis der Datenbank zur Startzeit des AMX Programms. Zur +Laufzeit ist es nicht gestattet, das aktuelle Verzeichnis zu +\o'a"'ndern! Daher sollten alle programmspezifischen Files +absolut von der root aus angegeben werden (z.B: "/dir/file", +siehe auch COPY(QUEL)). +.LP +Die Verwendung der C-Bibliotheksfunktionen +.DS I + - setjmp() + - longjmp() +.DE +zur Realisierung nichtlokaler Spr\o'u"'nge (siehe \*(xx\ Manual +SETJMP(3)) sollte vermieden werden. +.LP +Der AMX Compiler hat noch kein eigenes +Relationssperrkonzept, er sperrt die Datenbank f\o'u"'r die parallele +Verwendung w\o'a"'hrend der gesamten Zeit deren Nutzung durch +das AMX Programm, d.h.: +.IP 1- +zur Startzeit darf die Datenbank nicht in Benutzung +sein und +.IP 2- +zur Laufzeit kann niemand die Datenbank verwenden. +.LP +Das exklusive Sperren der Datenbank erfolgt \o'u"'ber das +concurrency-control-Schema von \*(yy\. +.LP +Durch die Laufzeitbibliothek werden eine Reihe von Objekten +definiert, die alle mit "AA" beginnen. Durch den +Anwendungsprogrammierer ist zu gew\o'a"'hrleisten, dass diese Objekte +nicht \o'u"'berdefiniert werden. Er sollte Namen, die mit "AA" +beginnen, generell vermeiden. Da die interne Ebene des +Datenbanksystems \*(yy\ in das AMX Programm gelinkt +wird, sind weitere Objekte mit einer festen Bedeutung +definiert, die im AMX Programm nicht verwendet werden +d\o'u"'rfen. Eine vollst\o'a"'ndige Liste der Namen befindet sich +im Anhang des Kapitel. F\o'u"'r eine n\o'a"'chste AMX Version +ist zumindest die \o'U"'berpr\o'u"'fung der Verwendung von bereits +vergebenen Namen vorgesehen. +.NH 3 +.ft B +Compilation +.ft R +.LP +AMX Programmnamen m\o'u"'ssen mit ".x" beendet sein. Die +\o'U"'bersetzung erfolgt durch den Aufruf: +.DS C + % amx file.x +.DE +Als Flags sind die des C-Compilers m\o'o"'glich. Der AMX Compiler +hinterl\o'a"'sst sein Ergebnis im "file.o", das in +einfachster Form mit: +.DS C + % cc -n file.o -la -o file + oder + % cc -i file.o -la -o file +.DE +weiter verarbeitet wird. Durch die Angabe von "-la" wird +die AMX Laufzeitbibliothek "liba.a" herangezogen. Das AMX +Programm kann nun durch den Aufruf von: +.DS C + % file +.DE +abgearbeitet werden. +.LP +Eine gleichzeitige \o'U"'bersetzung mehrerer AMX Programme durch +einen Aufruf des AMX Compilers ist aus internen Gr\o'u"'nden +nicht zul\o'a"'ssig. +.LP +Eine separate Compilierung von AMX Moduln ist nicht +m\o'o"'glich, s\o'a"'mtliche Datenbankaktionen m\o'u"'ssen in einem +Programm zusammengefasst sein. Nat\o'u"'rlich k\o'o"'nnen zu dem +compilierten AMX Programm beliebige \*(xx\-Objektmodule +einzeln bzw. in Bibliotheken zugelinkt werden. +.NH 3 +.ft B +Begriffe +.ft R +.LP +AMX ist in das relationale Modell von \*(yy\ integriert. +Durch ein AMX Programm k\o'o"'nnen Daten einer \*(yy\ +Datenbank manipuliert werden. Eine Datenbank ist eine Menge von +Relationen. Die Anzahl der Relationen innerhalb einer +Datenbank ist unbegrenzt. Eine Relation ist eine Menge von +Dom\o'a"'nen und Tupel, sie hat einen Eigent\o'u"'mer (Besitzer). +.LP +Die Anzahl der Dom\o'a"'nen pro Relation ist auf 49 begrenzt. +Die maximale Tupell\o'a"'nge ist generierungsabh\o'a"'ngig und +schwankt zwischen 498 und 1010 Bytes. Eine Ausrichtung der +Dom\o'a"'nen auf bestimmte Adressen ist nicht zu beachten. +.DS I ++-------------------------+ +| Begriffsanalogien | ++--------+-------+--------+ +Relation | Tupel | Dom\o'a"'ne + Tabelle | Zeile | Spalte + Datei | Satz | Feld +---------+-------+--------- +.DE +Eine Dom\o'a"'ne besitzt einen Typ und eine L\o'a"'nge. Folgende +Kombinationen sind zul\o'a"'ssig: +.DS I +---------+---------- + Typ | L\o'a"'nge +---------+---------- + integer | 1 + | 2 + | 4 + float | 4 + | 8 + char | 1 .. 255 +---------+---------- +.DE +Innerhalb einer Datenbank muss ein Nutzer f\o'u"'r seine +Relationen unterschiedliche Namen verwenden. Die Namen der +Systemkataloge +.DS L + "relation" Verwaltung der Relationen + "attribute" Verwaltung der Dom\o'a"'nen + "indexes" Verwaltung der Indizes + "integrities" Verwaltung der definierten Integrit\o'a"'ten + "protect" Verwaltung der vergebenen Zugriffsrechte + "tree" Verwaltung der vor\o'u"'bersetzten Datenbank- + aktionen +.DE +sind als Relationenname gesperrt, ebenso die Namen der +Relationen des Datenbankeigent\o'u"'mers (Datenbankadministrator +- DBA). +.LP +Innerhalb einer Relation m\o'u"'ssen die Dom\o'a"'nennamen +eineindeutig sein. Alle Namen (Datenbank, Relationen, +Dom\o'a"'nen) sind maximal 12 Zeichen lang und bestehen aus den +Zeichen "[a-z_0-9]", wobei der Name nicht mit einer Ziffer +"[0-9]" beginnen darf. Der AMX Compiler konvertiert grosse +Buchstaben "[A-Z]" automatisch in kleine "[a-z]". +.LP +Jede Relation muss vor ihrer Verwendung er\o'o"'ffnet und kann +nach Beendigung der Verarbeitung geschlossen werden. Sie +besitzt eine Menge von Tupeln (tuplecount) als zugeh\o'o"'rige +Daten. Wir unterscheiden die Recherche nach einer Menge von +Tupeln (scan) und das \o'A"'ndern bzw. Einf\o'u"'gen eines einzelnen +Tupel. Die Recherche kann alle Daten der Relation umfassen +(full relation scan) oder durch Bedingungen eingeschr\o'a"'nkt +werden (limited scan). +.LP +Ein scan setzt sich aus den Komponenten +.IP - +Selektion = scan-Bedingung, +.IP - +Projektion = Auswahl der Dom\o'a"'nen, deren Werte f\o'u"'r +die Verarbeitung interessieren und +.IP - +Aktion = Verarbeitung, die f\o'u"'r jedes gefundene Tupel +angestossen wird, +.LP +zusammen. +.NH 3 +.ft B +Syntaktische Regeln +.ft R +.LP +.nf + | : Alternative. + + [ ] : wahlweiser Ausdruck, kann entfallen. + + { } : mindestens einmalige Wiederholung, + mehrere Elemente werden durch COMMA "," getrennt. + Ausnahme: { amx_stmt } wird nicht separiert. + +{A-Z_}: Schl\o'u"'sselw\o'o"'rter bzw. terminale Symbole: + \*(yy\ = "ing_db" + OPEN = "open" + CLOSE = "close" + TUPLECOUNT = "tuplecount" + APPEND = "append" + OVER = "over" + SCAN = "scan" + PRINT = "print" + DELETE = "delete" + REPLACE = "replace" + LPAREN = "(" + RPAREN = ")" + LBRACE = "{" + RBRACE = "}" + DOLLAR_SIGN = "$" + IS = "=" + | "==" + RELOP = IS + | "<" + | "<=" + | ">" + | ">=" + | "!=" +.fi +.LP +.nf +{a-z_} : Regelname bzw. nonterminale Symbole. + Mit "(n)" numerierte Regeln sind im Programm + frei verwendbar, die mit "{n}" nur innerhalb + eines scan-Statements. + Alle unterstrichenen Regeln sind nicht weiter + aufgel\o'o"'st und besitzen folgende Bedeutung: + xx = \*(yy\-Nutzercode f\o'u"'r das + alter-ego-Flag + no_of_bufs = Anzahl der zus\o'a"'tzlichen Puffer + f\o'u"'r die Zugriffsmethoden + database = Datenbankname + c_code = C-Statement + c_decl = Deklaration einer C-Variablen + rel = Relationsname + c_var = C-Variablenname + dom_name = Dom\o'a"'nenname bzw. Dom\o'a"'nennummer + const = int-Konstante + | long-Konstante + | double-Konstante + | "string"-Konstante +.fi +.LP +.NH 3 +.ft B +Grammatik +.ft R +.LP +.nf +( 1) program : ing_db { amx_stmt } + ; +( 2) ing_db : \*(yy\ flags database + ; -------- +( 3) flags : [ "-u user_name " ] [ " +no_of_bufs " ] + --------- ---------- + ; +( 4) amx_stmt : c_code + ------ +( 5) | c_decl + ------ +( 6) | OPEN rel + --- +( 7) | CLOSE rel + --- +( 8) | TUPLECOUNT rel c_var + --- ----- +( 9) | APPEND rel target + --- +(10) | [ OVER rel ] SCAN rel + --- --- +(11) [ { qual } ] + +(12) [ LPAREN { var_assign } RPAREN ] + +(13) LBRACE [ { amx_stmt } ] RBRACE + +(14) | PRINT LPAREN [ { dom } ] RPAREN + +(15) | DELETE + +(16) | REPLACE target + +(17) | APPEND target + ; +(18) target : LPAREN { dom_assign } RPAREN + ; +(19) dom_assign : dom IS value + ; +(20) dom : DOLLAR_SIGN dom_name + ; -------- +(21) value : c_var + ----- +(22) | const + ----- +(23) | dom + ; +(24) qual : dom RELOP value + ; +(25) var_assign : c_var IS dom +.fi +.LP +.NH 3 +.ft B +Sprachbeschreibung +.ft R +.LP +Die AMX Sprachbeschreibung orientiert sich an der +vereinfachten AMX Grammatik. +Kommentare sind innerhalb von AMX Statements in der C +\o'u"'blichen Notation zugelassen: +.DS C + ## . . . /* Kommentar */ . . . +.DE +.DS L +( 1) program : ing_db { amx_stmt } + ; +.DE +Ein AMX Programm besteht aus einem einleitenden ing_db- +Statement und einer beliebigen Menge von amx-Statements. +.DS L +( 2) ing_db : \*(yy\ flags database + ; -------- +.DE +Das ing_db-Statement adressiert die zu verarbeitende +Datenbank "database" und gestattet wahlweise die Angabe von +Flags. +.DS L +( 3) flags : [ "-uuser_name" ] [ "+no_of_bufs" ] + ; --------- ---------- +.DE +Das Flag -u"user_name" bewirkt, dass das AMX Programm mit den +Datenbankberechtigungen des \*(yy\ Nutzer "user_name" l\o'a"'uft. +Das Flag +"no_of_bufs" f\o'u"'gt "no_of_bufs"-Puffer in das +Pufferschema der \*(yy\ Zugriffsmethoden ein. +Normalerweise stehen nur 3 Puffer f\o'u"'r die Arbeit mit Relationen zur +Verf\o'u"'gung, wobei eine Relation maximal einen Puffer belegen +kann. Bei der parallelen Arbeit mit mehreren Relationen +(Indexrelationen m\o'u"'ssen mitgerechnet werden) sollte jeder +Relation ein eigener Puffer zugeordnet werden k\o'o"'nnen. Die +zus\o'a"'tzlichen Puffer werden im Nutzerstack angelegt. +.DS L +( 4) amx_stmt : c_code + ; ------ +.DE +Ein AMX Statement kann eine Menge von beliebigen +C-Statements sein. Die C-Statements werden nicht durch das +Kennzeichen "##" am Anfang der Zeile eingeleitet. +.DS L +( 5) amx_stmt : c_decl + ; ------ +.DE +C-Variable, die sowohl im AMX als auch im C-Programm +verwendet werden sollen, m\o'u"'ssen mit dem Kennzeichen "##" am +Anfang der Zeile deklariert werden. +.LP +Folgende Typen werden unterst\o'u"'tzt: +.DS I + - short + - int + - long + - float + - double + - char * + - char [] +.DE +Folgende Speicherklassen werden unterst\o'u"'tzt: +.DS I + - auto + - extern + - static +.DE +.DS L +( 6) amx_stmt : OPEN rel + ; --- +.DE +Das open-Statement er\o'o"'ffnet die Relation +.ft B +rel +.ft R +f\o'u"'r die +weitere Verarbeitung. Die Relation +.ft B +rel +.ft R +muss eine +Prim\o'a"'r bzw. Basisrelation sein, d.h. es ist nicht m\o'o"'glich, +explizit eine Indexrelation zu er\o'o"'ffnen. Durch das open- +Statement werden automatisch alle zur Relation geh\o'o"'rigen +Indizes miter\o'o"'ffnet. Die Relation +.ft B +rel +.ft R +darf kein view +sein und es d\o'u"'rfen keine integrity- bzw. protection- +constraints auf ihr definiert sein. Die Systemkataloge +.ft B +relation +.ft R +, +.ft B +attribute +.ft R +und +.ft B +indexes +.ft R +werden durch den Start +eines AMX Programms automatisch er\o'o"'ffnet. +.LP +Recherchen (scan-Statement) sind auf allen Relationen +zugelassen, d.h. auf Basis-, Indexrelationen und Katalogen. +\o'A"'nderungen und Einf\o'u"'gungen sind nur auf Basisrelationen +zul\o'a"'ssig, f\o'u"'r die das Programm die update-Erlaubnis hat. +.DS L +( 7) amx_stmt : CLOSE rel + ; --- +.DE +Das close-Statement schliesst die Relation +.ft B +rel +.ft R +f\o'u"'r die +weitere Verarbeitung. Es k\o'o"'nnen nur Relationen geschlossen +werden, die zuvor durch das open-Statement er\o'o"'ffnet wurden. +Die Beendigung eines Programms ( +.ft B +exit +.ft R +) schliesst +automatisch alle er\o'o"'ffneten Relationen und Kataloge. +.DS L +( 8) amx_stmt : TUPLECOUNT rel c_var + ; --- ----- +.DE +Das tuplecount-Statement weist der C-Variable +.ft B +c_var +.ft R +als Wert die Anzahl der Tupel der Relation +.ft B +rel +.ft R +zu. +.ft B +c_var +.ft R +muss ein numerischer Typ sein. Die Anzahl der Tupel einer +Relation ist die einzigste verf\o'u"'gbare variable +Kataloginformation f\o'u"'r das AMX Programm. Auf Umwegen kann so die +Anzahl der \o'A"'nderungen in einer Relation bestimmt werden: +.DS L + . . . + ## long old, new; + . . . + ## tuplecount rel old + { Neueinf\o'u"'gungen } + ## tuplecount rel new + printf("# of updates", new - old); + . . . +.DE +.DS L +( 9) amx_stmt : APPEND rel target + ; --- +.DE +Das append-Statement f\o'u"'gt ein neues Tupel in die Relation +.ft B +rel +.ft R +ein. Durch die Projektion +.ft B +target +.ft R +werden den +aufgef\o'u"'hrten Dom\o'a"'nen Werte zugewiesen. Alle nicht angebenen +Dom\o'a"'nen der Relation +.ft B +rel +.ft R +werden mit einem Nullwert +initialisiert, alle numerischen Dom\o'a"'nen bekommen den Wert 0 +und die Zeichenkettendom\o'a"'nen eine mit Leerzeichen gef\o'u"'llte +Zeichenkette zugewiesen. Eventuell vorhandene Indizes +werden automatisch aktualisiert. +.DS L +(18) target : LPAREN { dom_assign } RPAREN + ; +.DE +Die Projektion wird durch eine \o'o"'ffnende "(" und eine +schliessende runde Klammer ")" begrenzt. Sie enth\o'a"'lt eine +durch Kommas "," getrennte Aufz\o'a"'hlung von Zuweisungen +.ft B +dom_assign. +.ft R +Es muss mindestens einer Dom\o'a"'ne ein Wert +zugewiesen werden. +.DS L +(19) dom_assign : dom IS value + ; +.DE +Eine Zuweisung weist der Dom\o'a"'ne +.ft B +dom +.ft R +den Wert +.ft B +value +.ft R +zu. +Bei den Zuweisungen von numerischen zu numerischen Typen +werden die notwendigen Konvertierungen ohne \o'U"'berlauf- bzw. +Unterlaufkontrolle vorgenommen. Zuweisungen von numerischen +zu Zeichenkettenwerten und umgekehrt sind nicht zul\o'a"'ssig. +.DS L +(20) dom : DOLLAR_SIGN dom_name + ; -------- +.DE +Eine Dom\o'a"'ne wird durch das Kennzeichen "$" und ihren Namen +bzw. ihre Nummer (siehe Dom\o'a"'ne +.ft B +attid +.ft R +des Katalogs +.ft B +attribute +.ft R +) spezifiziert. Durch die explizite +Kennzeichnung von Dom\o'a"'nennamen durch das Zeichen "$" werden im +Gegensatz zu EQUEL Konflikte mit dem Namen von C-Variablen +vermieden. Die Referenzierung von Dom\o'a"'nen \o'u"'ber ihre +interne Nummer (Reihenfolge vom CREATE(QUEL)) kann sinnvoll +bei einer vektorisierten Verarbeitung sein. +.DS L +(21) value : c_var + ; ----- +.DE +Ein Wert kann der aktuelle Wert der C-Variablen +.ft B +c_var +.ft R +sein. +.DS L +(22) value : const + ; ----- +.DE +Ein Wert kann eine in C \o'u"'bliche Konstante +.ft B +const +.ft R +sein. +.DS L +(23) value : dom + ; +.DE +Ein Wert kann der aktuelle Wert der Dom\o'a"'ne +.ft B +dom +.ft R +sein. +Diese Form des Wertes setzt einen \o'u"'bergeordneten scan +voraus, aus dem der Wert f\o'u"'r die Dom\o'a"'ne +.ft B +dom +.ft R +geholt +werden kann. +.DS L +(10) amx_stmt : [ OVER over_rel ] SCAN scan_rel + -------- -------- +(11) Selektion [ { qual } ] + +(12) Projektion [ LPAREN { var_assign } RPAREN ] + +(13) Aktion LBRACE [ { amx_stmt } ] RBRACE + ; +.DE +Das scan-Statement ist das m\o'a"'chtigste AMX Statement, es +\o'u"'bernimmt die Zugriffspfadoptimierung und erm\o'o"'glicht eine +rekursive Verarbeitung, da innerhalb eines scans ein weiterer +scan aufgerufen werden kann. +.LP +Die over-Klausel (OVER over_rel) gestattet die Zuweisung des +Zugriffspfades \o'u"'ber die Relation +.ft B +over_rel +.ft R +f\o'u"'r den scan +und damit die Ausschaltung der Zugriffspfadoptimierung im +AMX Compiler. +.ft B +over_rel +.ft R +muss die zu scannende Relation +selbst oder ein Index von +.ft B +scan_rel +.ft R +sein. Ist +.ft B +over_rel +.ft R +ein Index und wird durch die Selektion +.ft B +qual +.ft R +keinem +Schl\o'u"'ssel von +.ft B +over_rel +.ft R +ein Wert zugewiesen, wird der +Zugriffspfad \o'u"'ber die Prim\o'a"'rrelation +.ft B +scan_rel +.ft R +gew\o'a"'hlt, da +ein +.ft B +full relation scan +.ft R +\o'u"'ber einen Index unsinning ist. +Die scan-Klausel (SCAN scan_rel) adressiert die zu scannende +Relation +.ft B +scan_rel. +.ft R +.NH 3 +.ft B +Selektion +.ft R +.LP +Der scan kann durch die Angabe einer Selektion +eingeschr\o'a"'nkt werden. Die Selektion ist eine Einschr\o'a"'nkung +des Wertebereichs einzelner (oder aller) Dom\o'a"'nen. Mehrere +Einschr\o'a"'nkungen werden durch Komma "," getrennt. Eine +Dom\o'a"'ne kann maximal zwei Einschr\o'a"'nkungen erfahren. Alle +zugewiesenen Bedingungen und Werte der angebenen +Einschr\o'a"'nkungen werden beim Einlauf in den scan gekellert, so +dass z.B. eine \o'A"'nderung des Wertes einer verwendeten C- +Variablen keinen Einfluss auf die Selektion hat. +.NH 3 +.ft B +Projektion +.ft R +.LP +Die Projektion ist wahlweise, d.h. sie kann entfallen. Die +Projektion wird durch eine \o'o"'ffnende "(" und eine +schliessende runde Klammer ")" begrenzt. Sie weist f\o'u"'r +jedes, entsprechend der Selektion gefundene Tupel, der +angebenen Menge von C-Variablen den aktuellen Wert der +zugeordneten Dom\o'a"'nen zu. Die einzelnen Zuweisungen werden +durch Komma "," getrennt. +.NH 3 +.ft B +Aktion +.ft R +.LP +Die Aktion wird durch eine \o'o"'ffnende "{" und eine +schliessende geschweifte Klammer "}" begrenzt. Innerhalb +der Aktion k\o'o"'nnen beliebige AMX Statements stehen. Die +Aktion kann leer sein, allerdings m\o'u"'ssen die Klammern +angegeben sein. Es ist wichtig zu wissen, dass innerhalb der +Aktion die Dom\o'a"'nenwerte des gefundenen Tupel immer vorhanden +sind und sich nicht \o'a"'ndern. +.LP +.ft B +BEISPIEL +.ft R +.DS L + . . . + ## open supply + ## open parts + . . . + ## scan supply $snum = 122 + ## { + ## scan parts /*parts*/$pnum = /*supply*/$pnum + ## { + . . . + ## } + ## } + . . . + ## close supply + ## close parts + . . . +.DE +.LP +Die \o'U"'bernahme von Werten aus dem \o'u"'bergeordneten scan +gestattet die einfache Implementierung von geschachtelten +scan's z.B. zur Zuordnung von Abk\o'u"'rzungen zu Langformen +(Nomenklaturen) usw. Bei Zeichenkettendom\o'a"'nen gestattet +der AMX Compiler keine \o'U"'bernahme von Werten, wenn die +L\o'a"'nge der Dom\o'a"'ne des \o'u"'bergeordneten scan's k\o'u"'rzer als +die L\o'a"'nge der Dom\o'a"'ne des aktuellen scan's ist. Eine +Mischung von numerischen und Zeichenkettenwerten wird +grunds\o'a"'tzlich nicht unterst\o'u"'tzt. +.DS L +(24) qual : dom RELOP value + ; +.DE +.ft B +dom +.ft R +gibt die einzuschr\o'a"'nkende Dom\o'a"'ne und +.ft B +value +.ft R +den Wert der Einschr\o'a"'nkung an. Als Einschr\o'a"'nkungen sind die +Bedingungen "RELOP": +.DS C +"=", "==", "<", "<=", ">", ">=", "!=" +.DE +zul\o'a"'ssig. Wird eine Dom\o'a"'ne doppelt eingeschr\o'a"'nkt, sind +folgende zul\o'a"'ssige Kombinationen zu beachten: +.DS I +"<[=]" und ">[=]" +"<[=]" und "!=" +">[=]" und "!=" +.DE +Die Reihenfolge der Einschr\o'a"'nkungen f\o'u"'r eine Dom\o'a"'ne ist +in folgender Art einzuhalten: +.DS I +"<[=]" --> ">[=]" --> "!=" +.DE +.DS L +(25) var_assign : c_var IS dom + ; ----- +.DE +Eine Zuweisung weist der C-Variablen +.ft B +c_var +.ft R +den aktuellen Wert der Dom\o'a"'ne +.ft B +dom +.ft R +zu. Bei den Zuweisungen von +numerischen zu numerischen Typen werden die notwendigen +Konvertierungen ohne \o'U"'berlauf- bzw. Unterlaufkontrolle +vorgenommen. Zuweisungen von numerischen zu +Zeichenkettenwerten und umgekehrt sind nicht zul\o'a"'ssig. +.DS L +(14) amx_stmt : PRINT LPAREN [ { dom } ] RPAREN + ; +.DE +Das print-Statement gibt die Werte der, durch eine \o'o"'ffnende +"(" und eine schliessende runde Klammer ")", begrenzten Liste +der Dom\o'a"'nen in einem Standardformat nach standard output +aus. Die Liste enth\o'a"'lt eine durch Kommas "," getrennte +Aufz\o'a"'hlung der auszugebenden Dom\o'a"'nen. Eine leere Liste +"()" gibt die Werte aller Dom\o'a"'nen aus. Das Standardformat +enth\o'a"'lt den Namen und den Wert der Dom\o'a"'ne in folgender +Form: +.DS L +"%12s: %?\en", domainname, value +? == Format der auszugebenden Dom\o'a"'ne +.DE +.DS L +(15) amx_stmt : DELETE + ; +.DE +Das delete-Statement l\o'o"'scht das innerhalb des laufenden +scan's gefundene aktuelle Tupel aus der Datenbasis. +Innerhalb der Aktion bleibt das aktuelle Tupel mit seinen +Werten erhalten. Eventuell vorhandene Indizes werden +automatisch aktualisiert. +.DS L +(16) amx_stmt : REPLACE target + ; +.DE +Das replace-Statement gestattet die \o'A"'nderung von Werten +einzelner (oder aller) Dom\o'a"'nen. Eine Unterscheidung von +Schl\o'u"'ssel- und Nichtschl\o'u"'sseldom\o'a"'nen ist nicht zu +beachten. Die \o'A"'nderungen werden durch die Projektion +.ft B +target +.ft R +spezifiziert. Es ist zu beachten, dass die +\o'A"'nderungen in einem gesondertem Puffer ausgef\o'u"'hrt werden, +also das aktuell gefundene Tupel innerhalb des laufenden +scan's unver\o'a"'ndert bleibt. Eventuell vorhandene Indizes +werden, falls n\o'o"'tig, automatisch aktualisiert. Eine +Aktualsierung entf\o'a"'llt z.B., wenn eine identische \o'A"'nderung +(ge\o'a"'ndertes == Ursprungstupel) ausgef\o'u"'hrt wurde oder wenn +die ge\o'a"'nderten Dom\o'a"'nen nicht Be\%standteil des Index sind +und sich die Tupeladresse +.ft B +TID +.ft R +nicht ge\o'a"'ndert hat. +.DS L +(17) amx_stmt : APPEND target + ; +.DE +Das append-Statement f\o'u"'gt ein neues Tupel in die aktuell +gescannte Relation ein. Durch die Projektion +.ft B +target +.ft R +werden den aufgef\o'u"'hrten Dom\o'a"'nen Werte zugewiesen. Alle +nicht angebenen Dom\o'a"'nen erhalten den Wert aus dem aktuell +gefundenen Tupel des laufenden scan's. Es ist zu beachten, +dass die \o'A"'nderung in einem gesondertem Puffer ausgef\o'u"'hrt +werden, also das aktuell gefundene Tupel unver\o'a"'ndert +bleibt. Eventuell vorhandene Indizes werden automatisch +aktualisiert. +.RE diff --git a/WEGA/contrib/ingres/dbs/ing_src/teil2/dab b/WEGA/contrib/ingres/dbs/ing_src/teil2/dab new file mode 100644 index 0000000..cde114c --- /dev/null +++ b/WEGA/contrib/ingres/dbs/ing_src/teil2/dab @@ -0,0 +1,3107 @@ +.ds RH \f3Datenbank\f1 +.ds CH - % - +.ds LH Anwendung +.bp +.NH 2 +.ft B +Arbeit mit Datenbanken * +.ft R +.LP +.sp 10 +.NH 3 +.ft B +Vorbemerkung * +.ft R +.LP +In diesem Abschnitt wird beschrieben, +wie die Relationen der Datenbank erzeugt, +strukturiert und verwaltet werden. +Es wird davon ausgegangen, +dass der Leser etwas vertraut ist und die Anfragesprache +QUEL von \*(yy\ versteht. +.sp 1 +Um eine neue Datenbank zu gr\o'u"'nden, +m\o'u"'ssen sie ein g\o'u"'ltiger (eingetragener) +\*(yy\-Nutzer sein und die +.ft B +creatdb +.ft R +\-Erlaubnis haben. +Diese Erlaubnis wird vom \*(yy\-Sy\%stem\%ad\%mi\%ni\%stra\%tor verliehen. +Wenn sie beide Bedingungen erf\o'u"'llen, +k\o'o"'nnen sie eine Datenbank unter +Verwendung des \*(xx\-Shell-Kommandos +.sp 1 +.ft B +% creatdb meindb +.ft R +.sp 1 +gr\o'u"'nden, wobei +.ft B +meindb +.ft R +der Name der Datenbank ist. +Sie werden Datenbankadministrator (DBA) f\o'u"'r +"meindb". +Als DBA haben sie spezielle Berechtigungen. +.sp +.IP 1. +Alle von ihnen erzeugten Relationen +k\o'o"'nnen von allen anderen, +.ft B +meindb +.ft R +verwendenden, +Nutzern benutzt werden. +Erzeugt aber dagegen ein beliebiger Nutzer eine Relation, +so ist sie strikt privat und auf sie kann weder vom DBA +noch von einem anderen Nutzer zugegriffen werden. +.RE +.sp +.IP 2. +Sie k\o'o"'nnen das +.ft B +-u +.ft R +\-Flag in +.ft B +quel +.ft R +und +.ft B +printr +.ft R +verwenden. +Das bef\o'a"'higt sie, \*(yy\ auf +.ft B +meindb +.ft R +als ein anderer Nutzer laufen zu lassen. +Schlagen sie im \*(yy\-Referenz- +Manual unter den Kapiteln +.ft B +quel(unix) +.ft R +und +.ft B +users(files) +.ft R +wegen detaillierten Angaben nach. +.RE +.sp +.IP 3. +Sie k\o'o"'nnen mit +.ft B +sysmod +.ft R +, +.ft B +restore +.ft R +, +.ft B +creatdb +.ft R +, +.ft B +destroydb +.ft R +und +.ft B +purge +.ft R +auf +.ft B +meindb +.ft R +arbeiten. +.RE +.sp +.IP 4. +Eine Datenbank, die ohne Angabe von Flags gegr\o'u"'ndet +wurde, gestattet mehrere mitwirkende Nutzer. +Wenn jeweils nur ein Nutzer die Datenbank zu +bestimmter Zeit verwenden m\o'o"'chte, +kann der Datenbankadministrator die Gleichzeitigkeitskontrolle +ausschalten. +Schlagen sie unter +.ft B +creatdb(unix) +.ft R +im \*(yy\- +Referenz-Manual nach. +.RE +.sp 1 +Wenn eine Datenbank gegr\o'u"'ndet ist, sollten sie +sofort +.sp 1 +.ft B +% sysmod meindb +.ft R +.sp 1 +geben. Dieses Kommando konvertiert +die Systemrelationen in die g\o'u"'nstigste +Struktur zur Verwendung in \*(yy\. +.ft B +sysmod +.ft R +wird sp\o'a"'ter ausf\o'u"'hrlich erkl\o'a"'rt. +.sp 1 +Als DBA oder als ein Nutzer k\o'o"'nnen sie neue Relationen in +jeder Datenbank erzeugen, zu der +sie Zugriffsrecht haben. +Die vorliegenden Ausf\o'u"'hrungen beschreiben, wie das gemacht werden muss. +.NH 3 +.ft B +Erzeugung neuer Relationen mit QUEL +.ft R +.LP +Es gibt zwei Wege um neue Relationen mit QUEL zu erzeugen. +.sp 1 +.IP +create +.br +retrieve into +.RE +.sp 1 +.ft B +retrieve into +.ft R +wird verwendet, um eine neue Relation aus einer oder +mehreren existierenden Relationen zu formieren. +.ft B +create +.ft R +wird verwendet, um +eine neue Relation ohne Tupel (leer) zu erzeugen. +.sp 1 +Beispiel 1: +.sp 1 +.DS +range of t is teile +range of l is lieferung +retrieve into neuliefrg( + nummer = l.lnum, + t.tname, + l.liefdat) +where l.tnum = t.tnum +.DE +.sp 1 +Beispiel 2: +.sp 1 +.DS +create neuliefrg( + nummer = i2, + tname = c20, + liefdat = c8) +.DE +.sp 1 +Im Beispiel 1 erzeugt QUEL eine neue Relation, genannt +"neuliefrg". Das Format der Dom\o'a"'nen wird +berechnet. +Die Query wird bearbeitet und "neuliefrg" +modifiziert zu "cheapsort". +(Dies wird ausf\o'u"'hrlicher im Abschitt 2.2.4. erkl\o'a"'rt.) +.sp 1 +Im Beispiel 2 wird "neuliefrg" +erzeugt und der Name sowie +das Format f\o'u"'r jede Dom\o'a"'ne angegeben. +Die zugelassenen Formattypen sind: +.sp 1 +.DS I + +i1 1 Byte Integer +i2 2 " " +i4 4 " " +f4 4 Byte Gleitkommazahl +f8 8 " " " " +c1,c2,..,c255 1,2,..,255 Byte Zeichenkette +.DE +.sp 1 +Im Beispiel 2 betr\o'a"'gt die L\o'a"'nge eines einzelnen Tupel +30 Byte +(2 + 20 + 8). Die +Relation hat drei Dom\o'a"'nen. +Es ist klar, dass \*(yy\ +Grenzen hat. +Eine Relation kann +installationsabh\o'a"'ngig 49 bzw. 128 Dom\o'a"'nen und eine Tupell\o'a"'nge +von \o'u"'ber 498 bzw. 1010 Byte haben. +.sp 1 +\*(xx\ stellt den Speicherplatz auf der Platte in +Bl\o'o"'cken von 512 Byte, 1KByte bzw. 4KByte bereit. +Datens\o'a"'tze werden in \*(yy\ in Seiten (pages) +abgelegt, deren Gr\o'o"'ssen beim Anlegen einer +Datenbank eingestellt werden. +Die maximale Seitengr\o'o"'sse ist generierungsabh\o'a"'ngig. +.br +\*(yy\ teilt ein Tupel nicht +\o'u"'ber zwei Seiten, +so kann es vorkommen, +dass Speicherplatz vergeudet wird. +In einer Seite werden f\o'u"'r den +.ft B +overhead +.ft R +12 Bytes zuz\o'u"'glich +je 2 Byte pro Tupel f\o'u"'r Verwaltungsaufgaben genutzt. +Die Berechnungsvorschriften sind: +.sp 1 +.DS L +Anzahl der Tupel pro Seite = + (Seitengr\o'o"'sse-12)/(Tupell\o'a"'nge + 2) +.sp 1 +Verschwendeter (oder verschenkter) Speicherplatz = + (Seitengr\o'o"'sse-12) - (Anzahl der Tupel pro Seite) * + * (Tupell\o'a"'nge + 2) +.sp 1 +.DE +F\o'u"'r unser Beispiel und 512-Byte-Seitengr\o'o"'sse ergibt das +.sp 1 +.IP +15 = 500 / (30 + 2) +.br +.sp 1 +20 = 500 - 15 * (30 + 2) +.RE +.sp 1 +15 Tupel pro Seite und 20 Bytes +unbelegter Platz. +Diese Berechnung gilt nicht f\o'u"'r +komprimierte Relationen. +Wir werden auf dieses Problem im +Weiteren zur\o'u"'ckkommen, wenn Tupelkompression diskutiert wird. +.sp 1 +Wenn sie einen Dom\o'a"'nenname oder ein Format vergessen haben, +benutzen sie das "help"-Kommando. +Geben sie auf das Beispiel bezogen das QUEL- +Kommando +.sp 1 +.IP +help neuliefrg +.RE +.sp 1 +wird folgendes gedruckt: +.DS + +Relation: neuliefrg +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Owner: bob +Tuple width: 30 +Saved until: Thu Nov 10 08:35:06 1988 +Number of tuples: 0 +Storage structure: heap +Relation type: user relation + + attribute name type length keyno. + + nummer i 2 + tname c 20 + liefdat c 8 + +.DE +Merken sie sich, dass jede Relation ein Verfallsdatum +hat. +Es wird ausgehend vom Erzeugungsdatum der Relation +auf eine Woche festgesetzt. +Das +.ft B +save +.ft R +\-Kommando +kann verwendet werden, um diesen Zeitraum zu verl\o'a"'ngern. +Beachten sie dazu +.ft B +save(quel) +.ft R +und +.ft B +purge(unix) +.ft R +im +\*(yy\-Referenz- Manual. + +.NH 3 +.ft B +Das Kopieren von Daten aus und in eine +.ft R +.br +.ft B + Datenbank +.ft R +.LP +.NH 4 +.ft B +Allgemeine M\o'o"'glichkeiten +.ft R +.LP +Wenn eine Relation gegr\o'u"'ndet wurde, gibt es folgende M\o'o"'glichkeiten, +neue Daten einzuf\o'u"'gen: +.sp +.IP +append-Kommando +.br +copy-Kommando +.RE +.sp +.ft B +append +.ft R +wird zum Einf\o'u"'gen eines einzelnen Tupel zu irgend\%einem +Zeitpunkt oder zum F\o'u"'llen einer +Relation aus anderen Relationen verwendet. +.sp +.ft B +copy +.ft R +wird zum Kopieren von Daten aus einem \*(xx\-File in eine +Relation benutzt. +Es ist anzuwenden, um Daten von einem anderen Programm oder von einem +anderen System zu kopieren. +Es ist auch gebr\o'a"'uchlich, um gr\o'o"'ssere Datenmengen +zu kopieren. +.sp +Wir wollen nun eine einfache Relation erzeugen +und Daten dort einbringen. +.sp +Beispiel: +.sp +.DS +create abgabe (name = c10, wert = f4, ext = i2) +.DE +Jetzt sollen zwei Personen eingegeben werden. +Die einfachste M\o'o"'glichkeit ist nat\o'u"'rlich, diese Eingabe unter +Verwendung des QUEL-Kommandos +.ft B +append +.ft R +zu vollziehen. +.sp +.DS +append to abgabe (name="frank",wert = 5,ext = 204) + +append to abgabe (name="harry",ext = 209,wert = 4.50) +.DE +.sp +\*(yy\ erkennt die Dom\o'a"'nen +an ihren Namen, unabh\o'a"'ngig von ihrer +aufgelisteten Reihenfolge. +Die Relation +.ft B +abgabe +.ft R +sieht jetzt so aus: +.DS + +abgabe relation + +|name |wert |ext | +|----------------------------| +|frank |5.000 |204 | +|harry |4.500 |209 | +|----------------------------| +.DE +.sp +Wir haben zwei Personen in die +.ft B +abgabe +.ft R +\-Relation eingegeben. +Doch was ist, wenn wir weitere f\o'u"'nfzig einzugeben h\o'a"'tten. +Die Verwendung des "append"-Kommandos ist aufgrund der umfangreichen +Angaben f\o'u"'r jedes Tupel nicht geeignet. +Das +.ft B +copy +.ft R +\-Kommando entspricht besser unseren Anforderungen. +.sp +.ft B +copy +.ft R +kann Daten von einem regul\o'a"'ren +\*(xx\-File in verschiedenen Formaten \o'u"'bernehmen +und sie in die Relation einf\o'u"'gen. +Um das "copy"-Kommando zu verwenden, ist vorher +ein \*(xx\-File (\o'u"'blicherweise mit "ed") zu erzeugen, das die +Daten enth\o'a"'lt. +.sp +Als Beispiel wollen wir f\o'u"'nf neue Namen in das File +unter Verwendung des Editor's eintragen. +.LP +.DS L +% ed +a +bill,3.50,302 +sam,10.00,410 +susan,,100 +sally,.5,305 +george,4.00,302 + +w newdom +68 +q +% + +.DE +Das Format des obenstehenden Files ist +ein Name gefolgt von einem Komma, gefolgt von +einem Wert (wert), dann ein Komma, dann die Erweiterung (extension) +und schliesslich ein Newline. +Es ist zulaessig, Werte nicht anzugeben, wie zum Beispiel "wert" +bei "susan". +Solche Leerwerte werden bei +numerischen Dom\o'a"'nen zu +Null (0) und bei Zeichenketten auf blanks (Leerzeichen) gesetzt. +.LP +Um zu kopieren, starten wir \*(yy\ und geben das "copy"-Kommando. +.LP +.DS L +copy abgabe (name = c0, wert = c0, ext = c0) + from "/mnt/bob/newdom" +.DE +.LP +Das "copy"-Kommando arbeitet folgendermassen: +.LP +.DS L +copy relname (Liste, was zu kopieren ist) from "voller pathname" +.DE +.LP +Obwohl "wert" und "ext" in der Relation +als f4 (Gleitkomma) und i2 (Integer) gespeichert sind, +haben wir sie im +\*(xx\-File aber als Zeichenketten eingegeben. +Zur Spezifizierung des Formats der Dom\o'a"'ne akzeptiert +.ft B +copy: +.ft R +.IP +domain = format +.LP +wobei +.ft B +domain +.ft R +der Dom\o'a"'nenname und +.ft B +format +.ft R +im \*(xx\-File einer der folgenden Werte ist: +.LP +.DS L +i1, i2, i4 (Integer der L\o'a"'nge 1, 2, oder 4) +f4, f8 (Gleitkommazahl der L\o'a"'nge 4 + oder 8) +c1, c2, c3,...c255 (Zeichenkette mit fester L\o'a"'nge) +c0 (Zeichenkette mit variabler L\o'a"'nge, + begrenzt durch Komma, Tabulator oder + Newline) + +.DE +Im Beispiel verwenden wir: +.IP +name = c0, wert = c0, extension = c0 +.LP +Das bedeutet, dass jede Dom\o'a"'ne +im \*(xx\-File als Zeichen\%kette mit +variabler L\o'a"'nge gespeichert war. +.ft B +copy +.ft R +verwendet das erste Komma-, +Tabulator- oder Newline-Zeichen als Ende der Zeichenkette. +Das ist ungef\o'a"'hr die gebr\o'a"'uchlichste Nutzung von +.ft B +copy +.ft R +, wenn neue Daten erstmalig in eine +Relation eingebracht werden. +.LP +.ft B +copy +.ft R +kann auch benutzt werden, um Daten aus einer Relation +in ein \*(xx\-File zu kopieren. +Zum Beispiel: +.LP +.DS L +copy abgabe (name = c10, wert = c10, ext = c5) + into "/mnt/bob/data" +.DE +.LP +Folgendes ereignet sich: +.IP 1. +Wenn das File /mnt/bob/data bereits existiert, wird +es zerst\o'o"'rt. +.IP 2. +Das File wird im Modus 600 +(nur read/write-Erlaubnis f\o'u"'r den Nutzer) erzeugt. +.IP 3. +"name" wird als ein 10-Zeichenfeld kopiert, +unmittelbar gefolgt von "wert", +unmittelbar gefolgt von "ext". +"wert" wird konvertiert in eine Zeichenkette +der L\o'a"'nge 10. +"ext" wird konvertiert in eine Zeichenkette +der L\o'a"'nge 5. +.LP +Das File +.ft B +/mnt/bob/data +.ft R +wird eine Folge von Zeichen, +die folgendermassen aussieht: + +.DS L +frank``````````5.000``204harry``````````4.500 209bill +```````````3.500``302sam```````````10.000 410susan``` +```````0.000``100sally``````````0.500``305george`````` +```4.000``302 +.DE +.LP +Dabei steht "`" f\o'u"'r . +Die Ausgabe wurde zur Darstellung entsprechend +des vorliegenden Papierformates +in vier Zeilen geteilt. +In Wirklichkeit ist das File +eine einzige Zeile. +Ein anderes Beispiel: +.sp +.DS +copy (name = c0, colon = d1, ext = c0, comma = d1, + wert = c0, nl = d1) into "/mnt/bob/data" +.DE +.sp +In diesem Beispiel wird +.ft B +c0 +.ft R +interpretiert als "nutze +das festgelegte Zeichenketten-Format". +F\o'u"'r Zeichenketten-Dom\o'a"'nen ist das die +L\o'a"'nge der Dom\o'a"'ne. +Numerische Dom\o'a"'nen werden konvertiert in Zeichenketten +entsprechend dem \*(yy\-Standardformat +(siehe quel(unix)). +.sp +Die Statements: +.IP +colon = d1 +.br +comma = d1 +.br +nl = d1 +.LP +werden benutzt um einen Doppelpunkt, +ein Komma oder ein Newline in das File einzuf\o'u"'gen. +Das Format +.ft B +d1 +.ft R +wird als Pseudo-Zeichen (dummy) interpretiert. +W\o'a"'hrend des Kopierens in ein \*(xx\-File +kann eine ausgew\o'a"'hlte Menge von Zeichen in das File unter +Verwendung der +.ft B +dummy domain +.ft R +\-Spezifikation eingef\o'u"'gt werden. +So w\o'u"'rde das File "/mnt/bob/data" aussehen: + +.DS L +frank : 204, 5.000 +harry : 209, 4.500 +bill : 302, 3.500 +sam : 410, 10.000 +susan : 100, 0.000 +sally : 305, 0.500 +george : 302, 4.000 + +.DE +.LP +Wenn sie ein File mit der wirklichen Bin\o'a"'rdarstellung der +Zahlen w\o'u"'nschen, ist zu verwenden: +.IP +copy (name = c10, wert = f4, ext = i2) into "..." +.LP +Dies w\o'u"'rde ein File mit einer exakten +Kopie von jedem Tupel, +eins nach dem anderen, erzeugen. +Es ist h\o'a"'ufig w\o'u"'nschenswert und das wird hier bezweckt, f\o'u"'r tempor\o'a"'re Backups die Garantie +zu haben, dass die Gleitkomma-Dom\o'a"'nen +exakt abgebildet sind. +.NH 4 +.ft B +Typische Fehler +.ft R +.LP +Es gibt 17 verschiedene Fehler +die bei "copy" auftreten k\o'o"'nnen. +Wir wollen einige der h\o'a"'ufigsten +durchgehen. +.LP +Angenommen sie haben ein File mit +.sp 1 +bill,3.5,302 +.br +sam,10,410, +.br +susan,3,100 +.sp 1 +und arbeiten das "copy"-Kommando +.LP +.DS +copy abgabe (name = c0, wert = c0, ext = c0) + from "/mnt/bob/data" +.DE +.sp 1 +ab, dann erhalten sie die Fehlermitteilung +.sp 1 +.DS L +5809: COPY: Bad input String for Domain wert. +Input was "susan".There were 2 tuples sucessfully +copied from /mnt/bob/data into abgabe. +.DE +.LP +Folgendes hat sich ereignet: +.IP +Zeile 2 hat ein extra Komma, die ersten beiden +Tupel wurden richtig kopiert, +das n\o'a"'chste Tupel ergibt sich dann zu + name = "" (blank), wert = +"susan", and ext = "3". +Aber "susan" ist keine erlaubte Gleitkommazahl, +ein Fehler wird generiert und +der Prozess wird nach zwei Tupel gestoppt. +.LP +Wenn sie versuchen ein solches File +wie +.sp 1 +nancy,5.0,35000 +.sp 1 +zu kopieren erhalten sie die Fehlermitteilung +.DS L +5809: COPY: Bad input String for Domain ext. +Input was "35000". There were 0 Tuples successfully +copied from /mnt/bob/data into abgabe. +.DE +.LP +Hier gilt "ext" als eine i2 (Integer)-Dom\o'a"'ne, +Sie kann den Wert 32767 nicht \o'u"'berschreiten. +.LP +Es gibt weitere "numerische" Fehlermitteilungen, +die meisten sind selbsterkl\o'a"'rend. +.LP +Hinzuzuf\o'u"'gen sind drei, nicht verh\o'a"'ngnisvolle Warnungen, +die bei +.ft B +copy from +.ft R +auftreten k\o'o"'nnen. +.LP +Wenn sie von einem File +in eine Relation der Art +.ft B +isam +.ft R +oder +.ft B +hash +.ft R +kopieren, wird die Anzahl +der doppelten Tupel mitgeteilt (, sofern welche enthalten sind). +Das kann bei +.ft B +heap +.ft R +nicht geschehen, +weil auf doppelte Tupel nicht gepr\o'u"'ft wird. +.LP +\*(yy\ ist nicht in der Lage +.ft B +control characters +.ft R +(solche wie +.ft B +bell +.ft R +etc.) +zu speichern. +Wenn +.ft B +copy +.ft R +ein +.ft B +control character +.ft R +liest, konvertiert es dieses in +.ft B +blank +.ft R +und teilt die Anzahl der Dom\o'a"'nen +mit, in denen diese Zeichen enthalten waren. +.LP +Wenn sie mit der c0 +-Option kopieren, wird "copy" ihnen mitteilen, +wieviele Zeichen\%ketten l\o'a"'nger als ihre zugeh\o'o"'rigen Dom\o'a"'nen +waren und gek\o'u"'rzt werden. +Die Zeichenkette wird abgeschnitten. +.NH 4 +.ft B +Spezielle M\o'o"'glichkeiten +.ft R +.LP +Es gibt einige spezielle Funktionen, die +.ft B +copy +.ft R +in der Handhabung etwas erleichtern. +.NH 5 +.ft B +Physische Kopie (bulk copy) +.ft R +.LP +Wenn sie +.DS I +copy relname () from "file" + oder +copy relname () into "file" +.DE +geben, erweitert "copy" das Statement in folgender Bedeutung: +.IP +Kopiere jede Dom\o'a"'ne in ihrer genauen Reihenfolge entsprechend +ihres festgelegten Formats. +.LP +Wenn sie sagen w\o'u"'rden +.IP +copy abgabe () into "/mnt/bob/abgabe" +.LP +w\o'a"'re es dasselbe wie: +.DS I +copy abgabe (name = c10, wert = f4, ext = i2) + into "/mnt/bob/abgabe" +.DE +Dies verschafft ihnen einen bequemen Weg, um +ganze Relationen von und nach \*(yy\ zu kopieren, +bspw. aber auch von einer Datenbank in die andere. +.NH 5 +.ft B +Pseudodom\o'a"'nen (Dummy Domains) +.ft R +.LP +Wenn sie Daten von einem anderen +Computer oder einem anderen Programm kopieren wollen, +kann es vorkommen, dass ein Teil +der Daten ignoriert werden soll. +Das k\o'o"'nnen sie unter Verwendung +der +.ft B +dummy domain +.ft R +\-Spezifikation +d0, d1, d2 ... d511 realisieren. +Zum Beispiel +.DS I +copy rel (dom1 = c5, dummy = d2, dom2 = i4, + dumb = d0) from "/mnt/me/data" +.DE +Die ersten f\o'u"'nf Zeichen +werden in dom1 abgelegt, +die n\o'a"'chsten zwei werden ignoriert. +Die n\o'a"'chsten vier Bytes geh\o'o"'ren zum Typ i4 (Integer) +und gehen zu dom2, +und die verbleibende begrenzte Zeichenkette +wird ignoriert. +Der Name der +.ft B +dummy +.ft R +\-Dom\o'a"'ne +wird \o'u"'berlesen, +die Dom\o'a"'ne muss nicht unbedingt +.ft B +dummy +.ft R +heissen, wie das bei +.ft B +dumb = d0 +.ft R +der Fall ist. +.LP +Wie schon erw\o'a"'hnt, +k\o'o"'nnen "dummy"-Dom\o'a"'nen verwendet werden, +um bei einem "copy into" auf ein \*(xx\-File Spezialzeichen +("special characters") einzuf\o'u"'gen. +Die Liste der zugelassenen Dom\o'a"'nen enth\o'a"'lt: +.DS I +nl newline +tab tab character +sp space +nul a zero byte +null a zero byte +comma , +dash - +colon : +lparen ( +rparen ) +.DE +.sp 1 +.NH 5 +.ft B +Abschneiden (Truncation) +.ft R +.LP +Es ist nicht ungew\o'o"'hnlich, dass nach einem aufgetretenen Fehler +nochmals gestartet werden muss. +Der einfachste Weg, das zu tun, +ist das L\o'o"'schen der alten Relation. +Es wird mit dem Kommando +.IP +modify relname to truncated +.LP +realisiert und hat den Effekt des L\o'o"'schens +aller Tupel in +.ft B +relname +.ft R +, bei gleichzeitiger Freigabe des belegten Plattenspeicherbereichs +und der Umwandlung von +.ft B +relname +.ft R +zur\o'u"'ck zu +.ft B +heap +.ft R +\&. Es ist das logische \o'A"'quivalent zum +.ft B +destroy +.ft R +gefolgt von +.ft B +create +.ft R +(aber mit etwas weniger Eingabearbeit). +.LP +Da in den verwendeten Files Formatfehler nicht +auszuschliessen sind, ist es +im Allgemeinen keine gute Idee +mit +.ft B +copy +.ft R +Daten in eine Relation mit bereits +gepr\o'u"'ften Daten zu transportieren. +Die g\o'u"'nstigste Verfahrensweise ist, +eine tempor\o'a"'re Relation mit den selben Dom\o'a"'nen +zu erzeugen, +wie sie die existierende Relation besitzt. +Ko\%pieren sie die Daten in die tempor\o'a"'re Relation +und dann h\o'a"'ngen ("append") sie diese an die echte Relation an. +Zum Beispiel: +.DS I +create tempdom(name=c10,wert=f4,ext=i2) + +copy tempdom(name=c0,wert=c0,ext=c0) +from "/mnt/bob/data" + +range of td is tempdom +append to abgabe(td.all) +.DE +.sp 1 +.NH 5 +.ft B +Spezielle Begrenzer (Specifing Delimitors) +.ft R +.LP +Manchmal ist es w\o'u"'nschenswert das Zeichen +zu spezifizieren, +welches die Zeichenfolge +bei "copy from file" begrenzen soll. +Das ist mit der Angabe +.IP +domain = c0delim +.LP +m\o'o"'glich, wobei +.ft B +delim +.ft R +ein g\o'u"'ltiger Begrenzer (delimitor) +aus der Liste der zugelassenen Namen oder ein +beliebiges Zeichen ist. +Diese Liste wurde weiter oben +unter +.ft B +dummy domains +.ft R +aufgef\o'u"'hrt. +Bei den Zeichen muss beachtet werden, dass der +beliebige Delimitor ein Zeichen sein muss, welches +der interaktive Terminal-Monitor annimmt und der Parser +nicht als Operator interpretiert. +(Diese Interpretationsart kann umgangen werden, indem +die Angabe +.ft B +c0delim +.ft R +als String gequotet wird. Das heisst, der +gew\o'u"'nschte Delimitor m\o'u"'sste in der Form " +.ft B +c0) +.ft R +"geschrieben werden. +Zum Beispiel: +.IP +copy abgabe (name = c0nl) from "/mnt/me/data" +.LP +kopiert "name" des Files in die Relation. +Nur ein Newline begrenzt die Namen richtig, weil +Kommas oder Tabulatoren eventuell als Teil eines +Namens auftreten k\o'o"'nnen. +.LP +Bei +.ft B +copy into file +.ft R +wird +.ft B +delim +.ft R +immer sofort in das File geschrieben, +so dass bei +.ft B +copy into +.ft R +die Spezifikation lautet: +.IP +copy abgabe (name = c0nl) into "/mnt/me/file" +.LP +Genauer gesagt, "name" wird unmittelbar gefolgt von Newline. +.NH 5 +.ft B +Aufhebung der Begrenzer (Quoting) +.ft R +.LP +Soll in einem Wert einer Dom\o'a"'ne +der g\o'u"'ltige Begrenzer Verwendung finden, +so muss er kaschiert (aufgehoben) werden. +Dies geschieht durch das Voranstellen +eines backslash +.ft B +\e +.ft R +vor dem Begrenzer. +.br +So kann z.B. das Tupel +.IP +donald\e, mc, 6.0, 403 +.LP +korrekt mittels +.DS I +copy abgabe (name = c0, wert = c0, ext = c0) + from "/mnt/bob/data" +.DE +kopiert werden, wobei "name" den Wert +"donald, mc", "wert" den Wert "6.0" neu +erh\o'a"'lt. +.NH 3 +.ft B +Speicherstrukturen f\o'u"'r Relationen +.ft R +.LP +.NH 4 +.ft B +Einf\o'u"'hrung +.ft R +.LP +Wenden wir uns nun den Problemen der Effizienz zu. +Haben sie erst einmal eine Relation erzeugt +und Ihre Daten unter +Verwendung von +.ft B +copy +.ft R +oder +.ft B +append +.ft R +eingef\o'u"'gt, +kann \*(yy\ jede beliebige Query (Kommando aus QUEL) +in der Relation ausf\o'u"'hren. +Es gibt mehrere M\o'o"'glichkeiten, zur +Erh\o'o"'hung der +Geschwindigkeit, mit der \*(yy\ die Query ausf\o'u"'hrt. +.LP +\*(yy\ kann eine Relation in drei verschiedenen +internen +Strukturen speichern. +Sie werden +.ft B +heap +.ft R +, +.ft B +isam +.ft R +und +.ft B +hash +.ft R +genannt. +Zuerst wollen wir jede Struktur genauer +beschreiben und sp\o'a"'ter unsere Betrachtung +ausdehnen. +.NH 4 +.ft B +Heap +.ft R +.LP +Wird eine Relation erstmalig erzeugt, ist sie +vom Typ "heap". +Es gibt zwei wichtige Feststellungen zu +.ft B +heap: +.ft R +doppelte Tupel werden nicht gel\o'o"'scht +und die Lokalisierung der Tupel ist unbekannt. +Wenn sie die folgende Query ausf\o'u"'hren +.IP +range of a is abgabe +.br +retrieve (a.wert) where a.name = "bill" +.LP +muss \*(yy\ jedes Tupel lesen und pr\o'u"'fen, ob der +Name "bill" dort auftritt. +Bei kleinen Relationen ist das nicht schlimm, +aber bei sehr grossen Relationen kann das Minuten +(oder eben bei Computern mit kleinen +Hauptspeichern Stunden!) dauern. +.NH 4 +.ft B +Hash +.ft R +.LP +Bei einer Relation, deren Struktur +.ft B +hash +.ft R +ist, kann ein schneller +Zugriff auf Tupel gew\o'a"'hrt werden, +wenn die Suche (Recherche) durch bestimmte +Dom\o'a"'nen gesteuert wird. +Diese Dom\o'a"'nen werden gew\o'o"'hnlich als +.ft B +keyed domains +.ft R +(Schl\o'u"'ssel bzw. +Schl\o'u"'sseldom\o'a"'nen) bezeichnet. +Weiterhin enthalten, +.ft B +hash +.ft R +\-Relationen +keine doppelten Tupel. +Nehmen wir beispielsweise an, dass die "abgabe"-Relation als +.ft B +hash +.ft R +auf +die Dom\o'a"'ne "name" gespeichert ist. +In der Query +.IP +retrieve (a.wert) where a.name = "bill" +.LP +wird \*(yy\ schnell herausbekommen, +wo sich das Tupel ann\o'a"'hernd auf der Platte +befindet. +Wenn die Relation nur einige wenige Tupel enth\o'a"'lt, k\o'o"'nnen sie +den Unterschied zwischen +.ft B +heap +.ft R +\-und +.ft B +hash +.ft R +\-Struktur nicht bemerken. +Aber wenn die Relation gr\o'o"'sser wird, ist +die Zugriffszeit von sp\o'u"'rbarer +Bedeutung. +.NH 4 +.ft B +Isam +.ft R +.LP +Eine +.ft B +isam +.ft R +\-Struktur liegt dann vor, wenn die Relation nach +einer oder mehreren Dom\o'a"'nen sortiert ist +(auch +.ft B +keyed domains +.ft R +genannt). +Doppelte Tupel treten bei "isam"-Relationen nicht auf. +Wenn ein neues Tupel angef\o'u"'gt wird, wird es +"ann\o'a"'hernd" an der Stelle platziert, die der Sortierposition in der +Relation entspricht. +(Das "ann\o'a"'hernd" wird etwas sp\o'a"'ter erl\o'a"'utert.) +.LP +Angenommen "abgabe" hat die Struktur +.ft B +isam +.ft R +auf die Dom\o'a"'ne "name". +Die Ausf\o'u"'hrung der Query +.IP +retrieve (a.wert) where a.name = "bill" +.LP +wird \*(yy\ veranlassen, festzustellen, wo in der sortierten +Folge der Name "bill" steht und nur dieser +Teil der Relation wird gelesen. +.LP +Wenn die Relation ann\o'a"'hernd sortiert ist, ist +eine +.ft B +isam +.ft R +\-Struktur auch effizient zur +Ausf\o'u"'hrung der Query: +.IP +retrieve (a.wert) where a.name >= "b" and a.name < "g" +.LP +Diese Query zeigt alle Namen, die mit "b" bis "f" beginnen. +Es ist nicht n\o'o"'tig, die gesamte Relation zu +durchsuchen, +da sie eine +isam +\-Struktur \o'u"'ber "name" besitzt. +.NH 4 +.ft B +Spezifizierung der Speicherstruktur +.ft R +.LP +Eine von einem Nutzer erzeugte Relation kann durch Anwendung +des +.ft B +modify +.ft R +\-Kommandos in eine der Speicherstrukturen konvertiert werden. +Zum Beispiel +.DS I +modify abgabe to hash on name + oder +modify abgabe to isam on name + oder eben +modify abgabe to heap +.DE +.sp 1 +.NH 4 +.ft B +Haupt-(primary) und +.br + \o'U"'berlauf-(overflow) Seiten +.ft R +.LP +An dieser Stelle ist es notwendig auf das +Konzept der Haupt- und \o'U"'berlauf-Seiten bei +.ft B +hash +.ft R +\-und +.ft B +isam +.ft R +\-Strukturen einzugehen. +Beide, +.ft B +hash +.ft R +und +.ft B +isam +.ft R +, sind Techniken der Zuweisung +von Tupeln zu festen Seiten einer Relation, +basierend auf den Schl\o'u"'sseldom\o'a"'nen der Tupel. +So enth\o'a"'lt jede Seite nur eine bestimmte +Untermenge der Relation. +.LP +Wenn ein neues Tupel in eine +.ft B +hash +.ft R +\-oder +.ft B +isam +.ft R +\-Relation eingef\o'u"'gt wird, stellt \*(yy\ +zuerst fest, in welche Seite es geh\o'o"'rt +und \o'u"'berpr\o'u"'ft dann den verf\o'u"'gbaren Platz dieser Seite. +Wenn dort noch Platz ist, wird das Tupel +in dieser Seite untergebracht. +Wenn kein Platz ist, +wird eine \o'U"'berlauf-Seite erzeugt und +das Tupel dort platziert. +.LP +Die \o'U"'berlauf-Seite wird mit der Originalseite +verbunden. +Die Originalseite wird als Haupt-Seite bezeichnet. +Wenn die \o'U"'berlauf-Seite voll wird, +dann er\o'o"'ffnet \*(yy\ +eine \o'U"'berlauf-Seite zu dieser. +Wir haben dann eine Haupt-Seite, +die mit einer \o'U"'berlauf-Seite verbunden ist, +welche wiederum mit einer anderen \o'U"'berlauf-Seite verbunden ist. +\o'U"'berlauf-Seiten werden dynamisch so hinzugef\o'u"'gt, +wie sie gebraucht werden. +.sp 2 +.NH 4 +.ft B +Spezifizierung des Freiraumes +.br + auf einer Seite (free space) +.ft R +.LP +Beim +.ft B +modify +.ft R +\-Statement k\o'o"'nnen sie angeben, +wieviel Platz zum Wachsen der Relation frei gehalten +werden soll. +Wie schon erw\o'a"'hnt, +ist eine Relation in Seiten gegliedert. +Der F\o'u"'llungsfaktor ( +.ft B +fillfactor +.ft R +) spezifiziert, +wie weit jede Haupt-Seite belegt werden soll. +Diese Festlegung sollte n\o'a"'herungsweise darauf basieren, wieviele Tupel +in die Relation noch einzuf\o'u"'gen sind. +Zum Beispiel: +.IP +modify abgabe to isam on name where fillfactor = 100 +.LP +Hier wird "modify" mitgeteilt, +dass jede Seite m\o'o"'glichst mit 100% gef\o'u"'llt +werden soll. +.IP +modify abgabe to isam on name where fillfactor = 25 +.LP +bewirkt, dass jede Seite zu 25% gef\o'u"'llt, oder mit +anderen Worten, zu 75% leer ist. +Wir w\o'u"'rden so vorgehen, wenn wir etwa 1/4 der Daten +geladen h\o'a"'tten und annehmen, dass sie gleichm\o'a"'ssig +\o'u"'ber das Alphabet verteilt sind. +.LP +Merken sie sich, wenn der +.ft B +fillfactor +.ft R +nicht spezifiziert ist, +wird \*(yy\ einen vern\o'u"'nftigen Standardwert einsetzen. +Auch dann, wenn eine Seite gef\o'u"'llt ist, erzeugt \*(yy\ +automatisch eine \o'U"'berlauf-Seite, +so dass niemals der Fall eintritt, dass eine Relation +nicht erweitert werden kann. +.LP +Wenn eine Relation zu +.ft B +hash +.ft R +modifiziert wird, +kann ein Parameter +.ft B +minpages +.ft R +(minimale Seitenanzahl) +spezifiziert werden. +.ft B +modify +.ft R +garantiert, dass mindestens +.ft B +minpage +.ft R +als Anzahl der Haupt-Seiten der Relation zugewiesen wird. +.LP +.ft B +modify +.ft R +berechnet, wieviele Haupt-Seiten ben\o'o"'tigt +werden, um die bestehenden Tupel unter Ber\o'u"'cksichtigung des +spezifizierten +.ft B +fillfactor +.ft R +so unterzubringen, dass keine \o'U"'berlauf-Seiten im Original notwendig sind. +Wenn die Zahl kleiner als +.ft B +minpages +.ft R +ist, dann wird +.ft B +minpages +.ft R +statt dieses Wertes verwendet. +.LP +Zum Beispiel: +.DS +modify abgabe to hash on name where fillfactor = 50, + minpages = 1 + +modify abgabe to hash on name where minpages = 150 +.DE +Im ersten Fall garantieren wir, dass nicht mehr +Seiten als notwendig, bei 50% Belegung, benutzt werden. +Der zweite Fall ist typisch +f\o'u"'r die Modifizierung einer leeren oder fast +leeren Relation. +Wenn n\o'a"'herungsweise die maximale Gr\o'o"'sse +einer Relation bei ihrer Erstellung bekannt ist, +kann +.ft B +minpages +.ft R +dazu +benutzt werden, von Anfang an die Gr\o'o"'sse der Relation +auf dem Speicher freizuhalten. +.LP +Es ist noch eine andere Option f\o'u"'r +.ft B +hash +.ft R +zul\o'a"'ssig, +die sogenannte +.ft B +maxpages +.ft R + . Ihre Syntax ist die gleiche, wie f\o'u"'r +.ft B +minpages +.ft R + . Sie kann benutzt werden, um die maximale +Anzahl der Haupt-Seiten festzulegen. +.NH 4 +.ft B +Verdichtung (compression) +.ft R +.LP +Die drei Speicherstrukturen +("heap", "hash", "isam") k\o'o"'nnen zus\o'a"'tzlich +durch +.ft B +compression +.ft R +erg\o'a"'nzt +werden. +Das geschieht, indem die +Speicherstrukturen als +.ft B +cheap +.ft R +, +.ft B +chash +.ft R +und +.ft B +cisam +.ft R +geschrieben werden. +Verdichtung reduziert +intern den Speicherplatz f\o'u"'r jedes Tupel. +Die gegenw\o'a"'rtige "compression"-Technik +unterdr\o'u"'ckt nachlaufende +.ft B +blanks +.ft R +(Leerzeichen) in +den Zeichenkettten-Dom\o'a"'nen. +Die Verwendung von +.ft B +compression +.ft R +verlangt niemals +mehr Platz und normalerweise wird Speicherplatz +gewonnen und k\o'o"'nnen die Ausf\o'u"'hrungszeit verk\o'u"'rzt. +Dazu ein Beispiel: +.IP +modify abgabe to cisam on name where fillfactor = 100 +.LP +Es wird +.ft B +abgabe +.ft R +in eine komprimierte +.ft B +isam +.ft R +\-Struktur ver\o'a"'ndert und jede Seite +so weit als m\o'o"'glich gef\o'u"'llt. +Mit +.ft B +compression +.ft R +kann jedes Tupel +eine verschiedene, komprimierte L\o'a"'nge erhalten. +Dadurch muss die Zahl der Tupel, +die in einer Seite untergebracht werden k\o'o"'nnen, +davon abh\o'a"'ngen, wie erfolgreich die Verdichtung +ausgef\o'u"'hrt werden konnte. +.LP +Verdichtete Relationen sind aufwendiger zu aktualisieren. +Wenn ein +.ft B +replace +.ft R +auf eine oder mehrere Dom\o'a"'nen +ausgef\o'u"'hrt wird und das komprimierte Tupel war k\o'u"'rzer, +dann muss \*(yy\ einen neuen Platz f\o'u"'r das Tupel finden. +.NH 4 +.ft B +Zwei Varianten zu einem Problem +.ft R +.LP +Zur Erinnerung, doppelte Tupel werden bei einer +.ft B +heap +.ft R +\-Relation nicht +gel\o'o"'scht. +Verschiedentlich ist es w\o'u"'nschenswert, +sie zu l\o'o"'schen und +eine +.ft B +heap +.ft R +\-Relation zu sortieren. +Ein Weg dazu ist, +die Relation zu +.ft B +isam +.ft R +unter Angabe +der Ordnungsmerkmale ( +.ft B +keyed domains +.ft R +) zu modifizieren. +Eine Alternative dazu ist entweder die +Verwendung von +.ft B +heapsort +.ft R +oder +.ft B +cheapsort. +.ft R +Zum Beispiel: +.DS I +modify abgabe to heapsort on name, ext +.DE +.LP +Damit wird die Relation nach +"name" und dann nach "ext" sortiert. +Die Tupel werden zus\o'a"'tzlich nach den restlichen Dom\o'a"'nen, +in der Reihenfolge +ihrer urspr\o'u"'nglichen Angabe +beim +.ft B +create +.ft R +\-Statement, sortiert, +so dass in diesem Fall die Relation nach +"name", dann "ext" und dann "wert" sortiert wird. +Doppelte Tupel werden entfernt. +Die Relation wird als +.ft B +heap +.ft R +verlassen. +.ft B +heapsort +.ft R +und +.ft B +cheapsort +.ft R +sind vorgesehen +zum Sortieren von tempor\o'a"'ren Relationen, bevor sie gedruckt und +gel\o'o"'scht werden. +Dies ist wesentlich effektiver, +als die Modifizierung zu "isam", +da \*(yy\ kein "directory" erzeugt, +in dem die Schl\o'u"'sselinformationen f\o'u"'r +jede Seite enthalten sind. +Die Relation wird +.ft B +nicht +.ft R +in der Sortierung gehalten, +wenn anschliessend \o'A"'nderungen erfolgen. +.LP +Beispiele: +.br +Hier ist eine Sammlung von Beispielen und Erl\o'a"'uterungen +zur Abarbeitungseffizienz +jeder Query. +Die Queries basieren auf den +Relationen: +.DS I +teile(tnum, tname, farbe, gewicht, menge) + +lieferung(lnum, pnum, jnum, liefdat, menge) + +range of t is teile +range of l is lieferung + +modify teile to hash on tnum +modify lieferung to hash on lnum,jnum + +retrieve (t.all) where t.tnum = 10 + +.DE +\*(yy\ erkennt, dassteile +auf +.ft B +tnum +.ft R +via +.ft B +hash +.ft R +geschl\o'u"'sselt ist und geht direkt +auf die Seite, in der "teile" mit der Nummer 10 gespeichert ist. +.IP +retrieve (t.all) where t.tname = "magnetband" +.LP +\*(yy\ liest die vollst\o'a"'ndige Relation +und sucht den angegebenen "tname". +.IP +retrieve (t.all) where t.tnum < 10 and t.tnum > 5 +.LP +\*(yy\ liest die vollst\o'a"'ndige Relation, +weil kein exakter Wert f\o'u"'r "tnum" +gegeben war. +.IP +retrieve (l.liefdat) where l.lnum = 471 and l.jnum = 1008 +.LP +\*(yy\ erkennt, dass +.ft B +lieferung +.ft R +auf die Kombination von +.ft B +lnum +.ft R +und +.ft B +jnum +.ft R +via +.ft B +hash +.ft R +geschl\o'u"'sselt ist und +geht direkt zur richtigen Seite. +.DS I +retrieve (l.liefdat) where l.lnum = 471 +.DE +.LP +\*(yy\ liest die gesamte +Relation. +.ft B +lieferung +.ft R +ist auf die +Kombination von +.ft B +lnum +.ft R +und +.ft B +jnum +.ft R +via +.ft B +hash +.ft R +geschl\o'u"'sselt. +Jedoch wurde \*(yy\ nur ein Wert von +beiden gegeben, es kann den +Vorteil der Speicherstruktur +nicht nutzen. +.DS I +retrieve (t.tname, l.liefdat) where +t.tnum = l.tnum and l.lnum = 471 and l.jnum = 1008 +.DE +.LP +\*(yy\ nutzt den Vorteil beider +Speicherstrukturen. +Es findet zuerst alle Tupel +.ft B +l.tnum +.ft R +und +.ft B +l.liefdat +.ft R +, bei denen l.lnum = 471 und +l.jnum = 1008 ist. +Danach \o'u"'berpr\o'u"'ft es alle Tupel +t.tname, bei denen t.tnum gleich dem +korrekten Wert ist. +.LP +Dieses Beispiel illustriert, dass es manchmal +eine gute Idee ist, eine Relation mit den +Dom\o'a"'nen auf +.ft B +hash +.ft R +zu modifizieren, die mit +einer anderen Relation verbunden ( +.ft B +joined +.ft R +) sind. +In diesem Fall w\o'a"'re das die Frage nach +t.tnum = l.tnum. +.LP +.ft B +Zusammengefasst: +.ft R +.LP +Um den Vorteil einer +.ft B +hash +.ft R +\-Struktur nutzen zu k\o'o"'nnen, +ben\o'o"'tigt \*(yy\ einen exakten Wert +f\o'u"'r jede Schl\o'u"'sseldom\o'a"'ne. +Ein exakter Wert ist soetwas +wie: +.IP +l.lnum = 471 +.br +l.tnum = t.tnum +.LP +Ein exakter Wert ist aber nicht: +.IP +l.lnum >= 471 +.br +(l.lnum = 10 or l.lnum = 20) +.LP +Wir wollen nun unsere Aufmerksamkeit +einigen F\o'a"'llen zur Anwendung von "isam" widmen: +.DS I +modify lieferung to isam on lnum,liefdat +retrieve (l.all) where l.lnum = 471 +and l.liefdat > "75-12-31" +and l.liefdat < "77-01-01" +.DE +.LP +Da +.ft B +lieferung +.ft R +auf +.ft B +lnumund +.ft R +dann +auf +.ft B +liefdat +.ft R +sortiert ist, kann \*(yy\ +den ganzen Vorteil einer +.ft B +isam +.ft R +\-Struktur zur Lokalisierung des Bereichs +von +.ft B +lieferung +.ft R +, der die Query befriedigt, +nutzen. +.IP +retrieve (l.all) where l.lnum = 471 +.LP +Im Gegensatz zu +.ft B +hash +.ft R +, kann eine +.ft B +isam +.ft R +\-Struktur +noch verwendet werden, wenn nur der erste Schl\o'u"'ssel +beschafft wird. +.IP +retrieve (l.all) where l.lnum > 400 and l.lnum < 500 +.LP +Wieder wird \*(yy\ den Vorteil der Struktur nutzen. +.DS I +retrieve (l.all) where l.liefdat >= "75-12-31" and +l.liefdat <= "77-01-01" +.DE +.LP +Hier wird \*(yy\ die vollst\o'a"'ndige Relation lesen. +Das geschieht, weil der erste Schl\o'u"'ssel (lnum) nicht +in der Query vorgeschlagen wurde. +.LP +.ft B +Zusammengefasst: +.ft R +.LP +.ft B +isam +.ft R +gestattet die Beschleunigung des Zugriffs +sowohl zu exakten Werten, als auch zu +Wertebereichen. +Das funktioniert solange, wie wenigstens der erste Schl\o'u"'ssel +vom Nutzer vorgegeben wird. +.LP +Um festzustellen, wo die Tupel +in einer "isam"-Relation stehen, +durchsucht \*(yy\ das "isam-directory" dieser +Relation. +Wenn eine Relation nach +.ft B +isam +.ft R +modifiziert wird, +werden die Tupel zuerst sortiert und dabei die +doppelten Tupel +gel\o'o"'scht. +Als n\o'a"'chstes wird die Relation +(unter Verwendung des +.ft B +fillfactor +.ft R +), beginnend mit +Block 0, 1, 2... und so weiter, entsprechend der +ben\o'o"'tigten Seitenanzahl gef\o'u"'llt. +.LP +Jetzt wird das +.ft B +directory +.ft R +aufgebaut. +Die Schl\o'u"'sseldom\o'a"'nen des ersten Tupels +jeder Seite werden eingesammelt und +in ein +.ft B +directory +.ft R +(in der Relation +auf Platte gespeichert) gebracht. +Das +.ft B +directory +.ft R +wird nicht eher +ge\o'a"'ndert, als bis die n\o'a"'chste Modifizierung angewiesen wurde. +.LP +Wann immer ein Tupel zu einer Relation hinzugef\o'u"'gt wird, +wird das +.ft B +directory +.ft R +durchsucht, um die Seite zu finden, +in der das neue Tupel untergebracht werden muss. +Damit bleiben in dieser Seite die einzelnen +Tupel +.ft B +nicht +.ft R +genau sortiert. +Das ist auch mit der n\o'a"'herungsweisen ( +.ft B +approximately +.ft R +) Sortierung im obigen Kapitel gemeint. +.NH 4 +.ft B +Vergleich von heap, hash und isam +.ft R +.LP +Wir wollen einmal die Vor- und Nachteile +der einzelnen Speicherstrukturen +vergleichen. +Eine Relation wird immer als +.ft B +heap +.ft R +erzeugt. +.ft B +heap +.ft R +ist die g\o'u"'nstigste +Struktur f\o'u"'r das erstmalige +Auff\o'u"'llen einer Relation bei Verwendung von +.ft B +copy +.ft R +oder +.ft B +append. +.ft R +.LP +Der Platz von gel\o'o"'schten Tupeln bei +.ft B +heap +.ft R +wird nur in der letzten Seite wiederverwendet. +Ein Test auf doppelte Tupel wird bei +.ft B +heap +.ft R +\-Relationen nicht ausgef\o'u"'hrt. +.LP +"hash" ist vorteilhaft f\o'u"'r die Lokalisierung von Tupeln, +sofern sie in der Qualifikation ( +.ft B +where +.ft R +\-Klausel) durch einen exakten Wert +referenziert werden. +Die Haupt-Seite von Tupeln kann mit einem vorgegebenen +Wert leicht ermittelt werden. +.LP +.ft B +isam +.ft R +ist gebr\o'a"'uchlich f\o'u"'r exakte Werte und Wertebereiche. +Weil das "isam-directory" durchsucht werden muss, +um die Tupel zu lokalisieren, ist +.ft B +isam +.ft R +nicht so effektiv wie +.ft B +hash. +.ft R +.NH 4 +.ft B +\o'U"'berlauf-Seiten +.ft R +.LP +Wenn ein Tupel eingef\o'u"'gt wird +und sich kein freier Raum mehr auf der +Haupt-Seite einer Relation befindet, dann wird eine +\o'U"'berlauf-Seite erzeugt. +Wenn mehr Tupel eingef\o'u"'gt werden, als eine \o'U"'berlauf-Seite aufnimmt, +werden weitere Seiten angeh\o'a"'ngt. +Obwohl \o'U"'berlauf-Seiten notwendig sind, vermindern sie +die Geschwindigkeit +des Systems bei Ausf\o'u"'hrung +von Recherchen und +.ft B +update +.ft R +'s. +.LP +Beispielsweise wollen wir annehmen das "lieferung" +auf +.ft B +lnum +.ft R +via +.ft B +hash +.ft R +geschl\o'u"'sselt wird und 10 Haupt- +Seiten hat. +Angenommen der Wert lnum = 3 f\o'a"'llt auf Seite 7. +Um alle Tupel mit lnum = 3 zu finden, bezieht \*(yy\ in die Suche +die Haupt-Seite 7 und alle zu Seite 7 geh\o'o"'rigen \o'U"'berlauf- +Seiten ein +(, sofern es welche gibt). +Je mehr \o'U"'berlauf-Seiten einbezogen werden m\o'u"'ssen, +um so mehr Zeit wird ben\o'o"'tigt, um nach lnum = 3 zu recherchieren. +Um doppelte Tupel bei +.ft B +isam +.ft R +und +.ft B +hash +.ft R +l\o'o"'schen zu k\o'o"'nnen, +muss ebenfalls bei +.ft B +append +.ft R +und +.ft B +replace +.ft R +die Suche +\o'u"'ber alle Seiten ausgef\o'u"'hrt werden. +.LP +Wenn eine +.ft B +hash +.ft R +\- oder +.ft B +isam +.ft R +\-Relation zu viele \o'U"'berlauf- +Seiten +hat, empfiehlt es sich, sie erneut zu +.ft B +hash +.ft R +oder +.ft B +isam +.ft R +zu modifizieren. +Damit wird die Relation bereinigt +und es werden soviele \o'U"'berlauf-Seiten als m\o'o"'glich eli\%miniert. +.NH 4 +.ft B +Eindeutige Schl\o'u"'ssel +.ft R +.LP +Bei der Wahl des Schl\o'u"'ssels ( +.ft B +keyed domain +.ft R +) einer Relation +ist es w\o'u"'nschenswert, +weitgehende +Eindeutigkeit zu erreichen. +Beispielsweise treten bei Personalnummern +keine doppelten Nummern auf, +w\o'a"'hrend bei solchen Begriffen, wie +"Farbe" nur einige wenige +verschiedene Werte und +manchmal, wie bei "Geschlecht" +bekanntermassen nur zwei Werte auftreten +k\o'o"'nnen. +.LP +Wenn eine Relation auf die Dom\o'a"'ne "geschlecht" +via +.ft B +hash +.ft R +geschl\o'u"'sselt wird, k\o'o"'nnen +sie erwarten, dass alle m\o'a"'nnlichen Objekte auf einer Haupt-Seite und dazugeh\o'o"'rigen +\o'U"'berlauf-Seiten untergebracht werden, ebenso auch alle weiblichen. +Mit einer +.ft B +hash +.ft R +\-Relation gibt es keine L\o'o"'sung dieses +Problems. +Es muss ein Kompromiss zwischen +den in der Qualifikation am h\o'a"'ufigsten +verwendeten +Schl\o'u"'sseln und der Eindeutigkeit der +Schl\o'u"'sselwerte gefunden werden. +.LP +Da der Vorteil der +.ft B +isam +.ft R +\-Struktur +solange genutzt werden kann, als zumindest der +erste Schl\o'u"'ssel vorgegeben wird, k\o'o"'nnen +unter Umst\o'a"'nden weitere +Dom\o'a"'nen zum Schl\o'u"'ssel +hinzugef\o'u"'gt werden, +um die Eindeutigkeit desselben zu erh\o'o"'hen. +Nehmen wir beispielsweise an, dass die +Relation "lieferung" nur 10 verschiedene Lieferanten, aber tausende Tupel hat. +Die Wahl einer +.ft B +isam +.ft R +\-Struktur, mit den Schl\o'u"'sseln +.ft B +lnum +.ft R +und +.ft B +jnum +.ft R +wird wahrscheinlich viel mehr eindeutige Schl\o'u"'ssel ergeben. +Wie auch immer, die Gr\o'o"'sse des "directories" wird +zunehmen und folglich dauert die +Suche immer l\o'a"'nger. +Wenn sie zur Erh\o'o"'hung der +Eindeutigkeit des Schl\o'u"'ssels weitere +Dom\o'a"'nen zu Schl\o'u"'ssel hinzuf\o'u"'gen, +versuchen sie +m\o'o"'glichst die k\o'u"'rzesten auszuw\o'a"'hlen. +.NH 4 +.ft B +Systemkataloge +.ft R +.LP +\*(yy\ verwendet sieben Kataloge +( +.ft B +relation +.ft R +, +.ft B +references +.ft R +, +.ft B +attribute +.ft R +, +.ft B +indexes +.ft R +, +.ft B +tree +.ft R +, +.ft B +protect +.ft R +und +.ft B +intgrities +.ft R +), um Datenbanken +zu verwalten und zu organisieren. +Der +.ft B +relation +.ft R +\-Katalog hat ein Tupel f\o'u"'r +jede Relation in der Datenbank. +Der +.ft B +attribute +.ft R +\-Katalog hat ein Tupel +f\o'u"'r jedes Attribut in jeder +Relation. +Der +.ft B +indexes +.ft R +\-Katalog +hat ein Tupel f\o'u"'r jeden +Sekund\o'a"'rindex. +.LP +\*(yy\ greift auf diese Kataloge +in einer bestimmten Art und Weise zu. +Das Programm +.ft B +sysmod +.ft R +sollte verwendet werden, +um diese Kataloge auf vordefinierten +Dom\o'a"'nen via +.ft B +hash +.ft R +zu modifizieren. +Um +.ft B +sysmod +.ft R +anzuwenden, gibt der +Datenbankadministrator ein +.sp 1 +% sysmod Datenbankname +.sp 1 +.ft B +sysmod +.ft R +sollte unmittelbar +nach der Gr\o'u"'ndung einer Datenbank +abgearbeitet werden, bzw. nachdem die Relationen erzeugt wurden. Die Datenbank +ist nun aufgebaut. +Es ist nicht ausreichend, +.ft B +sysmod +.ft R +einmal zu starten und es dann zu vergessen. +Ein wiederholter Start von +.ft B +sysmod +.ft R +\o'u"'berarbeitet +die Systemkataloge. +Durch die Anwendung werden die +meisten \o'U"'berlauf-Seiten gel\o'o"'scht +und die Systemantwortzeit in vielerlei Hinsicht +verbessert. +.NH 3 +.ft B +Sekund\o'a"'rindizes +.ft R +.LP +Die Verwendung einer +.ft B +isam +.ft R +- oder +.ft B +hash +.ft R +\-Struktur +gestattet, schnell die Tupel einer +Relation zu finden und die Werte entsprechend +der Schl\o'u"'seldom\o'a"'nen zu \o'u"'bergeben. +Manchmal ist das aber nicht genug. +Nehmen wir beispielsweise an, +wir h\o'a"'tten die "abgabe"-Relation +.IP +abgabe(name, wert, ext) +.LP +auf +.ft B +name +.ft R +via +.ft B +hash +.ft R +geschl\o'u"'sselt. +Es ergibt sich ein schneller Zugriff +f\o'u"'r Queries mit einem exakten Wert f\o'u"'r +.ft B +name +.ft R +in der Qualifikation ( +.ft B +where +.ft R +\-Klausel). +Doch was ist, falls wir den +Queries einen exakten Wert f\o'u"'r +.ft B +ext +.ft R +\o'u"'bergeben wollen? +.LP +.ft B +abgabe +.ft R +kann entweder f\o'u"'r +.ft B +name +.ft R +oder +.ft B +ext +.ft R +auf +.ft B +hash +.ft R +gesetzt werden, wir k\o'o"'nnen w\o'a"'hlen, +was anwendungsfreundlicher ist +und +.ft B +abgabe +.ft R +auf diese Dom\o'a"'ne setzen. +Die andere Dom\o'a"'ne (sagen wir "ext") kann einen +Sekund\o'a"'rindex (secondary index) haben. +Ein Sekund\o'a"'rindex ist eine Relation, die die +exakte Position der Tupel zu jedem +.ft B +ext +.ft R +in der Relation +.ft B +abgabe +.ft R +enth\o'a"'lt. +.LP +Das Kommando zur Erzeugung eines +Sekund\o'a"'rindexes ist: +.IP +index on abgabe is abgext (ext) +.LP +Die allgemeine Form lautet: +.br +.sp 1 +index on relation_name is secondary_index_name (domains) +.sp 1 +Nun beauftragen wir \*(yy\, +einen Sekund\o'a"'rindex in der Relation +.ft B +abgabe +.ft R +zu erzeugen. +Die Dom\o'a"'ne die indiziert werden soll, ist +.ft B +ext. +.ft R +Indizes werden in drei Schritten gebildet: +.IP 1. +.ft B +abgext +.ft R +erzeugt ein +.ft B +heap. +.ft R +.IP 2. +F\o'u"'r jedes +Tupel in +.ft B +abgabe +.ft R +, wird ein Tupel +mit dem Wert f\o'u"'r +.ft B +ext +.ft R +und der genauen Position +des korrespondierenden Tupels in +.ft B +abgabe +.ft R +in +.ft B +abgext +.ft R +eingef\o'u"'gt. +.IP 3. +Standardm\o'a"'ssig wird +.ft B +abgext +.ft R +zu +.ft B +isam +.ft R +modifiziert. +.LP +Wenn wir jetzt die Query +.DS +range of a is abgabe +retrieve(a.wert) where a.ext = 207 +.DE +starten, wird \*(yy\ automatisch zuerst in +.ft B +abgext +.ft R +nachsehen, um ext = 207 zu finden. +Wenn es dort ein Tupel findet, geht es direkt +zum Tupel in der +.ft B +abgabe +.ft R +\-Relation. +Da +.ft B +abgext +.ft R +auf +.ft B +isam +.ft R +f\o'u"'r +.ft B +ext +.ft R +gesetzt wurde, wird die +Suche nach ext = 207 nat\o'u"'rlich ebenfalls schnell +erledigt sein. +.LP +Wenn sie die Query +.IP +retrieve(a.wert) where a.name = "frank" +.LP +starten, dann wird \*(yy\ in der +.ft B +hash +.ft R +\-Struktur der Relation +.ft B +abgabe +.ft R +versuchen fortzufahren, um die qualifizierten Tupel zu lokalisieren. +.LP +Da Sekund\o'a"'rindizes eigenst\o'a"'ndige Relationen sind, +k\o'o"'nnen sie auch (entweder) +.ft B +hash, isam, chash +.ft R +oder +.ft B +cisam +.ft R +sein. +Es ist nicht vern\o'u"'nftig, einen Sekund\o'a"'rindex auf +.ft B +heap +.ft R +zu setzen. +.LP +Die Beurteilung, welche Struktur geeignet ist, ergibt sich +aus den Erkenntnissen, +die zuvor diskutiert wurden: +.sp 1 +Werden die Dom\o'a"'nen durch exakte Werte referenziert? +.br +Werden sie durch Wertebereiche referenziert? +.br +etc. +.LP +In dem Fall, wo die +.ft B +ext +.ft R +\-Dom\o'a"'ne +durch exakte Werte referenziert und +die Relation beinahe gef\o'u"'llt ist, k\o'o"'nnen wir folgendes tun: +.DS I +modify abgext to hash on ext where fillfactor = 100 +and minpages = 1 +.DE +Sekund\o'a"'rindizes stellen in \*(yy\ +einen Weg dar, \o'u"'ber Dom\o'a"'nen +auf Tupel zuzugreifen, +die keine Schl\o'u"'ssel sind. +Eine Relation kann eine beliebige Anzahl von +Sekund\o'a"'rindizes haben und ausserdem kann +jeder Sekund\o'a"'rindex ein Index auf bis +zu sechs Dom\o'a"'nen einer Prim\o'a"'rrelation sein. +.LP +Wenn ein Tupel in einer Prim\o'a"'rrelation +ersetzt (replaced), gel\o'o"'scht (deleted) +oder angeh\o'a"'ngt (appended) wird, +m\o'u"'ssen alle Sekund\o'a"'rindizes auch aktualisiert +werden, +die Indizes +kosten was. +Sie erh\o'o"'hen den +Aufwand zur Aktualisierung +der Prim\o'a"'rrelation, aber +sie k\o'o"'nnen den Aufwand zum Auffinden von Tupel +in der Prim\o'a"'rrelation erheblich senken. +.LP +Ob ein Sekund\o'a"'rindex die Geschwinigkeit +der Recherche erh\o'o"'ht oder nicht, h\o'a"'ngt von +der Eindeutigkeit der Werte +der indizierten Dom\o'a"'nen +ab. +Die Hauptfrage bleibt, ob eine indirekte +Suche \o'u"'ber den Index effizienter als +das Durch\%suchen der gesamten +Prim\o'a"'rrelation ist. +Allgemein ist es effektiver, +wenn die Anzahl der Tupel, die die Qualifikation ( +where +\-Klausel) +erf\o'u"'llen, kleiner ist, als die Gesamtzahl der Seiten +(Haupt- und \o'U"'berlauf-Seiten) der +Prim\o'a"'rrelation. +.LP +Beispielsweise wollen wir h\o'a"'ufig alle +Personen wissen, die weniger als f\o'u"'nf Mark +verdienen, dann beachten sie den erzeugten Index +.IP +index on abgabe is abgwert (wert) +.LP +Standardm\o'a"'ssig wird +.ft B +abgwert +.ft R +eine +.ft B +isam +.ft R +-Struktur auf +.ft B +wert. +.ft R +Wenn \*(yy\ die Query +.IP +retrieve(a.name) where a.wert < 5.0 +.LP +ausf\o'u"'hrt, wird auf a.wert < 5.0 im +Sekund\o'a"'rindex lokalisiert und f\o'u"'r jedes Tupel das +gefunden wird, das korrespondierende Tupel +in +.ft B +abgabe +.ft R +geholt. +Die Tupel in +.ft B +abgwert +.ft R +sind nach +wert sortiert, die Tupel in +.ft B +abgabe +.ft R +jedoch nicht. +Damit wird im Allgemeinen jedes Tupel +von +.ft B +abgabe +.ft R +\o'u"'ber +.ft B +abgwert +.ft R +adressiert, +die sich aber auf verschiedenen Seiten befinden. +Solche Recherchen \o'u"'ber einen Sekund\o'a"'rindex +erfordern mehr Seitenleseoperationen (IO's), als +wenn die Prim\o'a"'rrelation +.ft B +abgabe +.ft R +sequentiell gelesen worden w\o'a"'re. +In solchen F\o'a"'llen ist die Erzeugung +eines Sekund\o'a"'rindex' nicht zu empfehlen. +.NH 3 +.ft B +Wiederherstellung (Recovery) und +.br + Aktualisierung (Update) +.ft R +.LP +.NH 4 +.ft B +Einf\o'u"'hrung +.ft R +.LP +\*(yy\ wurde sorgf\o'a"'ltig entworfen, um +die Integrit\o'a"'t der Datenbank bei bestimmten +Arten von Systemfehlern +zu sch\o'u"'tzen. +Um das \*(yy\ zu erm\o'o"'glichen, +wird bei der Ausf\o'u"'hrung von Aenderungen mit +dem sogenannten +.ft B +deferred update +.ft R +(verz\o'o"'gerte Aktualisierung) +oder +.ft B +batchfile update +.ft R +(gepufferte Dateiaktualisierung) gearbeitet. +Weiterhin gibt es in \*(yy\ zwei +Programme +.ft B +restore +.ft R +(wiederherstellen) und +.ft B +purge +.ft R +(reinigen), die verwendet +werden k\o'o"'nnen, +um nach aufgetretenen Systemfehlern die Datenbank +zu testen und wieder in Ordnung zu bringen. +Wir wollen zuerst diskutieren, +wie "deferred updates" erzeugt und ausgef\o'u"'hrt +werden und uns danach mit der Verwendung von +.ft B +purge +.ft R +und +.ft B +restore +.ft R +besch\o'a"'ftigen. +.NH 4 +.ft B +Deferred Update und Batch Update +.ft R +.LP +.NH 5 +.ft B +\o'U"'bersicht +.ft R +.LP +.ft B +deferred update +.ft R +kann man mit verz\o'o"'gerter Aktualisierung +\o'u"'bersetzen. +.IP +Ein +.ft B +append +.ft R +\-, +.ft B +replace +.ft R +\- oder +.ft B +delete +.ft R +\-Kommando wird +in vier Schritten ausgef\o'u"'hrt: +.IP 1. +Ein leeres +.ft B +batchfile +.ft R +(Pufferfile) wird erzeugt. +.IP 2. +Das Kommando wird ausgef\o'u"'hrt +und jede Aenderung der Relation wird in +das +.ft B +batchfile +.ft R +geschrieben. +.IP 3. +Das +.ft B +batchfile +.ft R +wird gelesen und +die Relation und ihre Sekund\o'a"'rindizes (falls vorhanden) +werden aktualisiert. +.IP 4. +Das +.ft B +batchfile +.ft R +wird zerst\o'o"'rt und \*(yy\ +kehrt zum Nutzer zur\o'u"'ck. +.LP +Das +.ft B +deferred update +.ft R +verz\o'o"'gert die wirkliche +\o'A"'nderung bis zum tats\o'a"'chlichen Ende +der Query. +Diese Vorgehensweise hat drei Vorteile: +.NH 5 +.ft B +Beseitigung der Auswirkung von Systemfehlern +.ft R +.LP +Falls das System w\o'a"'hrend einer Aktualisierung +zusammenbricht ( +.ft B +crash +.ft R +), +kann das \*(yy\-Recovery-Programm entscheiden, entweder +die \o'A"'nderung zu Ende auszuf\o'u"'hren oder durch +.ft B +back out +.ft R +(Ablehnung) die \o'A"'nderung zur\o'u"'ckzusetzen und die +Relation in dem Zustand zu belassen, in dem sie sich vorher +befand. +.NH 4 +.ft B +Die Verhinderung endloser Queries +.ft R +.LP +Falls +.ft B +abgabe +.ft R +ein +.ft B +heap +.ft R +w\o'a"'re und die Query +.DS +range of a is abgabe +append to abgabe(a.all) +.DE +w\o'u"'rde ohne +.ft B +deferred update +.ft R +ausgef\o'u"'hrt, +dann wird die Ausf\o'u"'hrung erst bei \o'U"'berlauf +des Plattenspeichers bzw. wenn kein freier +Platz mehr vorhanden ist, beendet! +Das geschieht deshalb, weil \*(yy\ +mit dem Lesen der Relation vorn anf\o'a"'ngt +und jedes Tupel an das Ende +angeh\o'a"'ngt (append) wird. +Es w\o'u"'rde bald beginnen, die Tupel zu lesen, +die kurz vorher angeh\o'a"'ngt worden sind und +unendlich fortsetzen, um +das Ende zu erhaschen, das immer +wieder entschwindet. +.LP +Obwohl diese Query sicherlich nicht +typisch ist, illu\%striert sie das Problem. +Es gibt bestimmte Klassen von Queries, +bei denen Probleme durch aktualisierte +Ablagen ber\o'u"'hrt werden, die +nicht pr\o'a"'zise definiert sind. +Mit dem +.ft B +deferred update +.ft R +kann garantiert werden, dass die Ergebnisse konsistent +und logisch sind. +.NH 5 +.ft B +Beschleunigung der \o'A"'nderungszeiten +.br + von Sekund\o'a"'rindizes +.ft R +.LP +Sekund\o'a"'rindizes k\o'o"'nnen schneller +aktualisiert werden, +wenn alle \o'A"'nderungen auf einmal ausgef\o'u"'hrt werden, +anstatt jede \o'A"'nderung einzeln. +Das schliesst auch den Schutz ein, +dass der Sekund\o'a"'rindex die Uebereinstimmung +mit der Prim\o'a"'rrelation beh\o'a"'lt. +.NH 5 +.ft B +Abschalten des deferred update +.ft R +.LP +Wenn sie von diesen Argumenten nicht +\o'u"'berzeugt wurden, ge\%stattet \*(yy\ +auch, das "deferred update" abzuschalten! +Tats\o'a"'chlich gibt es sicher F\o'a"'lle, wo es +angebracht ist (aber nat\o'u"'rlich +nicht notwendig), die \o'A"'nderung +direkt auszuf\o'u"'hren, d.h. die Relation wird +w\o'a"'hrend der Query ge\o'a"'ndert. +.LP +Um die direkte \o'A"'nderung anzuwenden, m\o'u"'ssen sie +die Erlaubnis des \*(yy\- +Systemadministrators haben. +Wenn sie das +.ft B +-b +.ft R +\-Flag beim Start von \*(yy\ verwenden, +wird das +.ft B +deferred update +.ft R +ausgeschaltet. +.sp 1 +% quel -b meindb +.sp 1 +\*(yy\ verwendet die direkte \o'A"'nderung nur f\o'u"'r Relationen ohne +Sekund\o'a"'rindizes. +Die Anwendung des +.ft B +deferred update +.ft R +wird f\o'u"'r Relationen +mit Sekund\o'a"'rindex +stillschweigend immer benutzt. +Bei Nutzung des +.ft B +-b +.ft R +\-Flag m\o'u"'ssen sie +auf die oben genannten Vorteile der verzichten. +In den meisten F\o'a"'llen sollte man +das +.ft B +-b +.ft R +\-Flag +.ft B +nicht anwenden. +.ft R +.sp 1 +Wenn sie \*(yy\ so benutzen, dass +sie interaktiv nur ein Tupel +eingeben oder \o'a"'ndern, ist +es etwas g\o'u"'nstiger das +.ft B +deferred update +.ft R +abzuschalten. +Wenn das System w\o'a"'hrend einer \o'A"'nderung +zusammenbricht, ist die eingebende Person +in der Lage, festzustellen, ob das +Tupel ge\o'a"'ndert wurde oder nicht. +.NH 4 +.ft B +Restore +.ft R +.LP +\*(yy\ ist so entworfen, dass nach fast allen +Typen von Systemabst\o'u"'rzen +ein Recovery m\o'o"'glich ist, +falls das \*(xx\-File-System +konsistent geblieben ist. +Das betrifft die \o'A"'nderungskommandos, das +.ft B +update +.ft R +\-, +.ft B +create +.ft R +\-, +.ft B +destroy +.ft R +\-, +.ft B +modify +.ft R +\- und auch das +.ft B +index +.ft R +\-Kommando. +.LP +\*(yy\ wurde auf +.ft B +perfekte Sicherheit +.ft R +entworfen. +Wenn irgend\%eine Nicht\o'u"'bereinstimmung entdeckt +oder irgendein Mangel von \*(xx\ zur\o'u"'ckgegeben +wurde, +generiert \*(yy\ eine System-Error-Mitteilung +(SYSERR) und bricht ab. +.LP +Wenn \*(xx\ zusammenbricht, w\o'a"'hrend \*(yy\ +arbeitet, oder ein \*(yy\-SYSERR auftritt, +ist es generell sinnvoll, +dass der Datenbankadministrator das Kommando +.sp 1 +% restore data_base_name +.sp 1 +gibt. Das Restore-Programm erf\o'u"'llt +folgende Funktionen: +.IP 1. +Es pr\o'u"'ft die +.ft B +"batchfiles". +.ft R +Wenn es eins findet, pr\o'u"'ft es jedes, +um festzustellen, ob es komplett ist. +Wenn der System-crash auftrat, w\o'a"'hrend +das +.ft B +batchfile +.ft R +gerade gelesen und auf die Datenbank ausgegeben wurde, +dann holt +.ft B +restore +.ft R +die \o'A"'nderung nach. +Falls andererseits das +.ft B +batchfile +.ft R +noch +nicht vollst\o'a"'ndig war, wird es einfach zerst\o'o"'rt, +damit ist es so, als w\o'a"'re die Query noch nicht ausgef\o'u"'hrt. +.IP 2. +Test auf unvollst\o'a"'ndige +.ft B +modify +.ft R +\-Kommandos. +Dieser Schritt ist entscheidend. +Er garantiert, dass sie entweder die Relation +so vorfinden, wie vor der Modifikation, +oder +.ft B +restore +.ft R +ist in der Lage das +.ft B +modify +.ft R +-Kommando zu vervollst\o'a"'ndigen. +.ft B +modify +.ft R +arbeitet so, dass es eine neue Kopie +der Relation in der neuen Struktur erzeugt. +Wenn es dann fertig ist, ersetzt es die alte +Relation, es speichert die neuen Informationen in ein +.ft B +modify batchfile +.ft R +(modifiziertes Pufferfile). +Das bef\o'a"'higt +.ft B +restore +.ft R +den Stand unfertiger Modifizierungen +festzustellen. +.IP 3. +Test auf die Uebereinstimmung der Systemrelationen. +Dieser Test wird verwendet, um +.ft B +destroy +.ft R +\-Kommandos zu vervollst\o'a"'ndigen, +.ft B +create +.ft R +\-Kommandos zur\o'u"'ckzusetzen +und +.ft B +index +.ft R +\-Kommandos zur\o'u"'ckzusetzen oder zu vervollst\o'a"'ndigen, +die durch einen System-crash unterbrochen wurden. +.IP 4. +Bereinigung tempor\o'a"'rer Relationen und Files. +.ft B +restore +.ft R +f\o'u"'hrt das +.ft B +purge +.ft R +\-Programm aus, +um tempor\o'a"'re Relationen und tempor\o'a"'re +Files, die vom System erzeugt wurden, zu l\o'o"'schen. +.ft B +purge +.ft R +wird etwas sp\o'a"'ter detaillierter diskutiert. +.LP +.ft B +restore +.ft R +kann dem Nutzer nicht sagen, welche Queries ausgef\o'u"'hrt +wurden und welche nicht. +Es kann nur die Queries erkennen, die gerade liefen, als der +crash erfolgte. +Falls Queries auch gerettet werden sollen, +ist es am besten, sie in ein File auszugeben. +Gegebenenfalls kann der Monitor jede Query oder eine Folge von Queries ausgeben und der Nutzer sp\o'a"'ter erkennen, welche +Queries +ausgef\o'u"'hrt wurden. +.LP +.ft B +restore +.ft R +hat mehrere Optionen zur Erweiterung +seiner Anwendbarkeit, +die durch Flags spezifiziert werden. +Die Optionen erm\o'o"'glichen: +.IP -a +fragt vor der Ausf\o'u"'hrung +.IP -f +verwendet f\o'u"'r +.ft B +purge +.ft R +; l\o'o"'scht +tempor\o'a"'re Files; +.IP -p +verwendet f\o'u"'r +.ft B +purge +.ft R +; l\o'o"'scht +verfallene Relationen; +.IP no_database + erneuert alle Datenbanken, +f\o'u"'r die sie DBA sind; +.LP +Von diesen Optionen ist +.ft B +-a +.ft R +die wichtigste. +Es kann geschehen, dass durch einen \*(xx\-crash eine +Seite des Systemkataloges besch\o'a"'digt +wird. +Das kann dazu f\o'u"'hren, dass +.ft B +restore +.ft R +eine Relation +austr\o'a"'gt (zerst\o'o"'rt). +In Wirklich\%keit wollen sie lieber zur Beseitigung des Problems +die Systemkataloge flicken ( +.ft B +patch +.ft R +), um korrekt +weiterarbeiten zu k\o'o"'nnen. +Aber kein +.ft B +restore +.ft R +\-Programm kann f\o'u"'r alle +M\o'o"'glichkeiten eingerichtet werden. +Es ist deshalb kein Ersatz (gl\o'u"'cklicherweise !) +f\o'u"'r den Menschen. +.LP +Wenn +.ft B +-a +.ft R +spezifiziert ist, teilt +.ft B +restore +.ft R +mit, was es +tun w\o'u"'rde und fragt dazu nach der +Erlaubnis. +Es liest von Standard-Input und +akzeptiert +.ft B +y +.ft R +als Anweisung zur Ausf\o'u"'hrung und +die \o'u"'brigen Zeichen als Ablehnung. +Beispielsweise, wenn bei +.ft B +restore +.ft R +vor Ausf\o'u"'hrung gefragt +werden soll, geben sie +.IP +restore -a meindb +.LP +Wenn sie auf alle Fragen +.ft B +nein +.ft R +antworten +wollen, so geben sie +.IP +restore -a meindb Abbruch: Betriebsnummer = 0 + + Betriebsnummer(8-St.): #9999999< + +.DE +.DS L +.ft B +Maske ansein_m: +.ft R + + Anschrift-Betriebsbezeichnung1: #aaaaaaaaaaaaaaaaaaaaaaaaa..a< + ..........Betriebsbezeichnung2: #aaaaaaaaaaaaaaaaaaaaaaaaa..a< + ..........Strasse/Nr. : #aaaaaaaaaaaaaaaaaaaaaaaaaaaa< + ..........Ort : #aaaaaaaaaaaaaaaaaaaaaaaaaaaa< + ..........Postleitzahl : #aaa< + Kurzbezeichnung: #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa< + Bezirk : #9< + +.DE +In den ersten beiden Zeilen wurden, um eine bessere Darstellung +zu erreichen, einige a ausgeblendet (entspricht ..). +.LP +.ft B +Ablauf: +.ft R +.LP +Der Eingabe-Generator wird mit +.br +.ft B +zip +.ft R +-pl LIBTUT ansbn +.br +gerufen. +.nf +Darstellung des Dialogs: + +------------------------------------------------------------- + + ++--------------------------------+ +| EINGABE-GENERATOR >>> ZIP <<< | +| Version 2.1 (curses) 01.02.89 | +| EVK Olbernhau | ++--------------------------------+ + +Der Abfragezyklus bezieht sich jeweils auf eine Variable! +Zur Orientierung werden die Texte der Maske mit ausgegeben. + +Erfassg./Korr. von Anschriften ==> Abbruch: Betriebsnummer = 0 + +Betriebsnummer(8-St.): +>>>Datentyp (i/l/c/f/d) > l + +>>>vereinbarter Name (Feld mit []) > BN + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Name Pruefprozedur mit () u.Arg.> przk() + +>>>Pruef-Art:Zei.=z/Wort=w > w + +>>>Hilfe einordnen? (j/n) > j + +>>>Hilfe-Art: Text=t / Prozedur=p > t + +>>>Name File f. Hilfe-Text m. (z,s) > bnhlp(3,15) +9999999< + + +Okay? >j + +------------------------------------------------------------- +.fi +.LP +Zur Orientierung im Dialog gibt ZIP alle F\o'u"'hrungstexte +entsprechend der Textmaske mit aus. +.LP +Parallel zum Dialog wird das File ansbn_i angelegt: +.DS I +-pl LIBTUT ansbn +long BN j przk() w bnhlp(3,15) t +.DE +.LP +Die Pr\o'u"'fung der Statistik-Betriebsnummer erledigt die Prozedur przk(): +.nf + +------------------------------------------------------------- + +/* Pruefziffernkontrolle Modul 11 (8-stellig) */ + +przk(pn) long *pn; +{ +long nr; +int bew[8]; +int erg, sg, i, divr, anr, pz, p; + +nr = *pn; +bew[0] = 0; +bew[1] = 4; +bew[2] = 8; +bew[3] = 5; +bew[4] = 10; +bew[5] = 9; +bew[6] = 7; +bew[7] = 3; + +p = nr % 10; +sg = 0; + +for (i = 0; i < 8; i++ ) +{ + anr = nr % 10; + erg = anr * bew[i]; + sg = sg + erg; + nr = nr / 10; +} +divr = sg % 11; +switch(divr) +{ + case 0 : pz = 5; + break; + case 2 : pz = 4; + break; + case 3 : pz = 9; + break; + case 4 : pz = 3; + break; + case 5 : pz = 8; + break; + case 6 : pz = 2; + break; + case 7 : pz = 7; + break; + case 8 : pz = 1; + break; + case 9 : pz = 6; + break; + default: pz = 0; + +} +if (p == pz) return(1); +else return(0); +} +------------------------------------------------------------- +.fi +.LP +Der R\o'u"'ckkehrcode dieser Prozedur, die ebenfalls in LIBTUT steht, +wird ausgewertet (1 ist TRUE, 0 ist FALSE). Der Return-Code 0 +veranlasst nach einem Hupton zur erneuten Eingabe (Kursor +auf Feldanfang), die Eingabe von Fragezeichen (?) f\o'u"'hrt zur +Ausgabe der +Hilfe "pruefzifferngesichert" - der Text dazu steht im File bnhlp, +das bei der Generierung eingezogen wird. +Die Prozedur ansein() wird mit +.br + zip -a 3 -hl LIBTUT ansein +.br +generiert. +Der Dialog l\o'a"'uft wie folgt ab: +.nf + +------------------------------------------------------------- + ++--------------------------------+ +| EINGABE-GENERATOR >>> ZIP <<< | +| Version 2.1 (curses) 01.02.89 | +| EVK Olbernhau | ++--------------------------------+ + +Der Abfragezyklus bezieht sich jeweils auf eine Variable! +Zur Orientierung werden die Texte der Maske mit ausgegeben. + +Anschrift-Betriebsbezeichnung1: +>>>Datentyp (i/l/c/f/d) > c + +>>>vereinbarter Name (Feld mit []) > ANS1[40] + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > n +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa< +..........Betriebsbezeichnung2: +>>>Datentyp (i/l/c/f/d) > c + +>>>vereinbarter Name (Feld mit []) > ANS2[40] + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > n +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa< +..........Strasse/Nr. : +>>>Datentyp (i/l/c/f/d) > c + +>>>vereinbarter Name (Feld mit []) > ANS3[30] + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > n +aaaaaaaaaaaaaaaaaaaaaaaaaaaa< +..........Ort : +>>>Datentyp (i/l/c/f/d) > c + +>>>vereinbarter Name (Feld mit []) > ORT[30] + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > n +aaaaaaaaaaaaaaaaaaaaaaaaaaaa< +..........Postleitzahl : +>>>Datentyp (i/l/c/f/d) > c + +>>>vereinbarter Name (Feld mit []) > PLZ[5] + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > n +aaa< +Kurzbezeichnung: +>>>Datentyp (i/l/c/f/d) > c + +>>>vereinbarter Name (Feld mit []) > KUBEZ[48] + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > n +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa< + +>>>Datentyp (i/l/c/f/d) > i + +>>>vereinbarter Name (Feld mit []) > BEZIRK + +>>>mit Korrekturmoeglichkeit?(j/n) > j + +>>>Hilfe einordnen? (j/n) > j + +>>>Hilfe-Art: Text=t / Prozedur=p > t + +>>>Name File f. Hilfe-Text m.(z,s) > bezhlp(15,3) +9< + +Okay? >>j +------------------------------------------------------------- +.fi +.LP +Die nach > stehenden Eingaben sind jeweils mit (Carriage Return) +abzuschliessen. + +Folgendes i-File entsteht: +.DS I +-a 3 -hl LIBTUT ansein +char ANS1[40] j n n +char ANS2[40] j n n +char ANS3[30] j n n +char ORT[30] j n n +char PLZ[5] j n n +char KUBEZ[48] j n n +int BEZIRK j n bezhlp(15,3) t +.DE +.LP +Es w\o'a"'re denkbar, die PLZ mit "isdigit()" zu pr\o'u"'fen, in Abweichung +zu oben entst\o'u"'nde das i-File: +.DS I +-a 3 -phl LIBTUT ansein +char ANS1[40] j n n +char ANS2[40] j n n +char ANS3[30] j n n +char ORT[30] j n n +char PLZ[5] j isdigit() z +char KUBEZ[48] j n n +int BEZIRK j n bezhlp(15,3) t +.DE +.LP +Beachten sie, dass \et als Trennzeichen steht. +Bei \o'A"'nderungen im *_i-File +d\o'u"'rfen die +Trennzeichen nicht versehentlich gel\o'o"'scht +werden! +.LP +Es wird bei der Erzeugung der Ein-/Ausgabe-Prozedur +davon ausgegangen, dass die C-Variablen an +Spalten bestimmter Relationen \o'u"'bergeben +bzw. von diesen \o'u"'bernommen werden. Deshalb sind +die C-Variablen grunds\o'a"'tzlich global de\%kla\%riert, +entsprechend erwartet die erzeugte Prozedur eine +globale Deklaration zur Wert-\o'U"'bergabe/-\o'U"'bernahme. +F\o'u"'r alle zu realisierenden Konvertierungen werden die +Prozeduren (im Sinne von Parameter-Prozeduren) +aus /usr/lib/libzip.a verwendet. +Die manuelle Ersetzung +der Funktionsprozeduren aus der Standard-Bibliothek von +C (libc.a) f\o'u"'hrt zu Fehlern. +.LP +Die Reihenfolge der Objekte in +der Arbeits-Bibliothek (hier LIBTUT) spielt eine Rolle, +sofern Pr\o'u"'fprozeduren verwendet werden (nach der ZIP-Prozedur !). +Die Arbeits-Bibliothek muss im Bindekommando +vor /usr/lib/libzip.a stehen. +.LP +Pruefprozeduren werden in Anlehnung an +die Funktionen aus "ctype" (isdigit(), isascii() usw.) so +ge\%staltet, dass der Rueckkehrcode 1 fuer TRUE und +0 f\o'u"'r FALSE liefert. Das gilt sowohl f\o'u"'er Prozeduren +die zeichenweise (z) als auch f\o'u"'r solche, die +wortweise (w) pr\o'u"'fen. +Das header-File wird f\o'u"'r ZIP-Prozeduren +standardm\o'a"'ssig eingezogen. +.LP +Als kleine zus\o'a"'tzliche Hilfe von ZIP steht eine +Menue-Prozedur +.ft B +menzip() +.ft R +zur Verf\o'u"'gung, die ein im main() vereinbartes Zeichenkettenfeld +auf w\o'a"'hlbaren Positionen invers ausgibt und die +angeklickte Zeile (1..n) als R\o'u"'ckkehrwert liefert +(s. Teil III, Beispiel "Terminkontrolle"). + diff --git a/WEGA/contrib/ingres/dbs/ing_src/teil2/zugr b/WEGA/contrib/ingres/dbs/ing_src/teil2/zugr new file mode 100644 index 0000000..aae9aa6 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/ing_src/teil2/zugr @@ -0,0 +1,597 @@ +.ds LH Anwendung +.ds RH \f3ZUGRIFF\f1 +.ds CH - % - +.bp +.NH 2 +.ft B +Zugriffsmethoden und ** +.br + Datenlokalisierung +.ft R +.LP +.sp 10 +.NH 3 +.ft B +Einleitung +.ft R +.LP +\*(yy\ unterst\o'u"'tzt mehrere Zugriffsmethoden, +deren sinnvoller Einsatz dem Projektanten +und dem Datenbankadministrator \o'u"'berlassen wird +und die Zuordnung von Datenbanken +und Relationen in eine hierarchische \*(xx\-File-Struktur. +.LP +Diese Kapitel beschreibt die Funktionsweise +der Zugriffsmethoden und gibt damit ,weiterf\o'u"'hrend +zum vorangegangenen, eine +Anleitung zu ihrem effektiven problembezogenem Einsatz. +Ausserdem werden die Teile des \*(yy\-Filesystems +beschrieben, die den anwendungsbezogenen Aufbau +mountbarer Filesysteme erm\o'o"'glichen. +.NH 3 +.ft B +Grundkonzepte von \*(yy +.ft R +.NH 4 +.ft B +Seitenkonzept und Tupeldarstellung +.ft R +.LP +Alle Zugriffsmethoden legen den Datenbestand +einer Relation in \*(xx\-Files ab. +Das File ist generierungsabh\o'a"'ngig in Seiten von 512-Byte +(\*(xx\ Version 7) oder 1KByte L\o'a"'nge +unterteilt. Jedes File f\o'u"'r eine +Relation besteht aus einer ganzen Anzahl von Seiten, +mindestens aber aus einer. +.LP +Jede Seite enth\o'a"'lt Tupel der Relation +und zwar so, dass jedes Tupel vollst\o'a"'ndig auf einer Seite +untergebracht ist. +.LP +Ein Tupel kann gew\o'o"'hnlich oder komprimiert gespeichert +werden: +Als gew\o'o"'hnlich gespeichertes Tupel wollen wir eine Speicherung verstehen, +wo jedes Attribut des Tupel genau soviele Bytes +belegt, wie beim create der Relation +als Formatl\o'a"'nge f\o'u"'r die entsprechenden Dom\o'a"'nen +definiert wurde. +Bei den Dom\o'a"'nen des Typs c (character) wird h\o'a"'ufig der +Fall eintreten, dass deren Attribute den verf\o'u"'gbaren Speicherplatz +nicht voll ausf\o'u"'llen, indem sie ab einer bestimmten +Position nur noch Leerzeichen enthalten. +Als eine komprimierte Speicherung eines Tupel +verstehen wir eine solche, +bei der Attribute von c-Dom\o'a"'nen um diese rechten Leerstellen +verk\o'u"'rzt werden (das Ende des relevanten Teils +des Attributes wird durch ein zus\o'a"'tzliches '\e0'-Byte markiert ! ). +Als Spreizen einer Relation wollen wir die Transformation +einer komprimierten in die gew\o'o"'hnliche Darstellung +verstehen. +.LP +F\o'u"'r gew\o'o"'hnlich dargestellte Relationen kann man die auf einer +Seite unterbringbaren Tupel berechnen als +.DS I + + 512 - 12 +Tupel pro Seite = ggZ (--------------------) + Tupell\o'a"'nge + 2 + +(Tupell\o'a"'nge in Byte, + ggZ: gr\o'o"'sste ganze Zahl von ) +.DE +Man sieht, dass pro Seite generell 12 +Bytes und pro Tupel 2 Byte Verwaltungsplatz +ben\o'o"'tigt werden. +.LP +Analog kann man sich ausrechnen, wieviel Restplatz +auf jeder Seite frei bleibt, wenn die Tupell\o'a"'nge +so gew\o'a"'hlt wird, dass ein ganzes Vielfaches von +ihr ( + 2 ! ) die Seite nicht ausf\o'u"'llt. +Maximal darf die Tupell\o'a"'nge 498 Bytes betragen +(pro Seite dadurch also ein Tupel !). +Die Beziehungen f\o'u"'r 1024-Byte-Seiten k\o'o"'nnen +mit den gleichen absoluten Werten berechnet werden. +.LP +Aus der Anzahl der Tupel und den auf einer Seite unterbringbaren, +kann der, f\o'u"'r eine Relation insgesamt n\o'o"'tige Speicherplatz +ausgerechnet werden. +.LP +F\o'u"'r komprimiert dargestellte Relationen +muss man eigene Absch\o'a"'tzungen verwenden. +.LP +Wir bezeichnen eine Seite mit minimalem Restplatz +als (100 %-tig) gef\o'u"'llt. +Der F\o'u"'llfaktor einer Seite entspricht dem +durch Tupel belegten Platz +im Verh\o'a"'ltnis zum Gesamtplatz. +.NH 4 +.ft B +Schl\o'u"'sselbegriff von \*(yy +.ft R +.LP +In der Relationentheorie bezeichnet +man als Schl\o'u"'ssel einer Relation +eine derartige Dom\o'a"'ne (oder Gruppe von Dom\o'a"'nen), +deren Attribute allein das Tupel charakterisieren. +Beliebige zwei Tupel einer Relation unterscheiden sich also +mindestens in ihren Schl\o'u"'sseln. +.LP +Wenn in der \*(yy\-Dokumentation von Schl\o'u"'sseln +gesprochen wird, ist ein anderer, schw\o'a"'cherer Begriff +gemeint. +Bei \*(yy\ kann eine Dom\o'a"'ne +(oder eine Gruppe von in ihrer Reihenfolge +ge\%kennzeichneter Dom\o'a"'nen) +f\o'u"'r die Sortierung oder Zugriffsunterst\o'u"'tzung +herangezogen werden. +F\o'u"'r diese Dom\o'a"'ne(n) wird dann vom Schl\o'u"'ssel +der Relation gesprochen. +\*(yy\ unterstellt f\o'u"'r den Schl\o'u"'ssel nicht +unbedingt die o.g. unifizierende Eigenschaft, +dass sich zwei Tupel mindestens in ihren Schl\o'u"'sseln +unterscheiden m\o'u"'ssen. +.LP +F\o'u"'r \*(yy\ sind zwei Tupel genau dann gleich, +wenn sie in allen paarigen Attributen +\o'u"'bereinstimmen. An den Stellen, +wo \*(yy\ doppelte Tupel ausschliesst, wird nicht +nur auf Unterschiede in den Schl\o'u"'sselattributen, +sondern auf solche in allen paarigen +Attributen getestet. +.NH 4 +.ft B +Seitenketten +.ft R +.LP +Wir wollen eine Gruppe von Seiten, die aus einer Hauptseite besteht, +an der ggf. weitere Seiten durch Verweisungen angekettet sind, +als Seitenkette bezeichnen. +Im Extrem besteht die Sei\%tenkette nur aus der Hauptseite. +Die Verweisungen erfolgen linear aus der Hauptseite +auf deren nachfolgende, aus dieser auf deren nachfolgende u.s.w. +In der Regel werden die der Hauptseite folgenden +Seiten als \o'U"'berlaufseiten bezeichnet. +Wir bezeichnen die in der Seitenkette enthaltenen Tupel als +Tupel\%kette der Seiten\%kette. +.DS L +Seitenkette ___________ + | | + | Haupt | + | Seite | + | | + ~~~~~~~~~~~ + | .................... + ___________ \o'U"'berlaufseiten + | | + | Folge | + | Seite | + | | + ~~~~~~~~~~~ + | + : + : + : +.DE +.LP +Gemeinsam bei allen Zugriffsmethoden ist: +.IP \ \ \ - 5 +Die Suche eines Tupels in einer Seitenkette erfolgt +sequentiell. +.sp1 +Sieht man von den hier nicht darzustellenden +Dekompositionsverfahren bei retrieve-Anweisungen +mit Aggregaten oder \o'u"'ber mehrere Relationen ab, +erfolgt die Anzeige aufgefundener Tupel +unmittelbar in der Reihenfolge der Tupelkette. +.sp1 +.IP +Das Anf\o'u"'gen (append) eines Tupel in einer Seitenkette +erfolgt hinten an die Tupel der laufenden Seite; +wenn daf\o'u"'r kein Platz mehr ist, +wird die Seitenkette um eine neue Seite verl\o'a"'ngert. +.sp1 +Dadurch geht die anfangs bestehende Reihenfolgeordnung +der Tupel in einer Seite und auch in der Seitenkette verloren. +.sp1 +.IP +Beim Streichen (delete) eines Tupel wird der Platz des Tupel +freigegeben und die Seite komprimiert; +die Seitenkette wird nicht komprimiert. +.LP +Unterschiede zwischen den Zugriffsmethoden +bestehen darin: +.sp1 +.IP \ \ \ - 5 +bei der heap-Technik wird die gesamte Relation in einer +einzigen Seitenkette abgelegt, bei den Direktzugriffsmethoden +hash und isam besteht die Relation aus mehreren Seitenketten. +Die Unterschiede bei letzteren Techniken +bestehen in der Art der Zuordnung von +Schl\o'u"'sselwerten zu den verschiedenen Seitenketten +der Relation. +.sp1 +.IP +Bei der heap-Technik werden doppelte Tupel in der Seiten\%kette +zugelassen, bei den Direktzugriffstechniken nicht. +.sp1 +Daraus ergeben sich Unterschiede beim Anf\o'u"'gen neuer Tupel: +.br +Bei heap erfolgt die Einspeicherung +am Ende der Tupel\%kette, +bei hash und isam muss die gesamte Seiten\%kette +durchsucht werden, um doppelte Tupel auszuschliessen, +das Anf\o'u"'gen erfolgt +auf dem ersten ausreichenden freien Platz der Seitenkette. +Bei heap wird dadurch der durch delete entstandene +freie Platz nicht wieder ausgenutzt. +.sp1 +Daraus ergeben sich auch Unterschiede beim Ersetzen (replace) +in komprimierten Relationen in solchen F\o'a"'llen, +wo das Ersetzen ggf. nicht inplace erfolgen kann. +Dann wird replace in delete und append aufgel\o'o"'st. +Beachten sie, dass jedes gefundene Tupel ersetzt wird, +replace also die Anzahl der Tupel einer Relation nicht \o'a"'ndert. +.NH 3 +.ft B +Zugriffstechniken von \*(yy +.ft R +.NH 4 +.ft B +Heap +.ft R +.LP +Eine als heap dargestellte Relation belegt +eine Seitenkette. +Bis auf die letzte Seite sind +bei Erzeugung der Relation +durch modify, copy from oder sukzessives append +alle Seiten +(100 %-tig) gef\o'u"'llt. +Die Tupel sind unsortiert. +Die Relation enth\o'a"'lt ggf. doppelte Tupel. +.LP +append f\o'u"'gt Tupel hinten an +(ggf. werden weitere Seiten angekettet !). +delete gibt Speicherplatz auf der jeweiligen Seite frei; +um die zu l\o'o"'schenden Tupel zu finden, +muss die gesamte Relation durchsucht werden. +Der freigegebene Platz kann durch append nicht wiederbenutzt werden, +da neue Tupel hinten angelegt werden. +retrieve durchsucht die gesamte Relation +und zeigt die sich qua\%lifizierenden +Tupel in der gefundenen, unsortierten Reihenfolge. +.LP +heap und cheap sind geeignete Zugriffstechniken, +um aus einer leeren Relation durch sukzessives Anf\o'u"'gen oder copy from +eine Relation aufzubauen. +Eine effektive Arbeit mit dieser Zugriffstechnik +ist aber nur bei kleinen Relationen denkbar. +.NH 4 +.ft B +Heapsort +.ft R +.LP +heapsort ist keine Speichertechnik +sondern Zustand einer Relation +nach Ausf\o'u"'hrung eines entsprechenden modify-Statements; +die Relation ist in der Folge ein heap. +.LP +Bei der Ausf\o'u"'hrung eines modify to heapsort +wird die Relation nach den angesprochenen Dom\o'a"'nen +sortiert, werden doppelte Tupel gestrichen +und wird die Relation als heap abgelegt. +.LP +Zur Durchf\o'u"'hrung der Sortierung wird die Relation +gespreizt, falls sie komprimiert gespeichert war. +Es werden Sortierarbeitspl\o'a"'tze +als Files im SYS-directory angelegt. +.NH 4 +.ft B +Hash +.tf R +.LP +F\o'u"'r eine als hash dargestellte Relation besteht ein +Direktzugriff auf ein Tupel, +wenn der Wert seines(r) Schl\o'u"'sselattribute(s) +vollst\o'a"'ndig angegeben wird. +Dieser Zugriff wird wie folgt vollzogen: +.LP +Durch eine hash-Funktion wird aus dem Schl\o'u"'sselattribut +die Adresse (der hash-Code) einer Hauptseite +berechnet. +Die hash Funktion berechnet also nach einem besonderen +Verfahren aus einem irgendwie strukturiertem Schl\o'u"'ssel +eine Zahl, die in einem Intervall +.DS C +0 <= Hauptseite <= N-1 +.DE +liegt. +N bezeichnen wir als Spreizungsbreite der hash-Funktion. +Diese dadurch jeweils errechnete Hauptseite ist Anfangsseite +einer Seitenkette, die alle die Tupel der Relation enth\o'a"'lt, +deren Schl\o'u"'ssel den gleichen hash-Code haben. +In diesen Seitenketten werden keine doppelten Tupel zugelassen. +Die Relation kann insgesamt als unsortiert aufgefasst werden, +da die hash-Funktion keinen "nat\o'u"'rlichen" Wert +aus dem Schl\o'u"'ssel bildet. +.DS I + 0 + 1 + hash(Schl\o'u"'sselwert) = : + : + N-1 + + + 0 1 ......... N-1 +________ ________ ________ +| | | | | | +|Seiten| |Seiten| ......... |Seiten| +|kette | |kette | |kette | +| | | | | | +~~~~~~~~ ~~~~~~~~ ~~~~~~~~ + +.DE +.LP +Beim modify einer Relation zu hash +kann die Spreizungsbreite +der hash-Funktion durch die geforderte Anzahl von +Hauptseiten +(minpages/maxpages als minimale/maximale Anzahl) +beeinflusst werden. +Die Ausf\o'u"'hrung des modify erfolgt durch sukzessives insert +in eine neue Relation. +Die alte Relation wird aus Sicherheitsgr\o'u"'nden erst +freigegeben, wenn die neue erzeugt ist. +Beim create einer leeren Relation +kann man mit +modify +eine gew\o'u"'nschte Spreizungsbreite einstellen. +.LP +hash und chash sind geeignete Zugriffstechniken, +um aus einer leeren Relation durch sukzessives Anf\o'u"'gen +oder durch copy from eine Relation aufzubauen. +.LP +\*(yy\ unterst\o'u"'tzt nur eine hash-Funktion. +Es kann nicht garantiert werden, +dass die durch die Spreizungsbreite definierte Anzahl +von Seitenketten schon bei Erzeugung der Relation jeweils +mindestens ein Tupel und maximal nicht mehr als auf der Hauptseite +unterbringbar enthalten. +Allerdings wird f\o'u"'r jede Seitenkette mindestens +eine Hauptseite reserviert. +.LP +Die Suche in einer hash-Relation f\o'u"'r einen einzelnen Schl\o'u"'sselwert +f\o'u"'hrt \o'u"'ber dessen hash-Code +auf die Hauptseite, wo sequentiell weiter gesucht wird. +Die Suche nach einem Schl\o'u"'sselintervall zwingt zum Durchsuchen +der gesamten Relation. +Deshalb ist die hash-Technik ungeeignet, +wenn h\o'a"'ufig Suchpfade \o'u"'ber +Schl\o'u"'sselintervalle benutzt werden m\o'u"'ssen. +.LP +Das \o'A"'ndern in einer Relation erfolgt einschliesslich +der Suche und dem Ausschluss der Anlage doppelter Tupel. +Beim Erg\o'a"'nzen neuer Tupel wird die betroffene Seitenkette +ggf. durch \o'U"'berlaufseiten erg\o'a"'nzt, die an die +vorherigen Seiten der Seitenkette angekettet werden. +.NH 4 +.ft B +Isam +.ft R +.LP +F\o'u"'r eine als isam dargestellte Relation +besteht ein Direktzugriff auf ein Tupel, +wenn der Wert seines(r) Schl\o'u"'sselattribute(s) +angegeben wird und besteht dar\o'u"'ber hinaus die M\o'o"'glichkeit, +Schl\o'u"'sselintervalle in einer ann\o'a"'hernden +Sortierung abzugreifen. +.LP +F\o'u"'r isam ist ein aus mehreren Komponenten +bestehender Schl\o'u"'ssel soweit definiert und ggf. +f\o'u"'r einen direkten Zugriff nutzbar, +wie seine ersten Komponenten l\o'u"'ckenlos +definiert sind. +.LP +Der Zugriff wird wie folgt organisiert: +.LP +Durch einen Adress-B*-Baum wird aus dem Schl\o'u"'sselattribut +die Adresse einer Hauptseite berechnet. +.LP +Ein B*-Adressbaum enth\o'a"'lt in jeder Baumebene +eine Folge von Seiten. Eine derartige Folge von Seiten +enth\o'a"'lt aufsteigend geordnete Schl\o'u"'ssel +von Seiten der darunter liegenden Baum\%ebene, also der +Nachfolgeebene. +Aus der Position des Schl\o'u"'ssels kann die betreffende Seite +der Nachfolgeebene bestimmt werden. +Diese enth\o'a"'lt ab dem sie definierenden Anfangsschl\o'u"'ssel +alle, die kleiner als der Anfangsschl\o'u"'ssel +ihrer, in gleicher Baumebene liegenden, Nachbarseite sind. +Der B*-Baum wird nach unten durch Hauptseiten +von Seitenketten abgeschlossen, +die zu den Schl\o'u"'sseln auch alle weiteren Attribute +als vollst\o'a"'ndige Tupel enthalten. +Der B*-Baum erh\o'a"'lt nach oben soviele Ebenen, bis die +Wurzelebene ganz auf einer Seite darstellbar ist. +.LP +Nehmen wir als Beispiel Schl\o'u"'ssel von ganzen Zahlen an und nehmen wir weiter an, dass auf +einer Seite der Seitenkette der Relation 5 Tupel unterbringbar w\o'a"'ren, +auf einer Seite des B*-Baumes aber 25 Adressen. +Dann w\o'a"'re folgender B*-Baum mit zwei Baumebenen denkbar: +.DS L + + ______________________________ + | 5 130 | + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + ________________________ ________________________ + | 5 10 .... 125| |130 135 .... 255| + ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~ + +_____ _____ _____ _____ _____ _____ _____ +| | | | | | | | | | | | | | +| 0 | | 5 | | 10| |125| |130| |135| |255| +| : | | : | | : | ..... | : | | : | | : | ..... | : | +| : | | : | | : | | : | | : | | : | | : | +| 4 | | 9 | | 14| |129| |134| |139| | : | +| | | | | | | | | | | | | | +~~~~~ ~~~~~ ~~~~~ ~~~~~ ~~~~~ ~~~~~ ~~~~~ + +.DE +Die Genauigkeit des B*-Baumes w\o'u"'rde gew\o'a"'hrleisten, +dass im Schl\o'u"'sselintervall 0 ... 254 +maximal 5 Tupel sequentiell gesucht werden m\o'u"'ssten, +dass in diesem Intervall keine \o'U"'berlaufseiten auftreten +und dass bei der Ausgabe Sortierabweichungen +nur in 5-er Schritten auftreten k\o'o"'nnten: +.br +z.B. +.DS I 12 + 9, 11, 13, 12, 14, 10, 17 +aber nie 9 nach 10, 11, 12, 13, 14 +oder nie 15 vor 10, 11, 12, 13, 14 +.DE +Allerdings w\o'u"'rden alle Tupel mit Schl\o'u"'sselwerten ab 255 +in die letzte Seitenkette eingeordnet werden. +.LP +Beenden wir hiermit das Beispiel. +.LP +Der B*-Baum ist Bestandteil der Relation. +.sp1 +.ti +5 +.ne 8 +(seine L\o'a"'nge ist berechenbar: +.IP \ \ \ \ \ - 8 +Tupell\o'a"'nge der Adresse: +.br +gespreizter Schl\o'u"'sselcode +.IP +jede Baumebene ganz in Seiten) +.LP +Die durch den B*-Baum ermittelten Hauptseiten +sind Anfangsseiten von Seitenketten, +die unsortiert alle Tupel enthalten und deren Schl\o'u"'ssel den +gleichen Baumpfad nehmen. +In diesen Seitenketten werden keine doppelten Tupel zugelassen. +Die B*-Baum-Struktur gew\o'a"'hrleistet f\o'u"'r gewisse +Schl\o'u"'sselintervalle +eine Sortierung untereinander. +.LP +Der B*-Baum wird bei der Erzeugung der Relation +angelegt und bleibt \o'u"'ber deren gesamte Lebensdauer fest. +Es ist unsinnig, eine leere Relation +als isam zu gr\o'u"'nden, der B*-Baum w\o'a"'re entartet, +man w\o'u"'rde eine einzige Seitenkette erzeugen, +bei dem bei jedem Einf\o'u"'gen eines neuen Tupel +eine Duplikatkontrolle \o'u"'ber alle bereits +vorhandenen Tupel erfolgen w\o'u"'rde. +.LP +Bei der Erzeugung der isam Relation durch modify +kann man die Genauigkeit des B*-Baumes +durch den F\o'u"'llfaktor der Hauptseiten +bestimmen. +Die alte Relation wird zun\o'a"'chst in eine Speicherungsform analog +heapsort \o'u"'berf\o'u"'hrt, diese wird danach, entsprechend dem +F\o'u"'llfaktor, gespreizt +und \o'u"'ber den so entstandenen Hauptseiten +wird der B*-Baum aufgebaut. +.LP +Die Suche in einer isam Relation kann f\o'u"'r die Angabe +von einzelnen Schl\o'u"'sselwerten, als auch f\o'u"'r +Intervalle von ihnen unterst\o'u"'tzt werden. +Das Anf\o'u"'gen erfolgt zun\o'a"'chst in den +Hauptseiten - soweit der F\o'u"'llfaktor des +erzeugenden modify vorausschauend gen\o'u"'genden Restplatz +definiert - danach werden der jeweiligen Seitenkette +\o'U"'berlaufseiten angef\o'u"'gt. +Das \o'A"'ndern in der Relation erfolgt einschliesslich +der Suche und dem Ausschluss der Anlage doppelter Tupel. +.NH 3 +.ft B +Die Gestaltung des Datenbankfilesystems +.br +f\o'u"'r \*(yy +.ft R +.NH 4 +.ft B +Einordnung einer Datenbank +.ft R +.LP +\*(yy\ wird installationsabh\o'a"'ngig +unter einem Anfangspfadnamen +.DS C +Pathname +.DE +installiert. Zum Beispiel ist +.DS C +Pathname = /mnt/ing_db +.DE +eingerichtet. +.LP +Unter diesem Pathname liegen eine Reihe hier nicht behandelter +Files und directories. +Die Datenbanken sind unter +.DS C +Pathname/data/base +.DE +eingerichtet, jede Datenbank erh\o'a"'lt ein directory ihres Namens: +.DS C +Pathname/data/base/dbname +.DE +In jedem directory dbname liegen +.sp1 +.IP \ \ \ - 5 +dbname/admin +.br +das s.g. admin-File mit allgemeinen Datenbankinformationen, +.sp1 +.IP +die Systemkataloge +(die Relationen relation, references, attributes, integrity, protect, indexes), +die Relationen (Relationen schlechthin, Indizes) +.LP +Durch diese Struktur sind insbesondere +.DS B +base oder +dbname oder +SYS +.DE +mountbar. +.LP +Bei Erzeugung einer Datenbank mittels creatdb +wird das directory dbname +angelegt und werden die Systemkataloge eingerichtet. +.NH 4 +.ft B +Bewertung des Relationennamens +.ft R +.LP +\*(yy\ speichert alle Daten einer Relation in einem \*(xx\-File +unter dem directory dbname. +Der File-Name wird aus dem vom Anwender +bei create oder retrieve into angegebenem Relationennamen +gebildet. +Dazu wird der Relationenname +.IP \ \ \ - 5 +ggf. durch Leerzeichen () auf 12 Bytes +verl\o'a"'ngert; +.br +dabei wird das erste in 2. bis 11. Position +gefundene "_" () durch "/" () +ersetzt; +.IP +den 12 Bytes werden 2 Bytes als Code des +arbeitenden Nutzers (s. auch +-u-Flag bei quel(unix) im Referenz-Manual) +angef\o'u"'gt. +.LP +Dadurch wird es m\o'o"'glich, dass +.IP - +verschiedene Nutzer private Relationen gleichen +Namens in der gleichen Datenbank anlegen k\o'o"'nnen; +.IP - +ein Nutzer durch sinnvolle Verwendung des +im Relationennamen die Verteilung der Relationen +auf das Wurzel-directory dbname oder in sub-directories +von dbname steuern kann.