<\/p>\n
Im Beitrag RDBMS-Tabellen manuell verknüpfen haben Sie erfahren, wie Sie die Tabellen eines relationalen Datenbankmanagementsystems wie Microsoft SQL Server oder MySQL mit den Bordmitteln von Access verknüpfen. Im vorliegenden Beitrag schauen wir uns an, wie Sie dies per VBA erledigen können. Dabei lernen Sie auch die verschiedenen Verbindungszeichenfolgen kennen.<\/b><\/p>\n
Wenn Sie eine Tabelle etwa vom SQL Server oder MySQL (stellvertretend für die vielen relationalen Datenbankmanagement-Systeme, die eine ODBC-Schnittstelle anbieten) verknüpfen, befinden sich ja nicht die Daten selbst in der Access-Datenbank, sondern nur die Verknüpfungen zu den Daten in den zugrunde liegenden Tabellen.<\/p>\n
Wo aber speichert Access die Informationen darüber, wo sich diese Tabellen befinden Ein Teil dieser Informationen landet, wenn Sie die Verknüpfung über eine DSN (Data Source Name) erstellt haben, in der Registry (System-datenquelle oder Benutzerdatenquelle) oder in einer Textdatei (Dateidatenquelle).<\/p>\n
Wir schauen uns dies anhand einiger Beispiele für den Zugriff auf eine MySQL-Datenbank an. Dazu legen wir, wie im Beitrag SQL-Server-Tabellen manuell verknüpfen beschrieben, drei Verknüpfungen zu einer Tabelle einer MySQL-Datenbank an – jeweils eine mit einer Dateidatenquelle, einer Benutzerdatenquelle und einer Systemdatenquelle. Wo wir die zugrunde liegenden Informationen dieser DSN finden, wissen wir – entweder in der Registry oder ein einer .dsn<\/b>-Datei.<\/p>\n
Die Systemtabelle MSysObjects<\/b><\/p>\n
Aber woher weiß Access, woher es die Informationen über die Verknüpfungen nehmen soll Diese Daten finden wir in der Systemtabelle MSysObjects<\/b>. Um diese Tabelle, die standardmäßig nicht sichtbar ist, zu öffnen, geben Sie im VBA-Editor den folgenden Befehl ein:<\/p>\n Den Inhalt dieser Tabelle nach dem Anlegen dreier Verknüpfungen wie oben beschrieben finden Sie wie in Bild 1 vor. Interessant sind hier vier Felder: Das Feld Type <\/b>enthält den Objekttyp. Der Wert 4 <\/b>steht für per ODBC eingebundene Tabellen.<\/p>\n Bild 1: Verknüpfungseigenschaften in der Systemtabelle MSysObjects<\/span><\/b><\/p>\n ForeignName <\/b>enthält den Namen der Tabelle in der Quelldatenbank, Name<\/b> den Namen der Tabelle in der aktuellen Access-Datenbank. Connect <\/b>liefert schließlich die Verbindungszeichenfolge. Und hier wird es interessant: Die per Dateidatenquelle eingebundene Tabelle referenziert im Gegensatz zu den beiden per System- oder Benutzerdatenquelle eingebundenen Tabellen gar keine externen Informationen.<\/p>\n Das bedeutet also, dass eine Dateidatenquelle nur zum Erstellen der Verknüpfung verwendet wird, danach nicht mehr. Die System- oder Benutzerdatenquelle hingegen wird wohl zumindest beim ersten Zugriff auf die verknüpfte Tabelle innerhalb einer Sitzung abgefragt.<\/p>\n Sinn der DSN<\/b><\/p>\n An dieser Stelle stellt sich die Frage nach dem Sinn einer DSN. Tatsächlich hängt es vom Anwendungsfall ab. Wenn die DSN nur von einer einzigen Datenbank verwendet wird, spielt es keine Rolle, ob Sie die Verknüpfungseigenschaften in der Datenbank speichern oder in eine DSN auslagern.<\/p>\n Sollten hingegen gleich mehrere Anwendungen auf die DSN zugreifen, hat eine System- oder Benutzerdatenquelle durchaus ihren Nutzen: Sie brauchen dann, wenn sich etwa der Servername der Datenquelle einmal ändert, nur die DSN anzupassen. Wenn Sie hingegen mehrere Datenbanken nutzen, die alle individuell mit der gleichen Datenquelle verknüpft sind, ohne eine System- oder Benutzerdatenquelle zu nutzen, müssen Sie die Verknüpfungsinformationen in allen betroffenen Datenbanken anpassen.<\/p>\n Wenn Sie die Verknüpfungseigenschaften allein in der Frontend-Datenbank speichern, haben Sie sogar den Vorteil, dass Sie diese Datenbank einfach verteilen können, ohne noch eine Benutzer- oder Systemdatenquelle hinzufügen zu müssen.<\/p>\n Verbindungszeichenfolge<\/b><\/p>\n Damit kommen wir nun dazu, uns den Umweg über die Assistenten zum Erstellen von Verknüpfungen zu ODBC-Datenquellen zu sparen und die Verknüpfung selbst zu erstellen. Dazu schauen wir uns zunächst an, wie solch eine Verbindungszeichenfolge überhaupt aufgebaut ist.<\/p>\n Kennzeichnung als ODBC-Verknüpfung<\/b><\/p>\n Diese beginnen immer mit dem Schlüsselwort ODBC<\/b>, gefolgt von einem Semikolon (;<\/b>). Dieses wird jedoch in der Eigenschaft Connect <\/b>der verknüpften Tabellen in der Tabelle MSysObjects <\/b>gar nicht aufgeführt. Der Grund ist: In der Spalte Connect <\/b>landen ausschließlich Verbindungszeichenfolgen für ODBC-Datenquellen, daher wird das ODBC; <\/b>hier weggelassen. Dass es dennoch nötig ist, zeigt ein Blick in die Eigenschaften des Entwurfs einer der betroffenen Tabellen (s. Bild 2).<\/p>\n Bild 2: Verknüpfungseigenschaften in den Eigenschaften des Tabellenentwurfs<\/span><\/b><\/p>\n Treiber festlegen<\/b><\/p>\n Neben dem einführenden ODBC; <\/b>erwartet eine Verbindungszeichenfolge die Angabe des Treibers für die zu verwendende ODBC-Schnittstelle. Diese werden unter DRIVER <\/b>angegeben. Für den SQL Server verwenden Sie beispielsweise die folgenden Werte – zunächst für den allgemeinen Treiber:<\/p>\n Für eine bestimmte Version des SQL Servers verwenden Sie diesen Treiber:<\/p>\n Das x<\/b> steht dabei für die Version des SQL Servers:<\/p>\n Für die aktuellen Versionen von MySQL verwenden Sie beispielsweise die folgenden Treiber-Ausdrücke – hier für die Version 5.2 <\/b>(für Version 5.3 <\/b>einfach 2 <\/b>durch 3 <\/b>ersetzen):<\/p>\n Diese ersetzen die zuvor verwendeten folgenden Ausdrücke für die Version 5.1 (a <\/b>für ANSI, w <\/b>für Unicode):<\/p>\n Festlegen des Servers<\/b><\/p>\n Mit dem Parameter SERVER <\/b>geben Sie die Adresse des Servers an. Bei Verwendung von SQL Server können Sie beim Zugriff auf die Standardinstanz auf dem gleichen Rechner den Wert localhost<\/b>, den Punkt (.<\/b>) oder den Rechnernamen angeben – also beispielsweise so:<\/p>\n Wenn Sie auf die Standardinstanz von SQL Server auf einem anderen Rechner zugreifen wollen, geben Sie einfach dessen Rechnernamen als Wert an:<\/p>\n Bei SQL Server gibt es benannte Instanzen. Auf diese greifen Sie zu, indem Sie diese per Backslash (\\<\/b>) vom Ausdruck für den Rechner getrennt angeben:<\/p>\n Bei Verwendung von SQL Server Express Edition geben Sie explizit SQLEXPRESS <\/b>als Instanzname an, zum Beispiel so:<\/p>\n Bei MySQL geben Sie beispielsweise localhost<\/b> an, wenn sich MySQL auf dem gleichen Rechner befindet:<\/p>\n Wenn es sich bei dem Rechner mit der MySQL-Installation etwa um einen Internetserver handelt, auf den Sie von außen zugreifen wollen, geben Sie die IP des Servers an:<\/p>\n Angeben der Datenbank<\/b><\/p>\n Die Datenbank legen Sie mit dem Parameter DATABASE <\/b>fest. Diesem übergeben Sie schlicht und einfach den Datenbanknamen:<\/p>\n Authentifizierungsmethode und -daten<\/b><\/p>\n Die Authentifizierungsmethode geben Sie nur beim SQL Server an. Dieser bietet ja die Möglichkeit, mit Windows-Authentifizierung zu arbeiten, also die Windows-Benutzerdaten zu verwenden. In diesem Fall stellen Sie den Parameter Trusted_Connection <\/b>auf den Wert True <\/b>ein:<\/p>\n Verwenden Sie unter SQL Server die SQL Server-Authentifizierung, also mit separaten Benutzerkonten für den SQL Server, geben Sie Benutzername und Kennwort mit den Parametern UID und PWD an:<\/p>\n Dies gilt in dieser Form auch für MySQL.<\/p>\n Verknüpfung per VBA anlegen<\/b><\/p>\n <\/p>\n Damit haben wir nun alle Informationen zusammen, um eine Verknüpfung per VBA zu erstellen.<\/p>\n Dies erledigen wir zunächst in einer einfachen VBA-Prozedur unter hartkodierter Eingabe der Parameter (s. Listing 1) – und zwar für eine Verknüpfung zu einer Tabelle einer MySQL-Datenbank.<\/p>\n Listing 1: Erstellen einer Verknüpfung per VBA<\/span><\/b><\/p>\n Die Prozedur Verknuepfung-Er-stel-len <\/b>stellt zunächst die Verbindungszeichenfolge in der Variablen strConnection <\/b>zusammen. Diese sieht zusammengefasst so aus:<\/p>\n Anschließend füllt die Prozedur die Variable db<\/b> mit der Funktion CurrentDb <\/b>mit einem Verweis auf die aktuelle Datenbank, denn schließlich wollen wir dieser die neue Verknüpfung hinzufügen.<\/p>\n Da Sie diese Funktion möglicherweise mehrmals aufrufen, etwa weil diese nicht auf Anhieb funktioniert oder Sie die Verknüpfung aktualisieren wollen, löschen wir die vorliegende Version der Tabelle, die wir s_users_link <\/b>nennen wollen.<\/p>\n Dies geschieht unter temporärer Deaktivierung der Fehlerbehandlung, da das Löschen beim Fehlen der Tabelle sonst einen Fehler auslöst. Dann erstellen wir mit der CreateTableDef<\/b>-Methode ein neues TableDef<\/b>-Objekt, das wir in der Variablen tdf <\/b>speichern. Dabei übergeben wir gleich den Namen für die Verknüpfung als Parameter, hier tblBenutzer<\/b>.<\/p>\n Danach stellen wir zwei Eigenschaften des TableDef<\/b>-Objekts ein.<\/p>\n Connect <\/b>erhält die in strConnection <\/b>gespeicherte Verbindungszeichenfolge als Wert, SourceTableName <\/b>den Namen der Tabelle auf dem Server.<\/p>\n Danach fügen wir das neu erzeugte TableDef<\/b>-Objekt an die Auflistung TableDefs <\/b>des Database<\/b>-Objekts an, aktualisieren mit der RefreshLink<\/b>-Methode des TableDef<\/b>-Objekts die Verknüpfung und aktualisieren schließlich noch mit der Methode RefreshDatabaseWindow <\/b>des Application<\/b>-Objekts die Anzeige im Navigationsbereich.<\/p>\n Verknüpfung mit Parametern<\/b><\/p>\n Die oben vorgestellte Prozedur versehen wir nun noch mit drei Parametern, damit wir diese flexibel einsetzen können (s. Listing 2). Die Prozedur erhält nun die folgenden Parameter:<\/p>\n Listing 2: Erstellen einer Verknüpfung per VBA – Version mit Parametern<\/span><\/b><\/p>\n Der Einsatz dieser Prozedur sieht dann etwa so aus:<\/p>\n Weitere Nutzung der Verknüpfungen<\/b><\/p>\n Nun haben wir zwar eine neue Verknüpfung per VBA erstellt, aber können wir diese nun auch sinnvoll nutzen Dazu schließen wir die Access-Datenbank und öffnen diese erneut. Die Verknüpfung zur Tabelle auf dem Server zeigt nach dem öffnen alle Daten wie gewünscht an.<\/p>\n Schließen wir hingegen die komplette Access-Anwendung, starten diese erneut und öffnen dann die Beispieldatenbank, lässt sich die Tabelle nicht mehr ohne Weiteres anzeigen. Stattdessen erscheint der Dialog aus Bild 3, der die Benutzerdaten für den Zugriff auf die Tabelle abfragt.<\/p>\n Bild 3: Abfrage der Benutzerdaten beim Zugriff auf die Tabelle nach einem Neustart von Access<\/span><\/b><\/p>\n Das heißt also: Access merkt sich die Benutzerdaten durchaus für die Dauer einer Sitzung, also bis zu dem Zeitpunkt, zu dem Sie die Access-Anwendung selbst schließen. Danach müssen Sie die Zugangsdaten neu eingeben.<\/p>\n Aber warum werden die Zugangsdaten nicht gespeichert Ein Blick in die Tabelle MSysObjects<\/b> liefert Gewissheit: Dort finden wir zwar den Namen der Datenbank, den Treiber und den Server vor, aber keine Benutzerdaten (s. Bild 4). Access sorgt also offensichtlich standardmäßig für ein wenig Sicherheit.<\/p>\n Bild 4: Die Benutzerdaten werden nicht in der Tabelle MSysObjects gespeichert.<\/span><\/b><\/p>\n Aber sollte es nicht eine Möglichkeit geben, diese Daten dennoch zu speichern Doch, die gibt es: Dazu müssen Sie die Eigenschaft Attributes <\/b>des TableDef<\/b>-Objekts nach dem Erstellen auf den Wert dbAttachSavePWD <\/b>einstellen.<\/p>\n Wir haben die Prozedur VerknuepfungErstellen <\/b>wie in Listing 3 erweitert, sodass Sie mit einem Boolean<\/b>-Parameter angeben können, ob der Benutzername und das Kennwort mit in der Systemtabelle MSysObjects <\/b>gespeichert werden soll.<\/p>\n Listing 3: Verknüpfung erstellen mit optionaler Speicherung der Benutzerdaten<\/span><\/b><\/p>\n Wenn Sie diese Variante ausprobieren, werden Sie feststellen, dass Sie auch nach dem Beenden und Neustarten von Access auf die Daten der verknüpften Tabelle zugreifen können.<\/p>\n Mit einem Blick in die Tabelle MSysObjects <\/b>stellen Sie außerdem fest, dass dort nun der Benutzername und auch das Kennwort im Klartext gespeichert werden. Diese Vorgehensweise ist also mit Vorsicht zu genießen und beispielsweise nur dann zu nutzen, wenn die Datenbank nur vom entsprechenden Benutzer geöffnet werden kann.<\/p>\n Alle ODBC-Verknüpfungen neu erstellen<\/b><\/p>\n Ausgestattet mit der parametrisierten Version dieser Prozedur können wir nun auch mehrere Tabellen in einem Rutsch hinzufügen. Dies können Sie beispielsweise dazu nutzen, alle vorhandenen Verknüpfungen zu Tabellen mit einer fest vorgegebenen Verbindungszeichenfolge zu erneuern. Die Prozedur würde etwa wie folgt aussehen:<\/p>\n Die Prozedur durchläuft alle TableDef<\/b>-Objekte der aktuellen Datenbank und prüft, ob deren Verbindungszeichenfolge mit dem Wert ODBC; <\/b>beginnt.<\/p>\n In diesem Fall handelt es sich um eine ODBC-Verknüpfung, die neu angelegt werden soll.<\/p>\n Also ruft die Prozedur für alle Tabellen, die diese Bedingung erfüllen, die Routine VerknuepfungErstellen <\/b>auf und übergibt die Verbindungszeichenfolge, den Namen der Verknüpfung in der aktuellen Datenbank, den Namen der Quelltabelle und den Wert für den Parameter zum Speichern der Benutzerdaten.<\/p>\n Dies wäre der Fall, in dem Sie alle Tabellen über die gleiche Verbindungszeichenfolge ansprechen wollen. Es kann jedoch auch geschehen, dass Sie in einer Access-Datenbank Tabellen aus verschiedenen SQL Server- oder MySQL-Datenbanken verwenden.<\/p>\n In diesem Fall wollen Sie vielleicht die der jeweiligen Tabelle zugeordnete Verbindungszeichenfolge für die Neuverknüpfung übergeben. Dies sieht dann so aus:<\/p>\n Tabellen einer SQL-Server-Datenbank einlesen<\/b><\/p>\n Vielleicht möchten Sie auch alle Tabellen einer Datenbank in der aktuellen Access-Datenbank verknüpfen. In diesem Fall benötigen Sie zunächst einmal eine Liste aller Tabellen des jeweiligen Datenbankmanagementsystems.<\/p>\n Dies gelingt erfreulicherweise – wie die zuvor vorgestellten Techniken auch – sowohl mit dem SQL Server als auch mit MySQL. Für andere relationale Datenbankmanagementsysteme müssten Sie dies ausprobieren und gegebenenfalls eine adäquate Methode herausfinden.<\/p>\n Die Prozedur aus Listing 4 gibt alle Tabellen der in der Verbindungszeichenfolge angegebenen Datenbank im Direktfenster aus. Die Prozedur schreibt wieder die Verbindungszeichenfolge in die Variable strConnection<\/b>. Dann erstellt sie ein neues QueryDef<\/b>-Objekt, also eine Abfrage.<\/p>\n Listing 4: Ausgeben aller Tabellen einer Datenbank<\/span><\/b><\/p>\n Da wir der dazu verwendeten CreateQueryDef<\/b>-Methode eine leere Zeichenkette als Name übergeben, wird die Abfrage nur temporär angelegt und erscheint später nicht im Navigationsbereich.<\/p>\n Danach füllt die Prozedur einige Eigenschaften des QueryDef<\/b>-Objekts. Connect <\/b>nimmt die Verbindungszeichenfolge aus strConnection<\/b>. SQL erwartet die auszuführende Abfrage. Diese liefert die Tabellennamen (TABLE_NAME<\/b>) aus einer speziell für diesen Fall vorgesehenen Sicht (INFORMATION_SCHEMA.TABLES<\/b>), und zwar nur für solche Objekte, deren Feld TABLE_TYPE <\/b>den Wert BASE TABLE <\/b>enthält.<\/p>\n Auf Basis dieses QueryDef<\/b>-Objekts erstellt die Prozedur dann ein Recordset, das sie im Anschluss in einer Do While<\/b>-Schleife durchläuft und dabei jeweils den Tabellennamen ausgibt. Statt der Debug.Print<\/b>-Anweisung könnten Sie hier auch den Aufruf der Prozedur VerknuepfungErstellen <\/b>unterbringen.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieser Beitrag hat die Techniken zum Herstellen von Verknüpfungen zu den Tabellen eines relationalen Datenbankmanagementsystems wie etwa SQL Server oder MySQL vorgestellt. Außerdem haben Sie erfahren, wie Sie alle Tabellen einer Datenbank auf einem solchen System ermitteln können. Damit können Sie dann auch beispielsweise alle oder auch nur Tabellen mit bestimmten Eigenschaften automatisiert per VBA verknüpfen. Dies könnte beispielsweise beim öffnen der Datenbank geschehen.<\/p>\n Die hier vorgestellten Techniken lassen sich auch auf Sichten anwenden.<\/p>\n Offen bleibt noch, wie man die Verknüpfungen ohne ständige Neueingabe der Benutzerdaten pflegen kann, ohne die Benutzerdaten im Klartext in der Systemtabelle MSysObjects<\/b> zu speichern. Dazu haben wir uns im Beitrag Sicherer RDBMS-Zugriff <\/b>etwas einfallen lassen (www.access-im-unternehmen.de\/975<\/b>).<\/p>\n Enthaltene Beispieldateien:<\/p>\n mdlVerknuepfungen.bas<\/p>\nDoCmd.OpenTable \"MSysObjects\"<\/pre>\n
![\"Verknüpfungseigenschaften](\"..\/fileadmin\/_temp_\/2015_02\/pic_974_001.png\")
<\/p>\n![\"Verknüpfungseigenschaften](\"..\/fileadmin\/_temp_\/2015_02\/pic_974_002.png\")
<\/p>\nDRIVER={SQL Server};<\/pre>\nDRIVER={SQL Server Native Client x.0};<\/pre>\n\n
DRIVER={MySQL ODBC 5.2 ANSI Driver};\r\nDRIVER={MySQL ODBC 5.2 Unicode Driver};<\/pre>\nDRIVER={MySQL ODBC 5.1a Driver};\r\nDRIVER={MySQL ODBC 5.1w Driver};<\/pre>\nSERVER=localhost;\r\nSERVER=.\r\nSERVER=Rechnername<\/pre>\n
SERVER=Rechnername;<\/pre>\n
SERVER=localhost\\BenannteInstanz\r\nSERVER=.\\BenannteInstanz\r\nSERVER=Rechnername\\BenannteInstanz<\/pre>\n
SERVER=localhost\\SQLEXPRESS\r\nSERVER=Rechnername\\SQLEXPRESS<\/pre>\n
SERVER=localhost<\/pre>\n
SERVER=xxx.xxx.xxx.xxx<\/pre>\n
DATABASE:Datenbankname;<\/pre>\n
TRUSTED_CONNECTION=true;<\/pre>\n
UID=Benutzername;PWD=Kennwort;<\/pre>\n
Public Sub <\/span>VerknuepfungErstellen()\r\n Dim <\/span>strConnection As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n strConnection = strConnection & \"ODBC;\"\r\n strConnection = strConnection & \"DRIVER={MySQL ODBC 5.2 ANSI Driver};\"\r\n strConnection = strConnection & \"SERVER=xxx.xxx.xxx.xxx;\"\r\n strConnection = strConnection & \"DATABASE=MeineDatenbank;\"\r\n strConnection = strConnection & \"UID=MeinBenutzername;\"\r\n strConnection = strConnection & \"PWD=MeinKennwort;\"\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.TableDefs.Delete \"tblBenutzer\"\r\n On Error GoTo<\/span> 0\r\n Set<\/span> tdf = db.CreateTableDef(\"tblBenutzer\")\r\n With<\/span> tdf\r\n .Connect = strConnection\r\n .SourceTableName = \"s_user\"\r\n End With<\/span>\r\n db.TableDefs.Append tdf\r\n tdf.RefreshLink\r\n Application.RefreshDatabaseWindow\r\nEnd Sub<\/span><\/pre>\nODBC;DRIVER={MySQL ODBC 5.2 ANSI Driver};SERVER=xxx.xxx.xxx.xxx;DATABASE=MeineDatenbank;UID=MeinBenutzername;PWD=MeinKennwort;<\/pre>\nPublic Sub <\/span>VerknuepfungErstellen(strConnection As String<\/span>, _\r\n strTableLocal As String<\/span>, strTable As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.TableDefs.Delete strTableLocal\r\n On Error GoTo<\/span> 0\r\n Set<\/span> tdf = db.CreateTableDef(strTableLocal)\r\n With<\/span> tdf\r\n .Connect = strConnection\r\n .SourceTableName = strTable\r\n End With<\/span>\r\n db.TableDefs.Append tdf\r\n tdf.RefreshLink\r\n Application.RefreshDatabaseWindow\r\nEnd Sub<\/span><\/pre>\n\n
Dim <\/span>strConnection As String<\/span>\r\nstrConnection = \"ODBC;DRIVER={MySQL ODBC 5.2 ANSI Driver};SERVER=xxx.xxx.xxx.xxx;DATABASE=MeineDatenbank;UID=MeinBenutzername;PWD=MeinKennwort;\"\r\nVerknuepfungErstellen strConnection, \"tblKunden\", \"s_user\"<\/pre>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2015_02\/pic_974_003.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_02\/pic_974_004.png\")
<\/p>\nPublic Sub <\/span>VerknuepfungErstellen(strConnection As String<\/span>, strTableLocal As String<\/span>, strTable As String<\/span>, _\r\n Optional<\/span> bolBenutzerdatenSpeichern As Boolean<\/span> = False<\/span>)\r\n ...\r\n With<\/span> tdf\r\n ...\r\n If <\/span>bolBenutzerdatenSpeichern Then<\/span>\r\n .Attributes = dbAttachSavePWD\r\n End If<\/span>\r\n End With<\/span>\r\n ...\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AlleVerknuepfungenNeuErstellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strConnection As String<\/span>\r\n strConnection = \"...\"\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>Left<\/span>(tdf.Connect, 5) = \"ODBC;\" Then<\/span>\r\n VerknuepfungErstellen strConnection, _\r\n tdf.Name, tdf.SourceTableName, True<\/span>\r\n End If<\/span>\r\n Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AlleVerknuepfungenNeuErstellenIndividuell()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>Left<\/span>(tdf.Connect, 5) = \"ODBC;\" Then<\/span>\r\n VerknuepfungErstellen tdf.Connect, tdf.Name, _\r\n tdf.SourceTableName, True<\/span>\r\n End If<\/span>\r\n Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AlleTabellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strConnection As String<\/span>\r\n strConnection = strConnection & \"...\"\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.CreateQueryDef(\"\")\r\n With<\/span> qdf\r\n .Connect = strConnection\r\n .SQL = \"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = ''BASE TABLE''\"\r\n .ReturnsRecords = True<\/span>\r\n Set<\/span> rst = qdf.OpenRecordset\r\n End With<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst.Fields(0)\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nDownloads zu diesem Beitrag<\/h3>\n