<\/p>\n
Unter dem SQL-Datenbankschema verstehen wir eine Reihe von SQL-Anweisungen, mit denen Sie Tabellen oder auch eine komplette Datenbank erstellen können. Dazu gehören beispielsweise die CREATE TABLE- oder CREATE INDEX-Anweisungen. Da man diese Befehle eher selten einsetzt, kann eine Lösung zum automatischen Erstellen des Schemas einer oder mehrerer Tabellen nicht schaden. Der vorliegende Beitrag zeigt, wie es funktioniert.<\/b><\/p>\n
Access macht es dem Entwickler leicht: Mit der Tabellenentwurfs-Ansicht, dem Indizes-Fenster und dem Beziehungen-Fenster bietet es uns drei Möglichkeiten, Tabellen und deren Beziehungen ganz einfach anzulegen. Im Tabellenentwurfsfenster erfassen wir die grundlegenden Daten wie die Felder mit ihren Datentypen und weitere Eigenschaften, im Indizes-Fenster verwalten wir einfache und zusammengesetzte Indizes und das Beziehungen-Fenster dient schließlich dazu, die Beziehungen zwischen den Tabellen anzulegen.<\/p>\n
Im Hintergrund rödelt Access ganz ordentlich und stellt die SQL-Anweisungen zusammen, welche die von uns angelegten Tabellen und Felder und auch änderungen an bestehenden Elementen zur Ausführung an die JET-Engine weitergeben.<\/p>\n
Solche Ausdrücke können Sie mit der Lösung des vorliegenden Beitrags selbst erstellen: Sie brauchen einfach nur das Formular aus Bild 1 zu öffnen und die gewünschte Tabelle auszuwählen, schon erscheinen die SQL-Ausdrücke zum Erstellen dieser Tabellen mit den gebräuchlichsten Eigenschaften im Formular.<\/p>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Datenbankschema-web-images\/pic005_opt.jpeg\")
<\/p>\n
Bild 1: Durch Auswählen einer Tabelle erhalten Sie den SQL-Ausdruck, um diese zu erstellen.<\/span><\/b><\/p>\n Grundlagen<\/b><\/p>\n SQL verwenden Sie ja normalerweise, um Abfragen für die Auswahl von Daten zu definieren oder auch zum Ausführen von Aktionsabfragen. Dieser Teil von SQL nennt sich Data Manipulation Language <\/b>(DML<\/b>). Für den vorliegenden Beitrag brauchen wir allerdings eine andere SQL-Teilmenge, nämlich die Data Definition Language <\/b>(DDL<\/b>). Sie enthält Befehle wie die oben bereits erwähnten CREATE TABLE…<\/b>– oder CREATE INDEX…<\/b>-Anweisungen. Mit ein wenig Einarbeitung können Sie mit diesen Befehlen Tabellen und Beziehungen sicher genauso schnell, wenn nicht noch schneller als mit den Elementen der Benutzeroberfläche erstellen.<\/p>\n Da die meisten von uns bequem sind, wird das aber kaum jemand tun. Dennoch kommt es vor, dass man eine oder mehrere SQL-Anweisungen zum Anlegen von Tabellen benötigt – beispielsweise, wenn Sie eine Tabelle per VBA-Code erstellen möchten. Dabei kann es sich um eine temporäre Tabelle handeln, die nur kurzzeitig benötigt und dann wieder gelöscht wird, zum Beispiel um zu importierende Daten vor dem Weiterverarbeiten zwischenzulagern. Oder Sie bauen einen Assistenten oder ein Tool, das per Mausklick Tabellen in Ihren Datenbanken anlegen soll. Dies ist zum Beispiel äußerst praktisch, wenn Ihre Datenbankanwendung immer wiederkehrerende Tabellen wie etwa eine Anreden<\/b>-Tabelle enthalten soll.<\/p>\n Ziel der nachfolgend vorgestellten Prozeduren ist es, auf Basis bestehender Tabellen SQL-Abfragen zu erzeugen, mit denen Sie die Tabellen nachbauen können. Für eine einfache Tabelle mit einem Primärschlüsselfeld namens AnredeID <\/b>und einem weiteren Textfeld namens Anrede <\/b>mit einer Feldgröße von 255 Zeichen benötigen Sie beispielsweise die folgenden beiden Zeilen:<\/p>\n Das Ganze ließe sich auch mit einer einzigen Zeile erledigen, und zwar so:<\/p>\n Warum wir in der nachfolgend beschriebenen Lösung die erste Variante verwenden, erfahren Sie weiter unten. Eine ganze Menge Informationen zu den Befehlen der Data Definition Language <\/b>erhalten Sie im Beitrag Datenbanken und Tabellen per SQL anpassen <\/b>(Shortlink 609).<\/p>\n DAO als Werkzeug zum Auslesen von Tabellen-, Feld- und Beziehungsinformationen<\/p>\n Bevor wir uns um das Erstellen der SQL-Anweisungen kümmern können, brauchen wir Möglichkeiten, die Struktur der Tabellen, Felder und Beziehungen auszulesen.<\/p>\n Wie aber soll dies gelingen – welche Bibliothek bietet Zugriff auf den Entwurf einer Datenbank Es handelt sich um die DAO<\/b>-Bibliothek, die Sie für den Zugriff auf die Daten einer Datenbank sicher schon Hunderte Male genutzt haben. Die für uns interessante Struktur basiert auf dem Database<\/b>-Objekt, das Sie normalerweise als Ausgangspunkt für die OpenRecordset<\/b>– oder die Execute<\/b>-Methode verwenden. In diesem Fall greifen wir auf dessen TableDefs<\/b>-Auflistung zu, die den Zugriff auf alle Tabellen der Datenbank erlaubt. Ein TableDef<\/b>-Objekt wiederum enthält unter anderem die Fields<\/b>-Auflistung, die wiederum die Field<\/b>-Objekte und somit die Informationen über die Felder der entsprechenden Tabelle liefert. Außerdem stellt das TableDef<\/b>-Objekt die Indexes<\/b>-Auflistung bereit, mit der wir die Indizes der angegebenen Tabelle auslesen können.<\/p>\n Etwas weiter oben stellt das Database<\/b>-Objekt neben der TableDefs<\/b>-Auflistung auch noch die Relations<\/b>-Auflistung bereit. Diese wiederum enthält die Relation<\/b>-Objekte mit allen Informationen zu den im Beziehungen-Fenster angelegten Beziehungen.<\/p>\n Tabellendefinition auslesen<\/b><\/p>\n Den Start macht die Funktion GetCreateTableString <\/b>(s. Listing 1). Sie erwartet ein TableDef<\/b>-Objekt mit einem Verweis auf die auszuwertende Tabelle und liefert eine Zeichenkette mit dem SQL-Ausdruck zum Erstellen der entsprechenden Tabelle zurück. Diese Zeichenkette enthält die CREATE TABLE<\/b>-Anweisung mit der Angabe des Namens der zu erstellenden Tabelle, die Feldliste sowie eventuell nötige CONSTRAINT<\/b>-Elemente zur Definition von Fremdschlüsselfeldern.<\/p>\n Listing 1: Zusammenstellen der SQL-Anweisung zum Erstellen einer Tabelle<\/p>\n Um einen solchen Ausdruck zu erstellen, verwendet die Prozedur eine String<\/b>-Variable namens strSQL<\/b>, die nach und nach erweitert wird. Gleich zu Beginn schreibt die Prozedur den Ausdruck CREATE TABLE <\/b>gefolgt von dem im Parameter angegebenen Tabellennamen und einer öffnenden Klammer in diese Variable. Die öffnende Klammer gibt den Startschuss für die folgende Feldliste ab. Diese stellt die Prozedur innerhalb einer For Each<\/b>-Schleife zusammen, die alle Field<\/b>-Elemente des TableDef<\/b>-Objekts auf Basis der gewünschten Tabelle durchläuft. Darin bedienen wir uns einer Hilfsvariablen namens strSQLField<\/b>, welche die Feldliste aufnimmt. Zu jedem Element der Feldliste gehört der Name der Tabelle, der vorsichtshalber in eckigen Klammern eingefasst wird – auf diese Weise verhindern wir, dass Feldnamen mit Sonderzeichen zu Fehlern beim Ausführen der SQL-Anweisungen führen. Hinter dem Feldnamen folgt der Datentyp. Diesen ermittelt eine separate Funktion namens GetFieldType <\/b>(s. Listing 2) – mehr dazu im Anschluss an die Beschreibung der aktuellen Funktion. Vorerst reicht uns die Information, dass GetFieldType <\/b>beispielsweise für ein Währungsfeld den Ausdruck MONEY <\/b>zurückliefert.<\/p>\n Listing 2: Diese Funktion liefert eine SQL-kompatible Zeichenkette für den Datentyp eines Felds zurück.<\/p>\n <\/p>\n Mit dem Feldnamen und dem Datentyp stellt unsere For Each<\/b>-Schleife also Ausdrücke der Form <\/p>\n zusammen. Um das angehängte Komma kümmert sich die Prozedur später.<\/p>\n Der folgende Block enthält eine weitere For Each<\/b>-Schleife, welche diesmal alle Index<\/b>-Elemente der aktuellen Tabelle durchläuft. Das Index<\/b>-Element enthält eine Reihe verschiedener Eigenschaften, welche die Art des Indexes festlegen: Foreign<\/b>, IgnoreNulls<\/b>, Primary<\/b>, Required <\/b>und Unique<\/b>. Die Funktion GetCreateTableString <\/b>kümmert sich nur um die Foreign<\/b>-Indizes – alle übrigen werden in einer separaten Funktion behandelt.<\/p>\n Hat die Foreign<\/b>-Eigenschaft eines Index<\/b>-Elements den Wert True<\/b>, handelt es sich um einen Fremdschlüsselindex, für den es eine Beziehung zu einer anderen Tabelle gibt. Die Beziehungen einer Datenbank werden über die Relations<\/b>-Auflistung des Database<\/b>-Objekts verfügbar gemacht. Wenn die Funktion GetCreateTableString <\/b>eine Tabelle mit einem Foreign<\/b>-Index entdeckt, durchsucht sie die Relations<\/b>-Auflistung nach einem Relation<\/b>-Element, dessen Eigenschaft ForeignTable <\/b>den Namen der aktuellen Tabelle enthält und deren Feld mit dem Feld des aktuellen Indexes übereinstimmt. Hat sie ein passendes Relation<\/b>-Element gefunden, stellen die folgenden Zeilen zum Beispiel diesen Ausdruck zusammen:<\/p>\n Ob der Ausdruck ON UPDATE CASCADE <\/b>(Aktualisierungsweitergabe) oder ON DELETE CASCADE <\/b>(Löschweitergabe) eingefügt wird, hängt davon ab, ob der Benutzer die entsprechenden Eigenschaften im Dialog Beziehungen bearbeiten <\/b>eingestellt hat. Dies ist zum Beispiel in Bild 2 der Fall.<\/p>\n Bild 2: Beziehungseigenschaften mit Lösch- und Aktualisierungsweitergabe<\/span><\/b><\/p>\n Aus den Eigenschaften des Relation<\/b>-Objekts bekommt man dies nur über Umwege heraus. Die benötigten Informationen stecken in der Eigenschaft Attributes<\/b>, die – wie die Pluralform schon andeutet – die Werte mehrerer Eigenschaften speichern kann. Bei diesen Eigenschaften kann es sich freilich nur um Boolean<\/b>-Eigenschaften auf Bit-Ebene handeln: Ob eine Eigenschaft den Wert True <\/b>oder False <\/b>aufweist, hängt nämlich davon ab, ob ein die Eigenschaft repräsentierender Zahlenwert im Bit-Wert der Eigenschaft Attributes <\/b>enthalten ist. Haben alle Eigenschaften den Wert False<\/b>, ist Attributes <\/b>gleich 0<\/b>. Hat eine der Eigenschaften den Wert True<\/b>, wird ein entsprechender Zahlenwert zum bestehenden Eigenschaftswert von Attributes <\/b>hinzuaddiert. Wie kommt man aber nun an diese Zahlenwerte Hier hilft ein Blick in den Objektkatalog weiter (siehe Bild 3). Wenn Sie hier auf eine der db…<\/b>-Konstanten klicken, finden Sie im unteren Bereich den entsprechenden Zahlenwert.<\/p>\n Bild 3: Der Objektkatalog liefert die möglichen Eigenschaftswerte für die Eigenschaft Attributes des Relation-Objekts.<\/span><\/b><\/p>\n Damit man aus mehreren addierten Zahlenwerten ablesen kann, ob der Zahlenwert für eine bestimmte Eigenschaft enthalten ist, müssen die Zahlenwerte Zweierpotenzen sein (also 0<\/b>, 1<\/b>, 2<\/b>, 4<\/b>, 8 <\/b>und so weiter). In diesem Fall entspricht dbRelationDeleteCascade <\/b>dem Wert 4096 <\/b>und dbRelationUpdateCascade <\/b>dem Wert 256<\/b>. Unabhängig von den übrigen möglichen Eigenschaftswerten enthält Attributes <\/b>nun den Wert 4096<\/b>, wenn Löschweitergabe aktiviert ist, den Wert 256<\/b>, wenn nur Aktualisierungsweitergabe aktiviert ist, und die Summe aus beiden, also 4352<\/b>, wenn der Benutzer beide Optionen im Dialog Beziehungen bearbeiten <\/b>aktiviert hat. Im Code können wir mit dem And<\/b>-Operator ganz einfach prüfen, ob eine der interessierenden Eigenschaften gesetzt ist. Der folgende Ausdruck liefert beispielsweise True <\/b>zurück, wenn dbRelationDeleteCascade <\/b>gesetzt ist:<\/p>\n Wie dies technisch funktioniert, lesen Sie im Beitrag Rund um Binärzahlen <\/b>(Shortlink 556). Nach dem Zusammensetzen der Feldliste und der Foreign-Constraints<\/b>-Liste entfernt die Funktion noch das Komma hinter dem letzten Element, schließt die Klammer und gibt den resultierenden Ausdruck als Funktionswert zurück.<\/p>\n Datentypen ermitteln<\/b><\/p>\n Kommen wir zur Funktion GetFieldType <\/b>aus Listing 2 zurück. Diese soll einen Ausdruck ermitteln, der auf Basis der Type<\/b>-Eigenschaft des Field<\/b>-Objekts einen SQL-kompatiblen Datentyp zurückliefert. <\/p>\n Listing 3: Diese Funktion liefert je Index eine eigene CREATE INDEX-Anweisung.<\/p>\n Die Type<\/b>-Eigenschaft liefert uns aber erstmal nur Zahlenwerte. Wie sollen wir von denen auf den benötigten SQL-Datentyp schließen Hier hilft wiederum der Objektkatalog weiter: Er liefert mit der Enumeration DataTypeEnum <\/b>eine Liste aller möglichen DAO<\/b>-Datentypen (siehe Bild 4). Diese müssen wir nun noch mit den unter SQL verwendeten Datentypen abgleichen, wobei die VBA-Online-Hilfe hilfreich ist – unter Access 2007 kommt man hier etwa mit den Schlüsselwörtern SQL <\/b>und Datentypen <\/b>zu einer Übersicht der SQL-Datentypen.<\/p>\n Bild 4: Auch für die Datentypen liefert der Objektkatalog die entsprechenden Konstanten.<\/span><\/b><\/p>\n Das Ergebnis dieser Recherche finden Sie in angereicherter Form eben in der Funktion GetFieldType<\/b>. Diese liefert im einfachen Fall einfach das zum Type<\/b>-Wert passende SQL-Schlüsselwort zurück. In manchen Fällen brauchen wir weitere Informationen:<\/p>\n Indizes definieren<\/p>\n Nachdem die Funktion GetCreateTableString <\/b>den eigentlichen Tabellenaufbau inklusive Beziehungen liefert, ist die Funktion GetCreateIndexString <\/b>(s. Listing 3) für die übrigen Indizes verantwortlich. Die Funktion wird für jedes Index<\/b>-Element der Indexes<\/b>-Auflistung eines TableDef<\/b>-Objekts einmal aufgerufen und erwartet das zu untersuchende TableDef<\/b>– und Index<\/b>-Element als Parameter.<\/p>\n Auch diese Funktion beginnt das Zusammensetzen des gefragten Ausdrucks mit dem CREATE<\/b>-Schlüsselwort. Dann fügt sie, wenn es sich bei dem Index um einen eindeutigen Index handelt, das UNIQUE<\/b>-Schlüsselwort an – in jedem Falle gefolgt von INDEX<\/b>.<\/p>\n Für den Namen des Index<\/b>-Elements ergibt sich eine Besonderheit: Offensichtlich bietet SQL nicht die Möglichkeit, einen Primärschlüssel- oder eindeutigen Index gleichzeitig als Fremdschlüssel einzurichten (dies geschieht nicht besonders oft, kann aber vorkommen, wenn man 1:1-Beziehungen einrichtet). Interessanterweise besitzt Access aber intern wohl die Möglichkeit, unter dem gleichen Namen Indizes mit Primär- und Fremdschlüsseleigenschaften gleichzeitig einzurichten. Die vorliegende Lösung erzeugt daraus zunächst einen FOREIGN KEY<\/b>-Constraint und anschließend in der Funktion GetCreateIndexString <\/b>einen gegebenenfalls als UNIQUE <\/b>gekennzeichneten PRIMARY<\/b>-Constraint. Dieser sollte eigentlich den gleichen Namen wie der FOREIGN KEY<\/b>-Index haben. Das Anlegen von Indizes mit bereits vergebenen Namen löst allerdings einen Fehler aus, sodass wir dem Namen des betroffenen Indexes eine GUID zur Alleinstellung voranstellen.<\/p>\n Weiter im Code: Das Schlüsselwort ON <\/b>und der Name der Tabelle ergänzen die CREATE INDEX<\/b>-Anweisung. Anschließend folgt in Klammern die Feldliste. Schließlich liest die Funktion anhand der Eigenschaften Primary<\/b>, Required <\/b>und IgnoreNulls <\/b>die Eigenschaften des Indexes aus und fügt entsprechende SQL-Schlüsselwörter an den Ausdruck an. Diese entsprechen genau den drei Eigenschaften, die Sie im Indizes<\/b>-Dialog beim Entwurf einer Tabelle angeben können (siehe Bild 5).<\/p>\n Bild 5: Eigenschaften eines Indexes im Tabellenentwurf<\/span><\/b><\/p>\n Einfacher Aufruf<\/b><\/p>\n Die Funktion CreateTableString <\/b>rundet die bislang vorgestellten Funktionen ab (s. Listing 4). Sie erwartet lediglich den Namen der Tabelle, die Sie per SQL-Anweisung reproduzieren möchten, und gibt die benötigten SQL-Ausdrücke zurück. Dazu ruft sie die bisher vorgestellten Funktionen mit den entsprechenden Parametern auf. Das Formular frmDDL<\/b>, das wir ganz zu Beginn in Bild 1 vorgestellt haben, macht sich diese Funktion zunutze, indem sie diese nach der Auswahl einer der Tabellen im Kombinationsfeld aufruft und den resultierenden Ausdruck anzeigt. Wenn Sie die Lösung in eigenen Datenbanken einsetzen möchten, brauchen Sie lediglich das Formular frmDDL<\/b> und die Module mdlSQLDump <\/b>und mdlGUIDs <\/b>in die Datenbank zu importieren und das Formular zu starten.<\/p>\n Listing 4: Diese Funktion erwartet lediglich die Angabe des Tabellennamens und liefert die zum Erstellen dieser Tabelle nötigen SQL-Anweisungen zurück.<\/p>\n Vorgehensweise beim Ausführen der SQL-Anweisungen<\/b><\/p>\nCREATE TABLE tblAnreden([AnredeID] COUNTER, [Anrede] CHAR(255));\r\nCREATE UNIQUE INDEX [PrimaryKey] ON [tblAnreden]([AnredeID]) WITH PRIMARY DISALLOW NULL;<\/pre>\n
CREATE TABLE tblAnreden([AnredeID] COUNTER CONSTRAINT PrimaryKey PRIMARY KEY, [Anrede] CHAR(255));<\/pre>\n
Public Function GetCreateTableString(tdf As DAO.TableDef) As String\r\n Dim db As DAO.Database\r\n Dim fld As DAO.Field\r\n Dim idx As DAO.Index\r\n Dim rel As DAO.Relation\r\n Dim strTable As String\r\n Dim strSQL As String\r\n Dim strSQLField As String\r\n Dim strFieldType As String\r\n Dim strConstraints As String\r\n Set db = CurrentDb\r\n strTable = tdf.Name\r\n strSQL = "CREATE TABLE " & strTable & "("\r\n For Each fld In tdf.Fields\r\n strSQLField = strSQLField & "[" & fld.Name & "]"\r\n strFieldType = GetFieldType(fld)\r\n strSQLField = strSQLField & " " & strFieldType & ", "\r\n Next fld\r\n strSQL = strSQL & strSQLField\r\n For Each idx In tdf.Indexes\r\n If idx.Foreign Then\r\n For Each rel In db.Relations\r\n If rel.ForeignTable = tdf.Name And idx.Fields(0).Name = rel.Fields(0).Name Then\r\n strConstraints = strConstraints & "CONSTRAINT "\r\n strConstraints = strConstraints & "[" & idx.Name & "] FOREIGN KEY ("\r\n strConstraints = strConstraints & "[" & rel.Fields(0).Name & "]"\r\n strConstraints = strConstraints & ") REFERENCES ["\r\n strConstraints = strConstraints & rel.Table & "]"\r\n If (rel.Attributes And dbRelationUpdateCascade) = dbRelationUpdateCascade Then\r\n strConstraints = strConstraints & " ON UPDATE CASCADE"\r\n End If\r\n If (rel.Attributes And dbRelationDeleteCascade) = dbRelationDeleteCascade Then\r\n strConstraints = strConstraints & " ON DELETE CASCADE"\r\n End If\r\n strConstraints = strConstraints & ", "\r\n End If\r\n Next rel\r\n End If\r\n Next idx\r\n strSQL = strSQL & strConstraints\r\n If Right(Trim(strSQL), 1) = "," Then\r\n strSQL = Left(strSQL, Len(Trim(strSQL)) - 1)\r\n End If\r\n strSQL = strSQL & ");"\r\n GetCreateTableString = strSQL\r\nEnd Function<\/pre>\nPublic Function GetFieldType(fld As DAO.Field) As String\r\nDim strFieldType As String\r\nSelect Case fld.Type\r\nCase dbLong\r\nIf (fld.Attributes And dbAutoIncrField) = 0 Then\r\n strFieldType = "INTEGER"\r\nElse\r\n strFieldType = "COUNTER"\r\nEnd If\r\nCase dbText\r\nstrFieldType = "TEXT"\r\nstrFieldType = strFieldType & "(" & fld.Size & ")"\r\nCase dbCurrency\r\nstrFieldType = "MONEY"\r\nCase dbInteger\r\nstrFieldType = "SMALLINT"\r\nCase dbBoolean\r\nstrFieldType = "BIT"\r\nCase dbSingle\r\nstrFieldType = "REAL"\r\nCase dbDate\r\nstrFieldType = "DATETIME"\r\nCase dbLongBinary\r\nstrFieldType = "IMAGE"\r\nCase dbMemo\r\nstrFieldType = "LONGTEXT"\r\nCase dbByte\r\nstrFieldType = "BYTE"\r\nCase dbSingle\r\nstrFieldType = "SINGLE"\r\nCase dbDouble\r\nstrFieldType = "DOUBLE"\r\nCase dbBinary\r\nstrFieldType = "BINARY"\r\nCase dbLongBinary\r\nstrFieldType = "OLE OBJECT"\r\nCase dbGUID\r\nstrFieldType = "GUID"\r\nCase Else\r\nstrFieldType = fld.Type\r\nStop\r\nDebug.Print fld.Type\r\nEnd Select\r\nGetFieldType = strFieldType\r\nEnd Function<\/pre>\n[AnredeID] COUNTER, [Anrede] CHAR(255),<\/pre>\n
CONSTRAINT [tblKategorientblArtikel] FOREIGN KEY ([KategorieID]) REFERENCES [tblKategorien] ON UPDATE CASCADE ON DELETE CASCADE,<\/pre>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Datenbankschema-web-images\/pic001_opt.jpeg\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Datenbankschema-web-images\/pic002_opt.jpeg\")
<\/p>\n(rel.Attributes And dbRelationUpdateCascade) = dbRelationUpdateCascade<\/pre>\n
Public Function GetCreateIndexString(tdf As DAO.TableDef, _\r\n idx As DAO.Index) As String\r\n Dim fld As DAO.Field\r\n Dim strIndex As String\r\n Dim strFields As String\r\n Dim strWith As String\r\n Dim strGUID As String\r\n strIndex = strIndex & "CREATE "\r\n If idx.Unique Then\r\n strIndex = strIndex & "UNIQUE "\r\n End If\r\n strIndex = strIndex & "INDEX "\r\n If idx.Foreign Then\r\n strGUID = CreateGUID\r\n End If\r\n strIndex = strIndex & "[" & strGUID & idx.Name & "]"\r\n strIndex = strIndex & " ON "\r\n strIndex = strIndex & "[" & tdf.Name & "]"\r\n strFields = ""\r\n For Each fld In idx.Fields\r\n strFields = strFields & "[" & fld.Name & "], "\r\n Next fld\r\n strFields = Left(strFields, Len(strFields) - 2)\r\n strIndex = strIndex & "("\r\n strIndex = strIndex & strFields\r\n strIndex = strIndex & ")"\r\n strWith = ""\r\n If idx.Primary Then\r\n strWith = strWith & "PRIMARY "\r\n End If\r\n If idx.Required Then\r\n strWith = strWith & "DISALLOW NULL "\r\n End If\r\n If idx.IgnoreNulls Then\r\n strWith = strWith & "IGNORE NULL "\r\n End If\r\n If Len(strWith) > 0 Then\r\n strIndex = strIndex & " WITH " & Trim(strWith)\r\n End If\r\n strIndex = strIndex & ";"\r\n GetCreateIndexString = strIndex\r\nEnd Function<\/pre>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Datenbankschema-web-images\/pic003_opt.jpeg\")
<\/p>\n\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Datenbankschema-web-images\/pic004_opt.jpeg\")
<\/p>\nPublic Function CreateTableString(strTable As String) As String\r\nDim db As DAO.Database\r\nDim idx As DAO.Index\r\nDim tdf As DAO.TableDef\r\nDim strSQL As String\r\nDim strIndex As String\r\nSet db = CurrentDb\r\nSet tdf = db.TableDefs(strTable)\r\nstrSQL = GetCreateTableString(tdf)\r\nFor Each idx In tdf.Indexes\r\n strIndex = strIndex & GetCreateIndexString(tdf, idx) & vbCrLf\r\nNext idx\r\nCreateTableString = strSQL & vbCrLf & strIndex\r\nEnd Function<\/pre>\n