<\/p>\n
Die Dokumentation von Datenbankanwendungen ist bei den meisten Entwicklern nicht besonders beliebt. Möglicherweise liegt der Grund schlicht darin, dass die Programmierarbeiten meist schon erledigt sind, wenn einem einfällt, dass der Kunde noch um eine ausführliche Dokumentation bat. Der vorliegende Beitrag soll zumindest die Dokumentation von Tabellen, Feldern und Co. so weit vereinfachen, dass Sie keinen Grund mehr haben, die Dokumentation an das äußerste Ende des Projekts zu verschieben.<\/b><\/p>\n
Zur Dokumentation eines Datenmodells gehören eigentlich zwei Stufen:<\/p>\n
Beides kann in einem einzigen Schritt durchgeführt werden: Sie erstellen einfach das Zieldokument, beispielsweise mit Word, legen einige Absatzformatvorlagen fest um die Dokumentation zu strukturieren und tragen dann die Beschreibung der Tabellen und Felder ein.<\/p>\n
Dies hat den Nachteil, dass änderungen in der zugrunde liegenden Datenbank meist nicht gleich in die Dokumentation übertragen werden – und dies später zu erledigen, dürfte zu einer unangenehmen Arbeit werden. Sie müssen dann nämlich erstmal herausfinden, an welchen Stellen die Dokumentation nun nicht mehr dem aktuellen Stand des Datenmodells entspricht.<\/p>\n
Besser ist es, die zwei Stufen wie oben beschrieben zu realisieren. Das heißt, dass Sie die Beschreibung der Tabellen und Felder gleich in den entsprechenden, im Entwurf zur Verfügung stehenden Eigenschaften unterbringen.<\/p>\n
Tabellen und Felder stellen jeweils eine eigene Eigenschaft namens Beschreibung <\/b>zur Verfügung, die Sie an folgenden Stellen anpassen können:<\/p>\n Während nur letztere Möglichkeit auf den ersten Blick die mehrzeilige Eingabe anbietet, können Sie vom Tabellenentwurf aus durch Markieren der entsprechenden Eigenschaft und anschließendes Drücken von Umschalt + F2 <\/b>das Zoom-Fenster öffnen. Hier finden Sie ein wenig mehr Platz zum Eingeben auch mehrzeiliger Beschreibungstexte.<\/p>\n Was gehört in eine Dokumentation<\/b><\/p>\n Der Beschreibungstext ist am ehesten für Außenstehende interessant. Der Entwickler einer Datenbankanwendung könnte sich die Dokumentation neben den Rechner legen, um beispielsweise schnell einmal einen Tabellen- oder Feldnamen nachzuschlagen, weil er gerade mit der Nase im VBA-Editor steckt, ein SQL-Statement zusammenbaut und nicht dauernd zwischen VBA-Editor und dem Tabellenentwurf wechseln möchte. Davon abgesehen sollten wir die Dokumentation nicht nur mit Tabellen- und Feldnamen sowie deren Beschreibungstexten, sondern auch mit weiteren Informationen füttern. Für Tabellen sind folgende Einstellungen aus dem Eigenschaftsfenster interessant (s. Bild 1):<\/p>\n Bild 1: Eigenschaftsfenster einer Tabelle in der Entwurfsansicht<\/span><\/b><\/p>\n Die Tabellenfelder geben neben dem Feldnamen und der Beschreibung noch wesentlich mehr wichtige Eigenschaften her (s. Bild 2):<\/p>\n Bild 2: Übersicht der Felder und ihrer Eigenschaften in der Tabellenentwurfsansicht<\/span><\/b><\/p>\n Für Felder, die als Nachschlagefeld definiert sind, gibt es sogar noch eine ganze Reihe weiterer Eigenschaften (s. Bild 3). Die wichtigsten finden Sie in dieser Auflistung:<\/p>\n Bild 3: Als Nachschlagefeld definierte Felder liefern noch mehr dokumentationswerte Eigenschaften.<\/span><\/b><\/p>\n Indizes dokumentieren<\/b><\/p>\n Es gibt in Access verschiedene Index-Arten: Einfache Indizes, die lediglich die Suche nach den Werten des indizierten Feldes beschleunigen, eindeutige Indizes, die dafür sorgen, dass ein Wert nur einmal je Tabelle vorkommt, und Primärschlüssel, die als eindeutige Merkmale einer Tabelle dienen. Jede Indexart kann sich überdies auf ein oder mehrere Felder beziehen.<\/p>\n Beziehungen dokumentieren<\/b><\/p>\n Neben den Tabellen und ihren Feldern sollen auch die Beziehungen zwischen den Tabellen dokumentiert werden. Diese finden Sie in der Benutzeroberfläche von Access unter Umständen nur mit Mühe: Beziehungen werden zwar im Beziehungen-Fenster festgelegt, aber Sie können dort Tabellen ein- und ausblenden.<\/p>\n Und mit den Tabellen verschwinden dann auch die Beziehungspfeile, welche die Beziehung charakterisieren. <\/p>\n Dennoch sollen die Beziehungen in einer Dokumentation entsprechend gewürdigt werden.<\/p>\n Konzept für den Aufbau der Dokumentation<\/p>\n Bevor wir uns an die technische Umsetzung begeben, sollten wir uns ein paar Gedanken über den Aufbau der Dokumentation machen. Die oberste Einheit in der Struktur der Dokumentation ist die Datenbankanwendung. Gleich darunter folgen die Tabellen. Jede Tabelle enthält Felder, also werden diese unterhalb der Tabellen angeordnet.<\/p>\n Indizes beziehen sich auf ein oder mehrere Felder.Daher sollen Indizes auf der gleichen Ebene wie die Felder dargestellt werden, allerdings im Anschluss an diese.<\/p>\n Beziehungen betreffen zwar in der Regel jeweils immer nur ein Feld einer Tabelle, aber da Felder auch in mehrere Beziehungen verstrickt sein können, landen auch diese auf der gleichen Ebene wie die Tabellenfelder.<\/p>\n Die Eigenschaften von Tabellen, Feldern, Indizes und Beziehungen landen jeweils eine Ebene unterhalb des Objekts, auf das sie sich beziehen.<\/p>\n Der Datenbankdokumentierer<\/b><\/p>\n Access enthält von Haus aus bereits einen Datenbankdokumentierer. Dieser bietet zwar eine halbwegs durchdachte Benutzeroberfläche (s. Bild 4), aber die Dokumentation landet in einem Bericht, der sich nur bedingt zur Weiterverarbeitung eignet.<\/p>\n Bild 4: Access bietet ebenfalls einen Datenbank-Dokumentierer. Dieser liefert sein Ergebnis jedoch nur als Bericht.<\/span><\/b><\/p>\n Mit den nachfolgend vorgestellten Techniken wollen wir uns nicht auf Berichte beschränken, sondern verschiedene Ausgabemöglichkeiten erlauben.<\/p>\n Technische Umsetzung: Daten sammeln<\/b><\/p>\n Wir gehen in folgenden Schritten vor: Als Erstes schauen wir, wie wir an die benötigten Informationen gelangen (Tabellen, Felder, Indizes und Beziehungen). Anschließend entwickeln wir die Techniken zum Ausgeben dieser Daten in verschiedenen Formaten.<\/p>\n Entsprechend unserer Struktur geben wir dabei erst den Datenbanknamen aus und dann die Tabellen mit ihren Eigenschaften. Für jede Tabelle folgen in einer weiteren Ebene die Felder, Indizes und Beziehungen, ebenfalls mit den jeweiligen Eigenschaften.<\/p>\n Die folgenden Abschnitte beschreiben dabei die grundlegenden Techniken zum Ermitteln der Informationen für die Tabellendokumentation.<\/p>\n Tabellen ermitteln <\/b><\/p>\n Die Tabellen und ihre Eigenschaften erhalten wir über die TableDefs<\/b>-Auflistung des Database<\/b>-Objekts. Die folgenden Zeilen zeigen, wie Sie alle Tabellen einer Datenbank durchlaufen und einige ihrer Eigenschaften im Direktfenster ausgeben können:<\/p>\n Um Systemtabellen auszuschließen, die mit MSys… <\/b>oder USys… <\/b>beginnen, können Sie innerhalb der For Each<\/b>-Schleife eine entsprechende Bedingung einarbeiten:<\/p>\n Das TableDef<\/b>-Objekt bietet noch weitere Eigenschaften, die wir für die Dokumentation verwenden können.<\/p>\n Felder und ihre Eigenschaften ermitteln<\/b><\/p>\n Wenn Sie einmal auf ein TableDef<\/b>-Objekt zugreifen, ist der Weg zur Fields<\/b>-Auflistung nicht mehr weit – und die ermöglicht den Zugriff auf alle Field<\/b>-Objekte einer Tabelle, sprich: auf die Felder.<\/p>\n Die folgende Beispielprozedur können Sie von der obigen Prozedur zum Ausgeben aller Tabellen aus aufrufen – zum Beispiel mit der folgenden Anweisung:<\/p>\n Die Prozedur durchläuft alle Field<\/b>-Elemente der Fields<\/b>-Auflistung des als Parameter übergebenen TableDef<\/b>-Objekts und gibt einige der Eigenschaften aus:<\/p>\n Indizes ermitteln<\/b><\/p>\n Auch auf die Indizes einer Tabelle können Sie per DAO zugreifen. Dazu liefert das TableDef<\/b>-Objekt eine Auflistung namens Indexes<\/b>. Jeder Index kann ein oder mehrere Felder betreffen. Dementsprechend enthält das Index<\/b>-Objekt wiederum eine Fields<\/b>-Auflistung, über die Sie alle Felder des Indexes abfragen können. Die folgende Beispielprozedur rufen Sie wiederum für jedes TableDef<\/b>-Objekt einmal auf:<\/p>\n Die Prozedur durchläuft erst alle Elemente der Indexes<\/b>-Auflistung und gibt einige Eigenschaften des aktuellen Indexes aus. Danach durchläuft sie alle Felder des Indexes und gibt auch diese aus:<\/p>\n Beziehungen ermitteln<\/b><\/p>\n Die Beziehungen wiederum befinden sich im Objektmodell nicht unterhalb der TableDef<\/b>-Objekte, sondern auf der gleichen Ebene. Das scheint auch logisch, denn schließlich betrifft jede Beziehung zwei Tabellen und verbindet diese.<\/p>\n <\/p>\n Die folgende Beispielprozedur liefert alle Beziehungen der aktuellen Datenbank. ForeignTable <\/b>liefert dabei die Tabelle, die das Primärschlüsselfeld der Beziehung enthält, Table <\/b>die Tabelle mit dem Fremdschlüsselfeld.<\/p>\n Die Fields<\/b>-Auflistung liefert in der Regel nur ein Field<\/b>-Objekt (außer, Sie erstellen eine Beziehung mit zwei Feldern jeder Tabelle – dies sollten Sie jedoch vermeiden).<\/p>\n Dieses Field<\/b>-Objekt liefert über die Eigenschaft Name <\/b>das Feld der Tabelle mit dem Primärschlüssel. Den Namen des Fremdschlüsselfeldes finden Sie mit der Eigenschaft ForeignName <\/b>des Field<\/b>-Objekts heraus.<\/p>\n Damit haben Sie alle Informationen zusammen, die eine Dokumentation der Tabellen erfordert – wir haben zwar nur jeweils ein paar Eigenschaften der betroffenen Objekte untersucht, aber das reicht für den Anfang. Die übrigen Elemente schauen wir uns später an.<\/p>\n Struktur und Inhalt der Dokumentation<\/b><\/p>\n Normalerweise wird eine Tabellendokumentation etwa in diesem Schema aufgebaut sein:<\/p>\n Beim Schreiben der Informationen in das Direktfenster kann man einfach alle Informationen heruntertippen – gegebenenfalls verwendet man noch ein paar Einrückungen, um die Struktur zu verdeutlichen.<\/p>\n Sollen die Daten in ein XML-Dokument geschrieben werden, sieht dies schon anders aus. XML basiert darauf, dass es zu jedem Element ein öffnendes und ein schließendes Tag gibt:<\/p>\n Dies kann, wenn sich keine Elemente dazwischen befinden, auch zu einem Element zusammengefasst werden:<\/p>\n In unserem Fall brauchen wir allerdings einige Verschachtelungen:<\/p>\n Das heißt, dass unsere Prozedur nicht nur einfach die Elemente des Datenmodells herunterbeten muss, sondern auch noch zu berücksichtigen hat, dass jedes ausgegebene Element eventuell auch noch ein schließendes Element benötigt.<\/p>\n Wir müssen den Aufruf der Methoden zum eigentlichen Ausgeben also so strukturieren, dass wir zum Beispiel im Falle einer XML-Dokumentation eine Verschachtelung abbilden können.<\/p>\n Auch ein Export in ein Word-Dokument könnte dies erfordern: Vielleicht möchte ja jemand die Eigenschaften der Felder einer Tabelle in einer Word-Tabelle abbilden und anschließend eine Tabellenunterschrift ausgeben.<\/p>\n Dann wäre es sinnvoll, eine Prozedur zu haben, die im Anschluss an die Ausgabe der Felder einer Tabelle aufgerufen werden kann.<\/p>\n Struktur der verwendeten Module und Klassen<\/p>\n Wie bereits erwähnt, kann es durchaus interessant sein, die Dokumentation in verschiedenen Formaten zu exportieren – Direktfenster, Word, XML und HTML sind nur ein paar Möglichkeiten. Um möglichst wenig Code mehrmals schreiben zu müssen, arbeiten wir mit drei Komponenten:<\/p>\n Die zweite ist eine Klasse, die mit der Anweisung Implements IDatabaseDocumentation <\/b>als Implementierung der oben genannten Schnittstelle definiert wird. Sie enthält den Code, der nach dem Aufruf der Methoden der Implementierung ausgeführt werden soll. Beispiele für diese Implementierung schauen wir uns gleich im Detail an.<\/p>\n Listing 1: Diese Schnittstelle definiert alle Methoden für die Ausgabe des Datenmodells.<\/p>\n Die Grundlagen zu dieser Vorgehensweise finden Sie im Beitrag Schnittstellenvererbung <\/b>(www.access-im-unternehmen.de\/734<\/b>).<\/p>\n Die Schnittstelle<\/b><\/p>\n Die Schnittstelle dieser Lösung (s. Listing 1<\/a>) enthält eine ganze Reihe Prozeduren, von denen die meisten dazu dienen, die Ausgabe von Tabellen, Feldern, Indizes oder Beziehungen einzuleiten oder zu beenden, damit man auch bei Verwendung von Formaten wie XML alle öffnenden und schließenden Tags setzen kann.<\/p>\n Sie werden nicht alle immer benötigen – die Ausgabe ins Direktfenster beispielsweise verwendet die Prozeduren, die das Beenden der Ausgabe etwa der Felder einer Tabelle ankündigt, nur zu kosmetischen Zwecken (hier für die Ausgabe einer Leerzeile).<\/p>\n Einige der Prozeduren erwarten Parameter. Dabei handelt es sich jeweils um die Prozeduren, welche die Ausgabe eines bestimmten Objekttyps einleiten, zum Beispiel StartPrintTables<\/b>. Dieser Prozedur übergeben wir später als Parameter die Anzahl der Tabellen und einen Variable zum Aufnehmen des Rückgabewertes Cancel<\/b>.<\/p>\n Auf diese Weise soll die Implementierung dieser Prozedur auf die Anzahl der im Anschluss auszugebenden Tabellen reagieren können. Wenn die Datenbank keine Tabellen enthält, wird der Wert 0 <\/b>für den Parameter intTableCount <\/b>übergeben.<\/p>\n\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_05\/TabellenDokumentieren_5-web-images\/pic001.png\")
<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_05\/TabellenDokumentieren_5-web-images\/pic002.png\")
<\/p>\n\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_05\/TabellenDokumentieren_5-web-images\/pic003.png\")
<\/p>\n\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_05\/TabellenDokumentieren_5-web-images\/pic004.png\")
<\/p>\nPublic Sub TabellenErmitteln()\r\n Dim db As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Set db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n Debug.Print tdf.Name, tdf.DateCreated\r\n Next tdf\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n
If Not (tdf.Name Like "MSys*" Or tdf.Name Like "USys*") Then\r\n Debug.Print tdf.Name, tdf.DateCreated\r\nEnd If<\/pre>\n
Call FelderErmitteln(tdf)<\/pre>\n
Public Sub FelderErmitteln(tdf As DAO.TableDef)\r\n Dim fld As DAO.Field\r\n For Each fld In tdf.Fields\r\n Debug.Print fld.Name, fld.Type, fld.Size\r\n Next fld\r\nEnd Sub<\/pre>\n
Call IndizesErmitteln(tdf)<\/pre>\n
Public Sub IndizesErmitteln(tdf As DAO.TableDef)\r\n Dim idx As DAO.Index\r\n Dim fld As DAO.Field\r\n For Each idx In tdf.Indexes\r\n Debug.Print idx.Name, idx.Primary, idx.Foreign, idx.IgnoreNulls\r\n For Each fld In idx.Fields\r\n Debug.Print " " & fld.Name\r\n Next fld\r\n Next idx\r\nEnd Sub<\/pre>\n
Public Sub BeziehungenErmitteln()\r\n Dim db As DAO.Database\r\n Dim rel As DAO.Relation\r\n Dim fld As DAO.Field\r\n Set db = CurrentDb\r\n For Each rel In db.Relations\r\n Debug.Print rel.Name, rel.Table, rel.ForeignTable\r\n For Each fld In rel.Fields\r\n Debug.Print " " & fld.Name, fld.ForeignName\r\n Next fld\r\n Next rel\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n
Datenbank\r\n Tabelle 1\r\n Feld 1\r\n Feld 2\r\n ...\r\n Index 1\r\n Index 2\r\n ...\r\n Beziehung 1\r\n Beziehung 2\r\n ...\r\n Tabelle 2\r\n ...<\/pre>\n
<database><\/database><\/pre>\n
<database \/><\/pre>\n
<database>\r\n <tables>\r\n <table name="tblAdressen">\r\n <fields>\r\n <field name="AdresseID" ...>\r\n <\/field>\r\n <\/fields>\r\n <indexes>\r\n ...\r\n <\/indexes>\r\n <relations>\r\n ...\r\n <\/relations>\r\n <\/table>\r\n <table name="tblAnreden">\r\n ...\r\n <\/table>\r\n <\/tables>\r\n<\/database><\/pre>\n
\n
Public Sub StartDocumentation(strDatabase As String, strPath As String, db As DAO.Database)\r\nEnd Sub\r\nPublic Sub StartPrintTables(intTableCount As Integer, cancel As Boolean)\r\nEnd Sub\r\nPublic Sub StartPrintTable(strTablename As String, strDescription As String, tdf As DAO.TableDef)\r\nEnd Sub\r\nPublic Sub StartPrintFields(intFieldCount As Integer, cancel As Boolean)\r\nEnd Sub\r\nPublic Sub StartPrintField(strField As String, strFieldtype As String, intFieldsize As Integer, fld As DAO.Field)\r\nEnd Sub\r\nPublic Sub FinishPrintField()\r\nEnd Sub\r\nPublic Sub FinishPrintFields()\r\nEnd Sub\r\nPublic Sub StartPrintIndexes(intIndexesCount As Integer, cancel As Boolean)\r\nEnd Sub\r\nPublic Sub StartPrintIndex(strName As String, idx As DAO.Index)\r\nEnd Sub\r\nPublic Sub FinishPrintIndex()\r\nEnd Sub\r\nPublic Sub FinishPrintIndexes()\r\nEnd Sub\r\nPublic Sub StartPrintRelations(intRelationCount As Integer, cancel As Boolean)\r\nEnd Sub\r\nPublic Sub StartPrintRelation(strTable1 As String, strTable2 As String, strField1 As String, _\r\nstrField2 As String, rel As DAO.Relation)\r\nEnd Sub\r\nPublic Sub FinishPrintRelation()\r\nEnd Sub\r\nPublic Sub FinishPrintRelations()\r\nEnd Sub\r\nPublic Sub FinishPrintTable()\r\nEnd Sub\r\nPublic Sub FinishPrintTables()\r\nEnd Sub\r\nPublic Sub FinishDocumentation()\r\nEnd Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_05\/TabellenDokumentieren_5-web-images\/pic005.png\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2010_05\/TabellenDokumentieren_5-web-images\/pic006.png\")
<\/p>\n