<\/p>\n
Beim Debuggen von VBA-Code, der Anweisungen für den Zugriff auf die Daten der Anwendung per DAO enthält, benötigt man immer wieder mal Detailinformationen. Welche Felder enthält die Tabelle noch Welchen Wert enthalten die Felder des aktuellen Datensatzes Wie viele Datensätze liefert das aktuelle Recordset Die notwendigen Informationen kann man sich mithilfe entsprechender Ausdrücke über das Direktfenster holen, aber meist kostet dies unnötig Zeit. Warum also nicht einfach eine kleine Hilfsklasse programmieren, die solche Fragen sehr einfach beantwortet Dieser Beitrag zeigt, wie es gelingt.<\/b><\/p>\n
Die Idee für diesen Betrag stammt aus meinen alltäglichen Bedürfnissen. Erstens habe ich wirklich oft den Bedarf, mal eben die Werte der Felder eines gerade in Bearbeitung befindlichen Datensatzes auszugeben oder auch nur dessen Feldnamen, zweitens kamen mit der Zeit noch weitere Ideen hinzu – abgeleitet zum Beispiel von MySQL, wo es einen einfachen Befehl etwa zur Anzeige aller Tabellen (ShowTables<\/b>) oder zur Ausgabe der Beschreibung einer Tabelle gibt (Describe Also habe ich eine Klasse entwickelt, die solche Fragen beantwortet. In den folgenden Abschnitten schauen wir uns an, wie die Klasse aufgebaut ist und welche Fragen sie beantworten kann.<\/p>\n Alle Tabellen ausgeben<\/b><\/p>\n Den Befehl ShowTables<\/b> unter MySQL fand ich schon immer praktisch. Gerade wenn man nicht so oft mit einer Datenbank arbeitet, merkt man sich nicht unbedingt alle Tabellennamen – und zum Nachschlagen eines Tabellennamens immer vom VBA-Editor zum Access-Fenster zu wechseln macht auch keinen Spaß, vor allem, wenn der Navigationsbereich einige hundert Elemente enthält, durch die man sich erst mal zu den Tabellen durchkämpfen muss.<\/p>\n Also entwickeln wir zunächst einmal die Methode ShowTables<\/b>, die eine Liste aller Tabellen der Datenbank in alphabetischer Reihenfolge im Direktfenster ausgeben soll.<\/p>\n Die Ausgabe könnte etwa wie in Bild 1 aussehen, sobald man den Befehl ShowTables <\/b>dort eingibt und die Eingabetaste betätigt.<\/p>\n Bild 1: Ausgabe der Tabellen einer Datenbank mit Detailinformationen<\/span><\/b><\/p>\n Dafür benötigen wir natürlich eine entsprechende Prozedur, die Sie in Listing 1 finden. Die Prozedur verwendet eine Enumeration, die im gleichen Modul wie folgt deklariert wird:<\/p>\n Listing 1: Ausgabe der Tabellen einer Datenbank im Direktfenster des VBA-Editors<\/span><\/b><\/p>\n Die Enumeration stellt die Werte für den Parameter der Prozedur ShowTables <\/b>bereit. Sie sollen mit der Prozedur nämlich nicht nur alle Tabellen ausgeben können, sondern auch nur alle lokalen Tabellen, alle ODBC-Tabellen oder auch nur die verknüpften Tabellen.<\/p>\n Um nur die lokalen Tabellen auszugeben, geben Sie etwa den folgenden Befehl im Direktfenster ein:<\/p>\n Aber es gibt noch weitere Möglichkeiten, die auszugebenden Tabellen einzuschränken: Mit dem zweiten Parameter namens bolSystem<\/b> legen Sie fest, ob Systemtabellen ausgegeben werden sollen. Der dritte Parameter bolHidden <\/b>gibt schließlich an, ob auch versteckte Dateien in der Liste erscheinen sollen. Da beide Parameter standardmäßig auf den Wert True <\/b>eingestellt sind, müssten Sie etwa den folgenden Aufruf verwenden, um nur die lokalen Tabellen ohne versteckte Tabellen und Systemtabellen auszugeben:<\/p>\n Die Prozedur prüft zunächst, ob der Benutzer eines der Enumeration-Elemente zur Einschränkung des Tabellentyps angegeben hat. Falls nicht, ist intType = 0 <\/b>und wir können intType per logischer Und-Verknüpfung auf alle Typen einstellen (dbLocal + dbODBC + dbLinked<\/b>).<\/p>\n Danach öffnet die Prozedur ein Recordset mit allen Tabellen auf Basis der Systemtabelle MSysObjects<\/b>. Man könnte zwar auch die TableDefs<\/b>-Auflistung verwenden, um auf die Tabellen zuzugreifen, aber mit MSysObjects <\/b>können wir die Tabellen direkt alphabetisch sortieren.<\/p>\n Die Abfrage enthält direkt einen Filter nach den entsprechenden Objekttypen – hier 1 <\/b>für lokale Tabellen, 4 <\/b>für ODBC-Tabellen und 6 <\/b>für eingebundene Tabellen.<\/p>\n Damit wir eine saubere Darstellung in zwei Spalten erreichen, benötigen wir noch die maximale Länge der Tabellennamen. Diese holt die Prozedur mit einer DMax<\/b>-Abfrage über den Ausdruck Len(Name) <\/b>für die Tabelle MSysObjects<\/b>.<\/p>\n Danach bildet die Prozedur die Spaltenüberschriften im Direktfenster ab, wobei nach einer Leerzeile die beiden überschriften Table <\/b>und Type <\/b>folgen. Den Abstand dazwischen liefert die Space<\/b>-Funktion, die den Text Type <\/b>so platziert, dass er knapp rechts neben dem längsten Tabellennamen landet. Auch die Anzahl der als Linie dienenden Minuszeichen wird anhand der Länge des längsten Tabellennamens ermittelt.<\/p>\n Danach steigt die Prozedur in eine Do While<\/b>-Schleife über alle Datensätze des Recordsets rst <\/b>ein. Darin ergänzt sie den Inhalt des Feldes Name des Recordsets um die entsprechende Menge Leerzeichen, damit alle Tabellennamen die Länge des längsten Namens haben, und speichert das Ergebnis in der Variablen strTable<\/b>.<\/p>\n Dann stellt sie die Variable bolShow <\/b>auf True <\/b>ein. Diese legt fest, ob die Tabelle aus dem aktuellen Datensatz ausgegeben wird, und kann in den folgenden Prüfungen noch auf False <\/b>eingestellt werden.<\/p>\n Zunächst jedoch kümmern wir uns darum, ob es sich um eine Systemtabelle handelt. Zunächst gehen wir nicht davon aus und setzen die Variable strSystem <\/b>auf eine leere Zeichenkette. Sollte die Tabelle sich allerdings als Systemtabelle herausstellen, was die Prozedur durch den Vergleich der Eigenschaft Attributes <\/b>des entsprechenden Eintrags der Auflistung TableDefs <\/b>mit der Konstanten dbSystemObject <\/b>herausfindet, erhält strSystem <\/b>den Wert |System<\/b>. Dieser wird später an einen Ausdruck angehängt, der den Typ der Tabelle charakterisiert.<\/p>\n Sollte der Benutzer für den Parameter bolSystem <\/b>jedoch den Wert False <\/b>übergeben haben, was bedeutet, dass er keine Systemtabellen in der Ausgabeliste wünscht, stellt die Prozedur nun die Variable bolShow <\/b>ebenfalls auf False <\/b>ein.<\/p>\n Danach folgt das gleiche Spiel für versteckte Tabellen. Diesmal wird die Variable strHidden <\/b>gegebenenfalls mit dem Wert |Hidden <\/b>gefüllt, falls es sich bei der Tabelle um eine versteckte Tabelle handelt, und die Variable bolShow <\/b>erhält den Wert False<\/b>, wenn der Parameter bolHidden <\/b>auch diesen Wert enthält.<\/p>\n Schließlich entscheidet der Wert von bolShow <\/b>darüber, ob die Tabelle in der Ausgabe landet. Hat die Variable den Wert False<\/b>, geschieht nichts weiter, anderenfalls werden die verschiedenen Tabellentypen anhand des Wertes des Feldes Type <\/b>des Recordsets entweder ausgegeben oder nicht.<\/p>\n Schauen wir uns das für den ersten Case<\/b>-Zweig der Select Case<\/b>-Anweisung an: Hat rst!Type <\/b>den Wert 1<\/b>, was auf eine lokale Tabelle hindeutet, prüft die Prozedur durch eine logische Konjunktion, ob der mit intType <\/b>übergebene Wert die Konstante dbLocal <\/b>enthält (mehr über logische Konjunktionen erfahren Sie im Beitrag Rund um Binärzahlen<\/b>, www.access-im-unternehmen.de\/556<\/b>).<\/p>\n In diesem Fall erhält die Variable strType <\/b>den Wert Local Table<\/b>. Außerdem gibt eine Debug.Print<\/b>-Anweisung den Namen der Tabelle (zuzüglich der weiter oben hinzugefügten Leerzeichen) und die Inhalte der Variablen strType<\/b>, strSystem <\/b>und strHidden <\/b>aus. Letztere könnten beispielsweise den Wert |Local Table|System|Hidden <\/b>liefern, wenn es sich um eine lokale, versteckte Systemtabelle handelt.<\/p>\n Die beiden übrigen Case<\/b>-Zweige erledigen dies ähnlich für ODBC-Tabellen und verknüpfte Tabellen.<\/p>\n Auf diese Weise gibt die Prozedur Informationen über alle Tabellen im Direktfenster aus.<\/p>\n Tabellenbeschreibungen<\/b><\/p>\n Die zweite Prozedur soll ähnliche Informationen liefern wie die Anweisung Describe Bild 2: Beschreibung einer Tabelle unter MySQL<\/span><\/b><\/p>\n Das können wir allerdings auch: Die nachfolgend beschriebene Prozedur namens Describe<\/b> liefert etwa die Ausgabe aus Bild 3.<\/p>\n Bild 3: Baugleiche Beschreibung im Direktbereich des VBA-Editors<\/span><\/b><\/p>\n Den ersten Teil der Prozedur, die diese Ausgabe liefert, finden Sie in Listing 2. Die Prozedur nimmt mit dem Parameter strTable <\/b>den Namen der zu untersuchenden Tabelle entgegen. Sie füllt die Variable db <\/b>mit einem Verweis auf die aktuelle Datenbank. Die Auflistung TableDefs <\/b>dieses Objekts liefert dann mit dem Namen der Tabelle als Parameter ein TableDef<\/b>-Objekt, das die Beschreibung der Tabelle sowie Auflistungen etwa der Tabellenfelder liefert. Dieses referenzieren wir mit der Variablen tdf<\/b>.<\/p>\n <\/p>\n Listing 2: Ausgabe der Felder einer Tabelle im Direktfenster des VBA-Editors (Teil I)<\/span><\/b><\/p>\n Zeichenlänge von Feldnamen und Standardwerten bestimmen<\/b><\/p>\n Im ersten Schritt durchlaufen wir alle Felder der Tabelle in einer For Each<\/b>-Schleife über die Auflsitung Fields<\/b>. Das jeweils aktuelle Element landet in der Variablen fld<\/b>.<\/p>\n Hier nehmen wir erstmal grundlegende Informationen auf, damit wir später die Breite der Spalten optimal auslegen können.<\/p>\n Die erste Information ist die Anzahl der Zeichen des längsten Feldnamens der Tabelle. Innerhalb der For Each<\/b>-Schleife prüft die Prozedur jeweils, ob die Länge des Feldnamens größer als die bereits in der Variablen intLen <\/b>gespeicherte Länge ist.<\/p>\n Falls ja, landet die Länge des aktuellen Feldnamens in dieser Variablen. Nach dem Durchlaufen der Schleife enthält intLen <\/b>somit die Anzahl der Zeichen des längsten Feldnamens.<\/p>\n Auf ähnliche Weise ermittelt die Prozedur anschließend die Länge des längsten Ausdrucks für die Eigenschaft DefaultValue <\/b>(zu deutsch: Standardwert<\/b>) und speichert diese in der Variablen intLenDefault<\/b>.<\/p>\n Danach wird intLen <\/b>um zwei erhöht, weil wir auf jeder Seite ein Zeichen Platz einräumen möchten.<\/p>\n Sollte das Feld mit dem längsten Feldnamen weniger als 16 Zeichen aufweisen, stellen wir intLen <\/b>auf 16 <\/b>ein.<\/p>\n Das Gleiche erledigt die Prozedur für die Variable intLenDefault<\/b>, nur dass hier die Mindestzeichenlänge sieben beträgt.<\/p>\n Damit können wir nun bereits die Spaltenüberschriften im Direktfenster ausgeben. Die Ausgabe besteht zunächst aus der Spaltenüberschrift Table, gefolgt von einer Reihe von Leerzeichen. Die Anzahl richtet sich nach der Anzahl Zeichen des längsten Feldnamens, die Space<\/b>-Funktion sorgt für die Ausgabe der entsprechenden Leerzeichen. Dann folgen die Spaltenüberschriften Type<\/b>, NULL<\/b>, KEY<\/b>, DEFAULT <\/b>und EXTRA<\/b>, jeweils durch das Pipe-Zeichen (|) voneinander getrennt. Auch hinter der Spalte DEFAULT <\/b>fügt die Anweisung einige Leerzeichen ein – hier in Abhängigkeit vom Wert der Variablen intLenDefault<\/b>.<\/p>\n Danach folgt die Trennlinie zwischen den Spaltenüberschriften und den eigentlichen Werten. Dabei berücksichtigen wir wieder die variable Breite der Spalten für die Feldnamen und die Standardwerte, diesmal durch den Aufruf der String<\/b>-Funktion, welche die benötigte Anzahl Minus-Zeichen liefert. Die übergänge von einem Spaltenkopf zum nächsten sind mit Plus-Zeichen versehen.<\/p>\n Felddatentypen bestimmen<\/b><\/p>\n Anschließend folgt eine weitere For Each<\/b>-Schleife über alle Felder des TableDef<\/b>-Objekts. Diesmal enthält diese einige Anweisungen zum Ermitteln der Feldeigenschaften sowie die Ausgabe der Informationen im Direktfenster.<\/p>\n Die erste Anweisung innerhalb der Schleife leert die Variable strType<\/b>. Diese nimmt gleich den Felddatentyp des aktuellen Feldes auf. Diesen ermittelt die Prozedur in einer Select Case<\/b>-Bedingung. Je nach dem Wert der Eigenschaft Type des Field<\/b>-Objekts trägt die Prozedur Werte wie ATTACHMENT<\/b>, BOOLEAN <\/b>oder CURRENCY <\/b>in strType <\/b>ein. Dies setzt sich im zweiten Teil der Prozedur, den Sie in Listing 3 finden, fort.<\/p>\n Listing 3: Ausgabe der Felder einer Tabelle im Direktfenster des VBA-Editors (Teil II)<\/span><\/b><\/p>\n Anschließend füllt die Prozedur den Inhalt von strType <\/b>so mit Leerzeichen auf, dass die Gesamtlänge der enthaltenen Zeichenkette 13 <\/b>beträgt.<\/p>\n Nun folgt die Spalte, die angibt, ob das Feld Null-Werte enthalten darf oder nicht. Dies ermittelt die Prozedur mit der Eigenschaft Required<\/b>. Hat diese den Wert True<\/b>, erhält strNull <\/b>den Wert NO<\/b>, anderenfalls den Wert YES<\/b>. NO <\/b>enthält noch ein folgendes Leerzeichen, damit beide Werte drei Zeichen lang sind.<\/p>\n Danach folgen die Indizes, in diesem Fall kümmern wir uns allerdings lediglich um Primärschlüssel und eindeutige Indizes. Der entsprechende Ausdruck soll in der Variablen strIndex <\/b>landen, die vorab mit drei Leerzeichen gefüllt wird. Warum nicht einfach mit einer leeren Zeichenkette Weil es auch sein kann, dass kein Index für dieses Feld festgelegt wurde – und dann benötigen wir eine entsprechend lange Zeichenkette, damit die Spalte die gewünschte Breite einhält.<\/p>\n Um die Indizes und deren Typ zu ermitteln, durchläuft die Prozedur zunächst die Indexes<\/b>-Auflistung des jeweiligen TableDef<\/b>-Objekts. Jedes Index<\/b>-Objekt enthält wiederum eine Auflistung der Felder, die zum Index gehören. Diese durchlaufen wir ebenfalls. Innerhalb der inneren For Each<\/b>-Schleife vergleicht die Prozedur dann den Namen des Feldes des Indexes mit dem Namen des aktuellen Tabellenfeldes. Stimmen beide überein, haben wir einen Index gefunden, der sich auf das aktuelle Tabellenfeld bezieht. Nun wollen wir noch herausfinden, um welche Art von Index es sich handelt. Hat die Eigenschaft Primary <\/b>des Index-Objekts den Wert True<\/b>, handelt es sich um einen Primärschlüssel.<\/p>\n Dies vermerken wir mit dem Wert PRI <\/b>in der Variablen strIndex<\/b>. Liegt kein Primärindex vor, prüfen wir den Index auf Eindeutigkeit. Diese Information liefert die Eigenschaft Unique<\/b>.<\/p>\n Liegt ein eindeutiger Index vor, soll strIndex <\/b>den Wert UNI <\/b>erhalten. Das war es für die Indizes – weitere Indexarten können Sie nach Wunsch ergänzen.<\/p>\n Fehlt noch eine Spalte, die weitere Informationen aufnimmt – in unserem Fall zunächst nur den Wert AUTOINCREMENT<\/b> für die Variable strExtra<\/b>, falls es sich um ein Autowert<\/b>-Feld handelt. Auch hier können Sie noch weitere Elemente hinzufügen.<\/p>\n Schließlich haben wir alle wichtigen Informationen gesammelt. Diese geben wir nun je Feld in einer einzigen Debug.Print<\/b>-Anweisung aus. Dabei werden wiederum die Spaltenbreiten durch gezielten Einsatz der Space<\/b>-Funktion angepasst.<\/p>\n Zu guter Letzt folgt eine Zeile mit einer Linie sowie eine mit der Anzahl der Felder in dieser Tabelle.<\/p>\n Feldwerte eines Datensatzes<\/b><\/p>\n Während die ersten beiden Prozeduren eher Informationen liefern, die man beim Programmieren mal eben abruft, folgen nun einige Beispiele, mit denen Sie auch beim Debuggen arbeiten können. Diese liefern nämlich konkrete Informationen zu den Werten, mit denen etwa die Felder des aktuellen Datensatzes gefüllt sind.<\/p>\n Daher erwarten die folgenden Prozeduren auch die übergabe von Objektverweisen als Parameter und nicht nur die Namen etwa einer Tabelle oder eines Feldes.<\/p>\n Stellen Sie sich vor, Sie debuggen eine soeben programmierte Prozedur, weil scheinbar etwas mit den Werten eines Recordsets nicht stimmt – etwa an einer Stelle wie in Bild 4.<\/p>\n Bild 4: Sie wollen an dieser Stelle die Feldinhalte erfahren<\/span><\/b><\/p>\n Normalerweise würden Sie dann manuell die entsprechenden Informationen im Direktfenster ausgeben lassen:<\/p>\n Dies setzt natürlich voraus, dass Sie den betroffenen Feldnamen kennen. Sonst arbeiten Sie sich vielleicht mit der folgenden Anweisung durch die einzelnen Felder:<\/p>\n Dies ist zeitraubend, vor allem, wenn Sie dies öfter erledigen müssen. Wie wäre es denn, wenn Sie diese Informationen wie in Bild 5 für alle Felder des aktuellen Recordsets mit einer einzigen Anweisung im Direktfenster ausgeben könnten<\/p>\n Bild 5: Feldnamen und -werte des aktuellen Recordsets mit einer einzigen Anweisung im Direktfenster ausgeben<\/span><\/b><\/p>\n Das hätte mir zu mancher Gelegenheit jedenfalls eine Menge Zeit gespart. Also schauen wir uns die Prozedur RecordsetValues<\/b> an, die wie in Listing 4 aussieht.<\/p>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2015_01\/pic_968_001.png\")
<\/p>\nPublic Sub <\/span>ShowTables(Optional<\/span> intType As <\/span>TableType, _\r\n Optional<\/span> bolSystem As Boolean<\/span> = True, Optional<\/span> bolHidden As Boolean<\/span> = True<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database, rst As <\/span>DAO.Recordset\r\n Dim <\/span>strType As String<\/span>, strTable As String<\/span>\r\n Dim <\/span>intLen As Integer<\/span>\r\n Dim <\/span>strSystem As String<\/span>, strHidden As String<\/span>\r\n Dim <\/span>bolShow As Boolean<\/span>\r\n If <\/span>intType = 0 Then<\/span> intType = dbLocal + dbODBC + dbLinked\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Name, Type FROM MSysObjects " _\r\n "WHERE Type IN (1,4,6) ORDER BY Name\", dbOpenDynaset)\r\n intLen<\/span> = DMax(\"Len<\/span>(Name)\", \"MSysObjects\")\r\n Debug.Print<\/span>\r\n Debug.Print<\/span> \"Table\" & Space(intLen<\/span> - 4) & \"Type\"\r\n Debug.Print<\/span> String(intLen<\/span> + 25, \"-\")\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strTable = rst!Name & Space(intLen<\/span> - Len<\/span>(rst!Name))\r\n bolShow = True<\/span>\r\n strSystem = \"\"\r\n If <\/span>(db.TableDefs(rst!Name).Attributes And dbSystemObject) Then<\/span>\r\n strSystem = \"|System\"\r\n If <\/span>bolSystem = False<\/span> Then<\/span> bolShow = False<\/span>\r\n End If<\/span>\r\n strHidden = \"\"\r\n If <\/span>(db.TableDefs(rst!Name).Attributes And dbHiddenObject) Then<\/span>\r\n strHidden = \"|Hidden\"\r\n If <\/span>bolHidden = False<\/span> Then<\/span> bolShow = False<\/span>\r\n End If<\/span>\r\n If <\/span>bolShow = True<\/span> Then<\/span>\r\n Select Case rst!Type\r\n Case <\/span>1\r\n If <\/span>(intType And dbLocal) = dbLocal Then<\/span>\r\n strType = \"Local Table\"\r\n Debug.Print<\/span> strTable & \" \" & strType & strSystem & strHidden\r\n End If<\/span>\r\n Case <\/span>4\r\n If <\/span>(intType And dbODBC) = dbODBC Then<\/span>\r\n strType = \"ODBC Table\"\r\n Debug.Print<\/span> strTable & \" \" & strType & strSystem & strHidden\r\n End If<\/span>\r\n Case <\/span>6\r\n If <\/span>(intType And dbLinked) = dbLinked Then<\/span>\r\n strType = \"Linked Table\"\r\n Debug.Print<\/span> strTable & \" \" & strType & strSystem & strHidden\r\n End If<\/span>\r\n End Select<\/span>\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Enum TableType\r\n dbLocal = 1\r\n dbODBC = 2\r\n dbLinked = 4\r\nEnd Enum<\/pre>\nShowTables dbLocal<\/pre>\n
ShowTables dbLocal, False, False<\/span><\/pre>\n![\"Beschreibung](\"..\/fileadmin\/_temp_\/2015_01\/pic_968_002.png\")
<\/p>\n![\"Baugleiche](\"..\/fileadmin\/_temp_\/2015_01\/pic_968_003.png\")
<\/p>\nPublic Sub <\/span>Describe(strTable As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>intLen As Integer<\/span>, intLenDefault As Integer<\/span>\r\n Dim <\/span>strType As String<\/span>, strNull As String<\/span>\r\n Dim <\/span>idx As <\/span>DAO.Index\r\n Dim <\/span>fldidx As <\/span>DAO.Field\r\n Dim <\/span>strIndex As String<\/span>, strExtra As String<\/span>\r\n Set<\/span> db = Currentdb\r\n Set<\/span> tdf = db.TableDefs(strTable)\r\n For Each fld In tdf.Fields\r\n If <\/span>Len<\/span>(fld.Name) > intLen Then<\/span>\r\n intLen<\/span> = Len<\/span>(fld.Name)\r\n End If<\/span>\r\n If <\/span>Len<\/span>(fld.DefaultValue) > intLenDefault Then<\/span>\r\n intLenDefault = Len<\/span>(fld.DefaultValue)\r\n End If<\/span>\r\n Next<\/span> fld\r\n intLen<\/span> = intLen<\/span> + 2\r\n If <\/span>intLen<\/span> < 16 Then<\/span>\r\n intLen<\/span> = 16\r\n End If<\/span>\r\n intLenDefault = intLenDefault + 2\r\n If <\/span>intLenDefault < 7 Then<\/span>\r\n intLenDefault = 7\r\n End If<\/span>\r\n Debug.Print<\/span> \"Table\" & Space(intLen<\/span> - 5) _\r\n & \"| Type | NULL | Key | DEFAULT\" & Space(intLenDefault - 7) _\r\n & \" | EXTRA\"\r\n Debug.Print<\/span> \"-----\" & String(intLen<\/span> - 5, \"-\") & \"+---------------+------+-----+-\" _\r\n & String(intLenDefault - 7, \"-\") & \"--------+------------------\"\r\n For Each fld In tdf.Fields\r\n strType = \"\"\r\n Select Case fld.Type\r\n Case <\/span>dbAttachment\r\n strType = \"ATTACHMENT\"\r\n Case <\/span>dbBoolean\r\n strType = \"BOOLEAN\"\r\n Case <\/span>dbCurrency\r\n strType = \"CURRENCY\"\r\n Case <\/span>dbDate\r\n strType = \"DATE\"\r\n Case <\/span>dbDouble\r\n strType = \"DOUBLE\"\r\n Case <\/span>dbGUID\r\n strType = \"GUID\"\r\n Case <\/span>dbInteger\r\n strType = \"INTEGER\"<\/pre>\n Case <\/span>dbLong\r\n strType = \"LONG\"\r\n Case <\/span>dbLongBinary\r\n strType = \"LONGBINARY\"\r\n Case <\/span>dbMemo\r\n strType = \"MEMO\"\r\n Case <\/span>dbSingle\r\n strType = \"SINGLE\"\r\n Case <\/span>dbText\r\n strType = \"TEXT\"\r\n Case Else<\/span>\r\n Debug.Print<\/span> fld.Type\r\n End Select<\/span>\r\n strType = strType & Space(13 - Len<\/span>(strType))\r\n If <\/span>fld.Required Then<\/span>\r\n strNull = \"NO \"\r\n Else<\/span>\r\n strNull = \"YES \"\r\n End If<\/span>\r\n strIndex = \" \"\r\n For Each idx In tdf.Indexes\r\n For Each fldidx In idx.Fields\r\n If <\/span>fldidx.Name = fld.Name Then<\/span>\r\n If <\/span>idx.Primary Then<\/span>\r\n strIndex = \"PRI\"\r\n Else<\/span>\r\n If <\/span>idx.Unique Then<\/span>\r\n strIndex = \"UNI\"\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> fldidx\r\n Next<\/span> idx\r\n strExtra = \"\"\r\n If <\/span>(fld.Attributes And dbAutoIncrField) = dbAutoIncrField Then<\/span>\r\n strExtra = strExtra & \", AUTOINCREMENT\"\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strExtra) > 0 Then<\/span>\r\n strExtra = Mid<\/span>(strExtra, 3)\r\n End If<\/span>\r\n Debug.Print<\/span> fld.Name & Space(intLen<\/span> - Len<\/span>(fld.Name)) & \"| \" & strType _\r\n & \" | \" & strNull & \" | \" & strIndex & \" | \" & fld.DefaultValue _\r\n & Space(intLenDefault - Len<\/span>(fld.DefaultValue)) & \" | \" & strExtra\r\n Next<\/span> fld\r\n Debug.Print<\/span> \"-----\" & String(intLen<\/span> - 5, \"-\") & \"+---------------+------+-----+-\" _\r\n & String(intLenDefault - 7, \"-\") & \"--------+------------------\"\r\n Debug.Print<\/span> tdf.Fields.Count & \" Fields\"\r\nEnd Sub<\/span><\/pre>\n![\"Sie](\"..\/fileadmin\/_temp_\/2015_01\/pic_968_004.png\")
<\/p>\nDebug.Print<\/span> rst!Artikelname<\/pre>\nDebug.Print<\/span> rst(0).Name, rst(0).Value<\/pre>\n![\"Feldnamen](\"..\/fileadmin\/_temp_\/2015_01\/pic_968_005.png\")
<\/p>\nPublic Sub <\/span>RecordsetValues(rst As <\/span>DAO.Recordset)\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>intLen As Integer<\/span>\r\n For Each fld In rst.Fields\r\n If <\/span>Len<\/span>(fld.Name) > intLen Then<\/span>\r\n intLen<\/span> = Len<\/span>(fld.Name)\r\n End If<\/span>\r\n intLen<\/span> = intLen<\/span> + 2\r\n If <\/span>intLen<\/span> < 15 Then<\/span>\r\n intLen<\/span> = 15\r\n