{"id":55000469,"date":"2026-02-01T00:00:00","date_gmt":"2026-03-10T12:06:57","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=469"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"ADODB_Datenbankinformationen_mit_OpenSchema","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/ADODB_Datenbankinformationen_mit_OpenSchema\/","title":{"rendered":"ADODB: Datenbankinformationen mit OpenSchema"},"content":{"rendered":"

\"\"Wenn Du per VBA auf eine Datenbank zugreifst, stellt sich manchmal die Frage: Welche Tabellen gibt es eigentlich? Welche Spalten hat eine bestimmte Tabelle und welche Datentypen verwenden diese? Gibt es Indizes oder Primärschlüssel? Die OpenSchema<\/b>-Methode der Connection<\/b>-Klasse aus der ADODB-Bibliothek liefert genau solche Metadaten – und zwar unabhängig davon, ob Du mit einer Access-Datenbank oder einem SQL Server arbeitest. In diesem Artikel zeigen wir, wie Du mit OpenSchema<\/b> die Struktur einer Datenbank abfragen kannst. Dabei stellen wir die wichtigsten Schema-Typen vor und zeigen für jeden ein praktisches Beispiel.<\/b><\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels findest Du in der Beispieldatenbank ADODB_OpenSchema.accdb<\/b>. Diese enthält ein Modul mdlOpenSchema<\/b> mit allen hier vorgestellten Prozeduren. Die Datenbank enthält außerdem einige Beispieltabellen, auf deren Struktur wir mit OpenSchema<\/b> zugreifen.<\/p>\n

Was ist OpenSchema?<\/h2>\n

OpenSchema<\/b> ist eine Methode des Connection<\/b>-Objekts von ADODB. Sie liefert ein Recordset<\/b> zurück, das Metadaten über die Struktur der verbundenen Datenbank enthält. Das können Informationen über Tabellen, Spalten, Indizes, Primärschlüssel, gespeicherte Prozeduren und vieles mehr sein.<\/p>\n

Der Aufruf sieht grundsätzlich so aus:<\/p>\n

Dim <\/span>rst As <\/span>ADODB.Recordset\r\nSet<\/span> rst = cnn.OpenSchema(SchemaTyp)<\/pre>\n
Der Parameter SchemaTyp<\/b> ist ein Wert der Enumeration SchemaEnum<\/b>. Dieser bestimmt, welche Art von Metadaten abgerufen wird.<\/p>\n
Optional können wir einen zweiten Parameter Criteria<\/b> übergeben, um die Ergebnisse einzuschränken – dazu kommen wir weiter unten.<\/p>\n
Voraussetzungen<\/h2>\n
Für die Verwendung von OpenSchema<\/b> benötigst Du einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects 6.1 Library<\/b>. Diesen fügst Du im VBA-Editor über Extras|Verweise<\/b> hinzu (siehe Bild 1).<\/p>\n
\"Verweis<\/p>\n
Bild 1: Verweis auf die ADODB-Bibliothek <\/span><\/b><\/p>\n
Außerdem benötigst Du ein geöffnetes Connection<\/b>-Objekt. Innerhalb einer Access-Datenbank kannst Du dafür einfach CurrentProject.Connection<\/b> verwenden. Für eine Verbindung zum SQL Server erstellst Du ein eigenes Connection<\/b>-Objekt mit der passenden Verbindungszeichenfolge, wie wir es im Artikel ADODB: Die Connection-Klasse<\/b> (www.vbentwickler.de\/446<\/b>) beschrieben haben.<\/p>\n
Übersicht der wichtigsten Schema-Typen<\/h2>\n
Die Enumeration SchemaEnum<\/b> enthält eine große Anzahl von Konstanten. Die folgenden sind in der Praxis besonders relevant:<\/p>\n
    \n
  • adSchemaTables<\/b> (20<\/b>): Listet alle Tabellen und Sichten (Views) der Datenbank auf.<\/li>\n
  • adSchemaColumns<\/b> (4<\/b>): Liefert alle Spalten aller Tabellen mit Datentyp, Länge und weiteren Informationen.<\/li>\n
  • adSchemaIndexes<\/b> (12<\/b>): Zeigt alle Indizes der Datenbank mit den zugehörigen Spalten und Eigenschaften an.<\/li>\n
  • adSchemaPrimaryKeys<\/b> (28<\/b>): Liefert die Primärschlüssel aller Tabellen.<\/li>\n
  • adSchemaForeignKeys<\/b> (27<\/b>): Zeigt alle Fremdschlüsselbeziehungen zwischen den Tabellen.<\/li>\n
  • adSchemaProcedures<\/b> (16<\/b>): Listet gespeicherte Prozeduren auf. Bei Access sind dies die gespeicherten Abfragen.<\/li>\n
  • adSchemaViews<\/b> (23<\/b>): Zeigt die Sichten (Views) der Datenbank an.<\/li>\n<\/ul>\n
    In den folgenden Abschnitten stellen wir die wichtigsten dieser Schema-Typen mit je einem vollständigen Codebeispiel vor.<\/p>\n
    Tabellen einer Datenbank auflisten<\/h2>\n
    Der wohl häufigste Anwendungsfall ist das Auflisten aller Tabellen einer Datenbank. Dazu verwenden wir die Konstante adSchemaTables<\/b>. Das zurückgegebene Recordset enthält unter anderem die folgenden Felder:<\/p>\n
      \n
    • TABLE_CATALOG<\/b>: Name der Datenbank<\/li>\n
    • TABLE_SCHEMA<\/b>: Schema der Tabelle (bei Access meist leer, bei SQL Server zum Beispiel dbo<\/b>)<\/li>\n
    • TABLE_NAME<\/b>: Name der Tabelle<\/li>\n
    • TABLE_TYPE<\/b>: Art des Objekts, zum Beispiel TABLE<\/b>, VIEW<\/b>, SYSTEM TABLE<\/b> oder ACCESS TABLE<\/b><\/li>\n<\/ul>\n
      Die Prozedur in Listing 1 gibt alle Tabellen der aktuellen Access-Datenbank im Direktbereich aus.<\/p>\n
      Public Sub <\/span>TabellenAuflisten()\r\n    Dim <\/span>cnn As <\/span>ADODB.Connection\r\n    Dim <\/span>rst As <\/span>ADODB.Recordset\r\n    Dim <\/span>strConnection As String<\/span>\r\n    Dim <\/span>strServer As String<\/span>\r\n    Dim <\/span>strDatabase As String<\/span>\r\n    strServer = \"amvDesktop2023\"\r\n    strDatabase = \"Mitarbeiterverwaltung\"\r\n    Set<\/span> cnn = New<\/span> ADODB.Connection\r\n    strConnection = \"Provider=MSOLEDBSQL;Data Source=\" _\r\n        & strServer & \";Initial Catalog=\" & strDatabase _\r\n        & \";Integrated Security=SSPI;\"\r\n    cnn.Open strConnection\r\n    Set<\/span> rst = cnn.OpenSchema(adSchemaTables)\r\n    Do While<\/span> Not<\/span> rst.EOF\r\n        Debug.Print<\/span> rst!TABLE_NAME, rst!TABLE_TYPE\r\n        rst.MoveNext<\/span>\r\n    Loop<\/span>\r\n    rst.Close\r\n    Set<\/span> rst = Nothing\r\n    cnn.Close\r\n    Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\n
      Listing 1: Alle Tabellen der Datenbank auflisten<\/span><\/b><\/p>\n
      Im Direktbereich erscheint dann eine Auflistung aller Tabellen mit dem jeweiligen Typ. Dabei wirst Du feststellen, dass neben den von Dir angelegten Tabellen auch Systemtabellen erscheinen, die Access intern verwendet, und Views.<\/p>\n
      Ergebnisse filtern mit Criteria<\/h2>\n
      Oft benötigst Du nicht alle Informationen, die OpenSchema<\/b> liefert. In diesem Fall kannst Du den optionalen Parameter Criteria<\/b> verwenden. Dieser erwartet ein Array<\/b> mit Filterwerten, wobei die Anzahl und Bedeutung der Array-Elemente vom jeweiligen Schema-Typ abhängt.<\/p>\n
      Für adSchemaTables<\/b> akzeptiert Criteria<\/b> ein Array mit vier Elementen in der folgenden Reihenfolge:<\/p>\n
        \n
      • TABLE_CATALOG<\/b>: Datenbankname (oder Null<\/b> für alle)<\/li>\n
      • TABLE_SCHEMA<\/b>: Schemaname (oder Null<\/b> für alle)<\/li>\n
      • TABLE_NAME<\/b>: Tabellenname (oder Null<\/b> für alle)<\/li>\n
      • TABLE_TYPE<\/b>: Tabellentyp (oder Null<\/b> für alle)<\/li>\n<\/ul>\n
        Wenn wir beispielsweise nur die regulären Tabellen anzeigen wollen und keine Systemtabellen oder Sichten, können wir das wie in Listing 2 formulieren.<\/p>\n
        Public Sub <\/span>NurTabellen()\r\n    ...\r\n    cnn.Open strConnection\r\n    Set<\/span> rst = cnn.OpenSchema(adSchemaTables, Array(Null, Null, Null, \"TABLE\"))\r\n    Do While<\/span> Not<\/span> rst.EOF\r\n        Debug.Print<\/span> rst!TABLE_NAME, rst!TABLE_TYPE\r\n        rst.MoveNext<\/span>\r\n    Loop<\/span>\r\n    rst.Close\r\n    Set<\/span> rst = Nothing\r\nEnd Sub<\/span><\/pre>\n
        Listing 2: Nur benutzerdefinierte Tabellen anzeigen<\/span><\/b><\/p>\n
        Hier übergeben wir für die ersten drei Elemente des Arrays den Wert Null<\/b>, da wir keine Einschränkung für Katalog, Schema oder Tabellenname vornehmen möchten. Das vierte Element setzen wir auf den Wert TABLE<\/b>, wodurch nur reguläre Tabellen zurückgegeben werden.<\/p>\n
        Spalten einer Tabelle ermitteln<\/h2>\n
        Mit adSchemaColumns<\/b> können wir die Spalten einer Tabelle samt Datentyp, Länge und weiteren Eigenschaften abfragen. Das ist besonders nützlich, wenn Du zur Laufzeit die Struktur einer Tabelle analysieren musst – zum Beispiel für einen generischen Export oder eine dynamische Formularerstellung.<\/p>\n
        Das zurückgegebene Recordset enthält unter anderem diese Felder:<\/p>\n
          \n
        • COLUMN_NAME<\/b>: Name der Spalte<\/li>\n
        • DATA_TYPE<\/b>: Numerischer Wert für den Datentyp (entspricht den ADODB-Typkonstanten wie adInteger<\/b>, adVarWChar<\/b> und so weiter)<\/li>\n
        • CHARACTER_MAXIMUM_LENGTH<\/b>: Maximale Zeichenlänge bei Textspalten<\/li>\n
        • IS_NULLABLE<\/b>: Gibt an, ob die Spalte Null-Werte erlaubt<\/li>\n
        • ORDINAL_POSITION<\/b>: Position der Spalte in der Tabelle<\/li>\n<\/ul>\n
          Der Criteria<\/b>-Parameter für adSchemaColumns<\/b> akzeptiert ein Array mit vier Elementen:<\/p>\n
          TABLE_CATALOG<\/b>, TABLE_SCHEMA<\/b>, TABLE_NAME<\/b> und COLUMN_NAME<\/b>.<\/p>\n
          In Listing 3 filtern wir die Ergebnisse auf eine bestimmte Tabelle.<\/p>\n
          Public Sub <\/span>SpaltenErmitteln()\r\n    ...\r\n    Set<\/span> rst = cnn.OpenSchema(adSchemaColumns, Array(Null, Null, \"tblKunden\", Null))\r\n    Do While<\/span> Not<\/span> rst.EOF\r\n        Debug.Print<\/span> rst!COLUMN_NAME, rst!DATA_TYPE, rst!CHARACTER_MAXIMUM_LENGTH\r\n        rst.MoveNext<\/span>\r\n    Loop<\/span>\r\n    rst.Close\r\n    Set<\/span> rst = Nothing\r\nEnd Sub<\/span><\/pre>\n
          Listing 3: Spalten einer Tabelle ermitteln<\/span><\/b><\/p>\n
          Die Ausgabe zeigt für jede Spalte den Namen, den numerischen Datentyp und die maximale Zeichenlänge. Bei numerischen Spalten ist die Zeichenlänge Null<\/b> (siehe Bild 2).<\/p>\n
          \"Tabellen<\/p>\n
          Bild 2: Tabellen einer Datenbank<\/span><\/b><\/p>\n
          Datentyp-Nummern lesbar machen<\/h2>\n
          Die Spalte DATA_TYPE<\/b> liefert numerische Werte, die den Konstanten der Enumeration DataTypeEnum<\/b> entsprechen.<\/p>\n
          Um die Ausgabe lesbarer zu gestalten, können wir eine Hilfsfunktion erstellen, die den numerischen Wert in einen lesbaren Namen umwandelt (siehe Listing 4).<\/p>\n
          Public Function <\/span>DatentypName( _\r\n          ByVal lngTyp As Long<\/span>) As String<\/span>\r\n     Select Case lngTyp\r\n          Case <\/span>2: DatentypName = \"SmallInt\"\r\n          Case <\/span>3: DatentypName = \"Integer\"\r\n          Case <\/span>4: DatentypName = \"Single\"\r\n          Case <\/span>5: DatentypName = \"Double\"\r\n          Case <\/span>6: DatentypName = \"Currency\"\r\n          Case <\/span>7: DatentypName = \"Date\"\r\n          Case <\/span>11: DatentypName = \"Boolean\"\r\n          Case <\/span>17: DatentypName = \"Byte\"\r\n          Case <\/span>72: DatentypName = \"GUID\"\r\n          Case <\/span>130: DatentypName = \"Text (WChar)\"\r\n          Case <\/span>202: DatentypName = \"VarWChar\"\r\n          Case <\/span>203: DatentypName = \"LongVarWChar\"\r\n          Case <\/span>205: DatentypName = \"LongVarBinary\"\r\n          Case Else<\/span>\r\n               DatentypName = \"Typ \" & lngTyp\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
          Listing 4: Hilfsfunktion zum Umwandeln der Datentypen<\/span><\/b><\/p>\n
          Diese Funktion kannst Du in der Prozedur SpaltenErmitteln<\/b> verwenden, indem Du die Zeile mit rst!DATA_TYPE<\/b> wie folgt anpasst:<\/p>\n
          Debug.Print<\/span> rst!COLUMN_NAME,\r\n     DatentypName(rst!DATA_TYPE),\r\n     rst!CHARACTER_MAXIMUM_LENGTH<\/pre>\n
          Damit erhalten wir das Ergebnis aus Bild 3.<\/p>\n
          \"Felder<\/p>\n
          Bild 3: Felder einer Tabelle<\/span><\/b><\/p>\n
          Indizes einer Tabelle abfragen<\/h2>\n
          Mit adSchemaIndexes<\/b> kannst Du herausfinden, welche Indizes für eine Tabelle definiert sind. Das ist nützlich, wenn Du die Performance einer Datenbank analysieren oder prüfen möchtest, ob ein bestimmter Index vorhanden ist. Die wichtigsten Felder im Ergebnis-Recordset sind:<\/p>\n