Wenn Du die Tabellen einer Access-Datenbank mit dem SQL Server Migration Assistant zum SQL Server migriert hast, ist der Großteil einer SQL Server-Migration bereits geschafft. Allerdings stehen noch weitere Arbeiten wie das Anpassen des VBA-Codes, Abfragen, Formularen und Berichten bevor. Eine andere, wichtige Aufgabe ist das Sicherstellen der Funktion der Tabellenverknüpfungen. Diese wurden, wenn die richtige Option im SQL Server Migration Assistant markiert wurde, bereits initial angelegt, während die Original-Tabellen der Access-Datenbank umbenannt wurden. Wie aber stellen wir sicher, dass die Tabellenverknüpfungen auch nach dem Ändern des Tabellenentwurfs im SQL Server aktuell bleiben? Das erläutern wir in diesem Artikel.<\/b><\/p>\n
Beispieldatenbank<\/h2>\n
Im Artikel Access-Datenbank zum SQL Server migrieren <\/b>(www.vbentwickler.de\/484<\/b>) zeigen wir, wie Du eine Access-Datenbank zum SQL Server migrierst. Die dort erstellt SQL Server-Datenbank nutzen wir als Beispielmaterial für die folgenden Abschnitte. Wir gehen zum Start davon aus, dass wie eine leere Access-Datenbank haben, in der wir Tabellenverknüpfungen auf Basis dieser SQL Server-Datenbank erstellen wollen.<\/p>\nWarum Tabellen per VBA verknüpfen?<\/h2>\n
Bevor wir uns ans Werk machen, stellt sich die Frage: Warum sollte ich überhaupt meine Access-Datenbank überhaupt per VBA mit Tabellen aus dem SQL Server verknüpfen?<\/p>\n
Wenn man eine Migration mit dem SQL Server Management Studio durchführe, werden ja bereits automatisch Tabellenverknüpfung hinzugefügt, und außerdem gibt es doch in Access ausreichend Möglichkeiten, Tabellen über die Benutzeroberfläche zu verknüpfen. Dazu gehört beispielsweise der Assistent, den wir über den Ribbon-Eintrag Externe Daten|Aus Datenbank|Aus SQL Server <\/b>öffnen (siehe Bild 1).<\/p>\n
![\"Öffnen](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_001.png\")
<\/p>\n
Bild 1: Öffnen des Assistenten zum Verknüpfen oder Importieren von SQL Server-Tabellen<\/span><\/b><\/p>\n Alternativ können wir auch den Befehl Externe Daten|Neue Datenquelle|Aus anderen Quellen|ODBC-Datenbank <\/b>nutzen (siehe Bild 2).<\/p>\n Bild 2: Öffnen des Assistenten für ODBC-Datenbanken<\/span><\/b><\/p>\n Beide führen dazu, dass wir eine Datenquelle erstellen, die auf einem Treiber besteht – der in beiden Fällen optimalerweise der aktuelle ODBC-Treiber für die Verbindung mit Microsoft SQL Server ist.<\/p>\n In beiden Fällen können wir Tabellenverknüpfungen erstellen, die funktionieren und die je nach den Einstellungen, die wir dort vornehmen, zum Beispiel wie folgt aussehen:<\/p>\n Wenn die Tabellen einmal verknüpft sind, können wir diese sogar über die Benutzeroberfläche verwalten.<\/p>\n Dazu bietet sich zunächst der Tabellenverknüpfungs-Manager <\/b>an, den wir über den Ribbon-Eintrag aus Bild 3 öffnen.<\/p>\n Bild 3: Öffnen des Tabellenverknüpfungs-Managers<\/span><\/b><\/p>\n Der Tabellenverknüpfungs-Manager erscheint anschließend wie in Bild 4.<\/p>\n Bild 4: Der Tabellenverknüpfungs-Managers<\/span><\/b><\/p>\n Hier sehen wir für jede Datenquelle einen Haupteintrag, den wir öffnen können. Danach erscheinen alle Tabellen, die aus dieser Datenquelle stammen.<\/p>\n Wir können alle Tabellen markieren, indem wir einen Haken für den Haupteintrag setzen, oder auch einzelne Einträge markieren.<\/p>\n Dies aktiviert die beiden Schaltflächen Aktualisieren <\/b>und Verknüpfung erneuern<\/b>. Wenn wir auf Aktualisieren <\/b>klicken, wird die Verknüpfung aktualisiert, wobei alle Änderungen, die wir zwischenzeitlich an der markierten Tabelle im SQL Server vorgenommen haben, an die Tabellenverknüpfung übertragen werden.<\/p>\n Wenn wir also beispielsweise ein neues Feld zur Tabelle tblAbteilungen <\/b>hinzufügen und diesen Befehl betätigen, sehen wir beim nächsten Öffnen der Tabellenverknüpfung in Access das neue Feld.<\/p>\n Ähnlich funktioniert die Schaltfläche Verknüpfung erneuern<\/b>. Wenn wir nur eine Tabelle neu verknüpfen wollen, erscheint der Dialog aus Bild 5, mit dem wir die bereits verknüpfte Tabelle übernehmen oder einen neuen Namen eingeben können.<\/p>\n Bild 5: Neuverknüpfung einer Tabelle<\/span><\/b><\/p>\n Wenn wir jedoch die gesamte Datenquelle markieren, erscheint der Dialog aus Bild 6. Damit können wir also auch die Verbindungszeichenfolge bearbeiten. Danach wird der Dialog zum Verknüpfen einer Tabelle für alle Tabellenverknüpfungen dieser Datenquelle jeweils einmal angezeigt.<\/p>\n Bild 6: Neuverknüpfung einer Datenquelle<\/span><\/b><\/p>\n Die Funktion zum Aktualisieren einer Tabellenverknüpfung können wir auch schneller aufrufen. Dazu klicken wir mit der rechten Maustaste auf die Tabellenverknüpfung im Navigationsbereich und wählen dort den Befehl Link aktualisieren <\/b>aus (siehe Bild 7).<\/p>\n Bild 7: Aktualisieren einer Datenquelle<\/span><\/b><\/p>\n Direkt darüber sehen wir noch eine weitere Möglichkeit, den Tabellenverknüpfungs-Manager zu öffnen.<\/p>\n Außerdem können wir eine Tabellenverknüpfung über das Kontextmenü in eine lokale Tabelle konvertieren.<\/p>\n Das ist hilfreich, wenn man zum Beispiel eine Datenbank an einen anderen Entwickler übergeben möchte, wenn dieser Arbeiten an der Datenbank durchführen soll, man aber nicht die SQL Server-Datenbank mitliefern möchte.<\/p>\n Wenn es solche Möglichkeiten gibt, warum sollten wir dann also das Aktualisieren oder Erneuern der Tabellenverknüpfungen per VBA programmieren?<\/p>\n Dazu gibt es verschiedene Gründe:<\/p>\n Deshalb ist es sinnvoll, einige VBA-Routinen vorzubereiten, mit denen wir die Tabellenverknüpfungen jederzeit per Mausklick entweder aktualisieren oder erneuern können.<\/p>\n Wenn wir dann zum Beispiel auf dem Entwicklungssystem den Server wechseln, brauchen wir einfach nur eine andere Verbindungszeichenkette zu irgendwo in der Datenbank zu speichern, die dann auf dem Zielrechner zum Herstellen der Tabellenverknüpfungen verwendet wird.<\/p>\n Wenn wir die Tabellenverknüpfungen über die Benutzeroberfläche aktualisieren wollen, gibt es einen Unterschied bezüglich der beiden Authentifizierungsmethoden Windows-Authentifizierung und SQL Server-Authentifizierung.<\/p>\n Bei der Windows-Authentifizierung wird bekanntlich das Windows-Konto des aktuellen Benutzers im SQL Server überprüft.<\/p>\n Ist dieses bekannt und die entsprechende Anmeldung im SQL Server hat Berechtigungen für den Zugriff auf die entsprechenden Tabellen, erfolgt die Aktualisierung ohne weitere Interventionen des SQL Servers.<\/p>\n Wenn wir jedoch die SQL Server-Authentifizierung verwendet wird, prüft der SQL Server, ob Benutzername und Kennwort der jeweiligen SQL Server-Anmeldungen vorliegen.<\/p>\n Das ist der Fall, wenn man in der laufenden Access-Session bereits einmal die Anmeldedaten für das Aktualisieren oder erneute Anlegen der Tabellenverknüpfungen verwendet hat. Diese werden dann intern gespeichert.<\/p>\n Sobald die Session jedoch geschlossen ist, also die laufende Access-Anwendung mit den zwischengespeicherten Anmeldedaten beendet wurde, liegen die Anmeldedaten nicht mehr im Speicher.<\/p>\n Öffnet man die Access-Anwendung mit den verknüpften Tabellen erneut und versucht, eine der Tabellen zu öffnen, erscheint die Meldung aus Bild 8.<\/p>\n Bild 8: Abfrage der Verbindungsdaten von per SQL Server-Authentifizierung verknüpften Tabellen<\/span><\/b><\/p>\n Wenn wir die Daten einmal eingegeben haben, können wir alle Tabellen, die über die gleiche Verbindungszeichenfolge verknüpft sind, wieder öffnen.<\/p>\n Nachfolgend beschreiben wir, wie man die Verknüpfung zu einer einzelnen Tabelle per VBA aktualisiert und wie man alle Tabellenverknüpfungen erneuert.<\/p>\n Bei Verwendung der SQL Server-Authentifizierung erscheint daher auch hier die Meldung zur Eingabe der Verbindungsdaten. Eine automatische Aktualisierung der Tabellenverknüpfungen ist also nur möglich, wenn wir die Windows-Authentifizierung für den Zugriff auf die Tabellen des SQL Servers verwenden.<\/p>\n Wenn wir die SQL Server-Authentifizierung nutzen, können wir die Tabellen nicht einfach mit den nachfolgend beschriebenen VBA-Prozeduren aktualisieren, sondern müssen zumindest eine Tabellenverknüpfung löschen und erneut anlegen. Dadurch sind anschließend aber auch alle anderen Tabellen mit der gleichen Verbindung wieder zugreifbar.<\/p>\n Hinweis: Früher war es möglich, den Benutzernamen und das Kennwort in der Verbindungszeichenfolge für eine Tabelle dauerhaft zu speichern, aber diese Funktion hat Microsoft aus Sicherheitsgründen entfernt. Das ist sinnvoll, denn sonst könnten die Zugangsdaten über die Benutzeroberfläche ausgelesen werden, was potenzielle Sicherheitslücken mit sich bringt.<\/p>\n Als Erstes schauen wir uns an, wie wir die Tabellenverknüpfungen per VBA aktualisieren können – also so, als ob wir den Befehl Link aktualisieren <\/b>im Kontextmenü einer Tabelle im Navigationsbereich aufrufen.<\/p>\n Wir gehen hier davon aus, dass uns eine frisch mit dem SQL Server Migration Assistant migrierte Datenbankanwendung vorliegt.<\/p>\n Um beispielsweise die Tabellenverknüpfung zur Tabelle tblAbteilungen <\/b>zu aktualisieren, verwenden wir die Methode RefreshLink <\/b>des jeweiligen TableDef<\/b>-Objekts.<\/p>\n Das Aufwendigste daran ist das Referenzieren dieses Objekts. Dazu verwenden wir die folgende Prozedur:<\/p>\n Diese füllt die Variable db<\/b> mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Dann referenzieren wir das TableDef<\/b>-Objekt der Tabelle tblAbteilungen<\/b> und rufen seine Methode RefreshLink <\/b>auf. Schließlich aktualisieren wir noch den Navigationsbereich, damit die Änderung direkt sichtbar wird.<\/p>\n Sollten wir in der Zwischenzeit den Entwurf der SQL Server-Tabelle tblAbteilungen <\/b>angepasst haben, werden diese Änderungen nun beim Öffnen der Tabelle in Access direkt sichtbar.<\/p>\n Eine einzige Tabellenverknüpfung wollen wir meist nur während der Entwicklung aktualisieren, was sich schneller durch das Betätigen des Befehls Link aktualisieren <\/b>des Kontextmenüs des jeweiligen Eintrags im Navigationsbereich von Access realisieren.<\/p>\n Wir wollen vermutlich eher direkt alle Tabellen aktualisieren, zum Beispiel direkt dann, wenn der Benutzer die Anwendung öffnet. Dann können wir die folgende Prozedur aufrufen:<\/p>\n Die Prozedur durchläuft alle Elemente der TableDefs<\/b>-Auflistung und prüft in zwei If…Then<\/b>-Bedingung, ob die Tabelle erstens einen Wert für die Eigenschaft Connect<\/b> enthält und zweitens, ob dieser mit ODBC; <\/b>beginnt.<\/p>\n Für Tabellen, die per ODBC verknüpft sind, liefert die Eigenschaft Connect <\/b>beispielsweise Werte wie den folgenden:<\/p>\n Wenn wir die Frontend-Datenbank vom Entwicklungsrechner zum Rechner des Benutzers übertragen, bei dem einer der folgenden Faktoren zutrifft, reicht das reine Aktualisieren mit RefreshLink <\/b>nicht aus:<\/p>\n In diesem Fall müssen wir vor dem Aufruf der Methode RefreshLink <\/b>noch die neue Verbindungszeichenfolge mit den geänderten Parametern für die Eigenschaft Connect <\/b>festlegen.<\/p>\n Die Prozedur TabellenverknuepfungAktualisieren <\/b>müssen wir dann wie in Listing 1 um die Definition der zu verwendenden Verbindungszeichenfolge erweitern und diese der Eigenschaft Connect <\/b>zuweisen.<\/p>\n Listing 1: Aktualisieren mit neuer Verbindungszeichenfolge<\/span><\/b><\/p>\n Damit stellt sich nun die Frage, in welchem Szenario wir mit dem Aktualisieren der Tabellenverknüpfungen auskommen und wann wie die Tabellenverknüpfungen löschen und und neu erstellen müssen.<\/p>\n Da wir sogar eine neue Verbindungszeichenfolge beim Aktualisieren der Tabellenverknüpfungen über die Connect<\/b>-Eigenschaft des TableDef<\/b>-Objekts übergeben können, sollte dies für sehr viele Fälle bereits ausreichen.<\/p>\n Es gibt jedoch auch Fälle, wo tatsächlich ein Löschen und Neuerstellen der Tabellenverknüpfungen erforderlich ist:<\/p>\n Für diese Fälle haben wir einen Satz von Prozeduren und Funktionen programmiert, die wir in den folgenden Abschnitten beschreiben.<\/p>\n In Fällen, wo das Löschen und erneute Erstellen der Tabellenverknüpfungen nicht erforderlich ist, sollte man es immer mit dem Aktualisieren der Tabellenverknüpfungen versuchen.<\/p>\n Damit erhalten wir zumindest die folgenden beiden Vorteile:<\/p>\n Das Erneuern einer Tabellenverknüpfung per VBA ist aufwendiger als das Aktualisieren. Hier müssen wir die vorhandene Tabellenverknüpfung erst löschen und danach erneut anlegen.<\/p>\n Dafür können wir damit aber auch Tabellenverknüpfungen auf Basis der SQL Server-Authentifizierung aktualisieren. Wir müssen dazu aber den Benutzernamen und das Kennwort der SQL Server-Anmeldung entweder durch den Benutzer eingeben lassen oder aber irgendwo speichern.<\/p>\n Wie bereits beschrieben, ist das nicht mehr in der Verbindungszeichenfolge möglich. Andere Möglichkeiten sind:<\/p>\n Auf diese Möglichkeiten gehen wir später ein.<\/p>\n Nachfolgend stellen wir einen Satz von Prozeduren und Funktionen vor, mit denen Du alle Tabellen einer SQL Server-Datenbank neu einbinden kannst.<\/p>\n Dabei gehen wir direkt davon aus, dass alle Tabellen der SQL Server-Datenbank aktualisiert werden sollen.<\/p>\n Wir orientieren uns also nicht mehr an den Tabellenverknüpfungen, die bereits in der Access-Datenbank vorliegen, sondern lesen alle Tabellen aus der SQL Server-Datenbank aus und legen für diese neue Tabellenverknüpfungen an.<\/p>\n Die Hauptprozedur heißt AlleSQLServerTabellenVerknuepfen<\/b> und sieht wie in Listing 2 aus.<\/p>\n Listing 2: Hauptprozedur zum erneuten Verknüpfen aller Tabellen einer SQL Server-Datenbank<\/span><\/b><\/p>\n Sie erwartet die folgenden Parameter:<\/p>\n Wenn wir strNamensschema <\/b>nicht angeben, werden die Bezeichnungen für die Tabellenverknüpfungen nach dem folgenden Schema angelegt, sodass sich eine Bezeichnung wie dbo_tblAbteilungen <\/b>ergibt:<\/p>\n Für die Tabelle tblAbteilungen <\/b>des Schemas dbo <\/b>lautet der Name der Tabellenverknüpfung in diesem Fall also:<\/p>\n Wir können jedoch ein benutzerdefiniertes Namensschema für das Anlegen der Tabellenverknüpfungen vorgeben.<\/p>\n Dabei können wir die beiden Platzhalter [Tabelle] <\/b>und [Schema] <\/b>für den Parameter strNamensschema <\/b>angeben. Um das gleiche Namensschema wie oben zu erhalten, übergeben wir hier:<\/p>\n Wenn wir nur den Tabellennamen als Tabellenverknüpfung nutzen wollen, übergeben wir folglich:<\/p>\n Die Prozedur AlleSQLServerTabellenVerknuepfen <\/b>deklariert zunächst einige Variablen.<\/p>\n Danach sieht der grundlegende Ablauf wie folgt aus:<\/p>\n Wenn wir die Tabellen einer SQL Server-Datenbank per Windows-Authentifizierung verknüpfen wollen, verwenden wir beispielsweise diesen Aufruf der Funktion AlleSQLServerTabellenVerknuepfen<\/b>:<\/p>\n Dies verknüpft alle Tabellen der Datenbank SQLServerTabellenVerknuepfen <\/b>von dem mit amvDesktop2023 <\/b>angegebenen SQL Server.<\/p>\n Dabei wird das Standardnamensschema [Schema]_[Tabelle] <\/b>verwendet, für die Tabelle tblAbteilungen <\/b>des Schemas dbo <\/b>also beispielsweise dbo_tblAbteilungen<\/b>.<\/p>\n Wenn wir die Tabellenverknüpfungen einfach mit dem Namen der jeweiligen Tabelle anlegen wollen, übergeben wir für den Parameter strNamensschema <\/b>den Wert wie in folgendem Aufruf:<\/p>\n Wollen wir alle Tabellen nach dem Standardschema für eine Verbindung mit SQL Server-Authentifizierung verknüpfen, nutzen wir den folgenden Aufruf:<\/p>\n Für SQL Server-Authentifizierung nur mit dem Tabellennamen verwenden wir folglich den folgenden Aufruf:<\/p>\n Für die Verwendung eines ADODB-Recordsets zum Einlesen aller Tabellen der gewünschten SQL Server-Datenbank benötigen wir einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects 6.1 Library<\/b>, die wir über den Verweise<\/b>-Dialog hinzufügen (siehe Bild 9).<\/p>\n Bild 9: Verweis auf die ADODB-Bibliothek<\/span><\/b><\/p>\n Vorbereitend für das Einlesen dieser Tabellen ermitteln wir mit der Funktion ADODBVerbindungszeichenfolgeHolen <\/b>eine Verbindungszeichenfolge für den direkten Zugriff auf den SQL Server per ADODB (siehe Listing 3).<\/p>\n Listing 3: Ermitteln der ADODB-Verbindungszeichenfolge<\/span><\/b><\/p>\n Diese erwartet die folgenden Parameter:<\/p>\n Die Funktion stellt die Verbindungszeichenfolge in der Variablen strTemp <\/b>zusammen. Dabei werden strServer <\/b>und strDatabase <\/b>direkt in den String eingebunden.<\/p>\n Abhängig davon, ob bolTrustedConnection <\/b>den Wert True <\/b>hat, wird der Zeichenfolge noch das Element Integrated Security=SSPI; <\/b>hinzugefügt oder im Falle des Wertes False <\/b>der Benutzername und das Kennwort:<\/p>\n Der Wert von strTemp <\/b>wird anschließend als Funktionsergebnis zurückgegeben.<\/p>\n Für das Verknüpfen der Tabelle benötigen wir analog eine Verbindungszeichenfolge für ODBC. Diese stellt die Funktion ODBCVerbindungszeichenfolgeHolen <\/b>zusammen (siehe Listing 4).<\/p>\n Listing 4: Ermitteln der ODBC-Verbindungszeichenfolge<\/span><\/b><\/p>\n Diese erwartet die gleichen Parameter wie die Funktion ADODBVerbindungszeichenfolgeHolen<\/b> und stellt die Verbindungszeichenfolge auf ähnliche Weise zusammen. Diese beginnt jedoch mit der Zeichenfolge ODBC; <\/b>und gibt dann mit ODBC Driver 18 for SQL Server <\/b>den Treiber an, was der zum Zeitpunkt der Erstellung dieses Artikels die aktuelle Version ist.<\/p>\n Anschließend hängt sie den Namen für den SQL Server und die Datenbank an und prüft wiederum, ob die Windows-Authentifizierung oder die SQL Server-Authentifizierung verwendet werden soll. Abhängig davon wird nur das Element Trusted_Connection=Yes <\/b>angehängt oder der Benutzername mit UID <\/b>und das Kennwort mit PWD<\/b>.<\/p>\n Nun benötigen wir eine Auflistung aller Tabellen der SQL Server-Datenbank, die wir einlesen wollen.<\/p>\n Dazu nutzen wir ein ADODB-Recordset, das wir mit den Datensätzen einer Abfrage auf eine Systemtabelle des SQL Servers füllen.<\/p>\n Dies alles geschieht in der Funktion AlleSQLServerTabellenHolen <\/b>aus Listing 5, der wir die ADODB-Verbindungszeichenfolge als Parameter übergeben und die ein ADODB-Recordset zurückliefert.<\/p>\n![\"Öffnen](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_002.png\")
<\/p>\nDescription=AccessSQLServer;DRIVER=ODBC Driver 18 for SQL Server;SERVER=amvDesktop2023;Trusted_Connection=Yes;APP=Microsoft Office;DATABASE=SQLServerTabellenverknuepfen;TrustServerCertificate=Yes;<\/pre>\n
Tabellenverknüpfungen verwalten<\/h2>\n
![\"Öffnen](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_003.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_004.png\")
<\/p>\n![\"Neuverknüpfung](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_006.png\")
<\/p>\n![\"Neuverknüpfung](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_007.png\")
<\/p>\nVerknüpfungen über den Navigationsbereich aktualisieren<\/h2>\n
![\"Aktualisieren](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_008.png\")
<\/p>\n\n
Tabellenverknüpfungen aktualisieren bei Windows-Authentifizierung vs. SQL Server-Authentifizierung<\/h2>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_009.png\")
<\/p>\nTabellenverknüpfung aktualisieren per VBA<\/h2>\n
Public Sub <\/span>TabellenverknuepfungAktualisieren()\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 Set<\/span> tdf = db.TableDefs(\"tblAbteilungen\")\r\n tdf.RefreshLink\r\n Application.RefreshDatabaseWindow\r\nEnd Sub<\/span><\/pre>\nAlle Tabellenverknüpfungen aktualisieren<\/h2>\n
Public Sub <\/span>AlleTabellenverknuepfungenAktualisieren()\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>Not<\/span> Len<\/span>(tdf.Connect) = 0 Then<\/span>\r\n If <\/span>Left<\/span>(tdf.Connect, 5) = \"ODBC;\" Then<\/span>\r\n Debug.Print<\/span> tdf.Connect\r\n tdf.RefreshLink\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> tdf\r\n Application.RefreshDatabaseWindow\r\nEnd Sub<\/span><\/pre>\nODBC;Description=AccessSQLServer;DRIVER=ODBC Driver 18 for SQL Server;SERVER=amvDesktop2023;Trusted_Connection=Yes;APP=Microsoft Office;DATABASE=SQLServerTabellenverknuepfen;TrustServerCertificate=Yes;<\/pre>\n
Tabellenverknüpfung mit neuer Verbindungszeichenfolge aktualisieren<\/h2>\n
\n
Public Sub <\/span>TabelleAktualisieren_NeueVerbindungszeichenfolge()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strODBCVerbindungszeichenfolge As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.TableDefs(\"tblAbteilungen\")\r\n strODBCVerbindungszeichenfolge = \"ODBC;DRIVER=ODBC Driver 18 for SQL Server;SERVER=amvDesktop2023;\" _\r\n & \"DATABASE=SQLServerTabellenVerknuepfen;UID=sa;PWD=********;Encrypt=YES;TrustServerCertificate=YES;\"\r\n tdf.Connect = strODBCVerbindungszeichenfolge\r\n tdf.RefreshLink\r\n Application.RefreshDatabaseWindow\r\nEnd Sub<\/span><\/pre>\nWann Tabellenverknüpfungen aktualisieren und wann löschen und erneuern?<\/h2>\n
\n
Besser aktualisieren als löschen und neu erstellen<\/h2>\n
\n
Tabellenverknüpfung erneuern per VBA<\/h2>\n
\n
Routinen zum Erneuern der Tabellenverknüpfungen<\/h2>\n
Public Sub <\/span>AlleSQLServerTabellenVerknuepfen(ByVal strServer As String<\/span>, ByVal strDatabase As String<\/span>, _\r\n Optional<\/span> ByVal bolTrustedConnection As Boolean<\/span> = True, Optional<\/span> ByVal strUser As String<\/span> = \"\", _\r\n Optional<\/span> ByVal strPassword As String<\/span> = \"\", Optional<\/span> ByVal strNamensschema As String<\/span> = \"\")\r\n Dim <\/span>strADODBVerbindungszeichenfolge As String<\/span>\r\n Dim <\/span>strODBCVerbindungszeichenfolge As String<\/span>\r\n Dim <\/span>rstTabellen As <\/span>ADODB.Recordset\r\n Dim <\/span>strSchema As String<\/span>\r\n Dim <\/span>strTabelle As String<\/span>\r\n Dim <\/span>strTabellenverknuepfung As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n \r\n strADODBVerbindungszeichenfolge = ADODBVerbindungszeichenfolgeHolen(strServer, strDatabase, bolTrustedConnection, _\r\n strUser, strPassword)\r\n \r\n strODBCVerbindungszeichenfolge = ODBCVerbindungszeichenfolgeHolen(strServer, strDatabase, _\r\n bolTrustedConnection, strUser, strPassword)\r\n \r\n Set<\/span> rstTabellen = AlleSQLServerTabellen(strADODBVerbindungszeichenfolge)\r\n Set<\/span> db = CurrentDb\r\n \r\n Do While<\/span> Not<\/span> rstTabellen.EOF\r\n strSchema = rstTabellen!TABLE_SCHEMA\r\n strTabelle = rstTabellen!TABLE_NAME\r\n \r\n strTabellenverknuepfung = Tabellenverknuepfungsname(strNamensschema, strSchema, strTabelle)\r\n \r\n Call<\/span> TabellenverknuepfungErstellen(db, strODBCVerbindungszeichenfolge, strSchema, strTabelle, _\r\n strTabellenverknuepfung)\r\n \r\n rstTabellen.MoveNext<\/span>\r\n Loop<\/span>\r\n rstTabellen.Close\r\n Set<\/span> rstTabellen = Nothing\r\n Set<\/span> db = Nothing\r\n \r\n MsgBox<\/span> \"Verknuepfung aller SQL-Server-Tabellen abgeschlossen.\", vbInformation\r\nEnd Sub<\/span><\/pre>\n\n
[Schema]_[Tabelle]<\/pre>\n
dbo_tblAbteilungen<\/pre>\n
[Schema]_[Tabelle]<\/pre>\n
[Tabelle]<\/pre>\n
\n
Beispiele für den Aufruf<\/h2>\n
Call<\/span> AlleSQLServerTabellenVerknuepfen(\"amvDesktop2023\", _\r\n \"SQLServerTabellenVerknuepfen\", True<\/span>)<\/pre>\nCall<\/span> AlleSQLServerTabellenVerknuepfen(\"amvDesktop2023\", _\r\n \"SQLServerTabellenVerknuepfen\", True, , , \"[Tabelle]\")<\/pre>\nCall<\/span> AlleSQLServerTabellenVerknuepfen(\"amvDesktop2023\", _\r\n \"SQLServerTabellenVerknuepfen\", False, _\r\n \"sa\", \"********\")<\/pre>\nCall<\/span> AlleSQLServerTabellenVerknuepfen( _\r\n \"amvDesktop2023\", _\r\n \"SQLServerTabellenVerknuepfen\", False, _\r\n \"sa\", \"********\", \"[Tabelle]\")<\/pre>\nZusammenstellen der ADODB-Verbindungszeichenfolge<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2025_05\/pic_485_010.png\")
<\/p>\nPublic Function <\/span>ADODBVerbindungszeichenfolgeHolen(ByVal strServer As String<\/span>, ByVal strDatabase As String<\/span>, _\r\n Optional<\/span> ByVal bolTrustedConnection As Boolean<\/span> = True, Optional<\/span> ByVal strUser As String<\/span> = \"\", _\r\n Optional<\/span> ByVal strPassword As String<\/span> = \"\") As String<\/span>\r\n \r\n Dim <\/span>strTemp As String<\/span>\r\n \r\n strTemp = \"Provider=MSOLEDBSQL;Server=\" & strServer & \";Database=\" & strDatabase & \";\"\r\n \r\n If <\/span>bolTrustedConnection Then<\/span>\r\n strTemp = strTemp & \"Integrated Security=SSPI;\"\r\n Else<\/span>\r\n strTemp = strTemp & \"User ID=\" & strUser & \";Password=\" & strPassword & \";\"\r\n End If<\/span>\r\n \r\n ADODBVerbindungszeichenfolgeHolen = strTemp\r\nEnd Function<\/span><\/pre>\n\n
\"User ID=\" & strUser & \";Password=\" & strPassword & \";\"<\/pre>\n
Zusammenstellung der ODBC-Verbindungszeichenfolge<\/h2>\n
Public Function <\/span>ODBCVerbindungszeichenfolgeHolen(ByVal strServer As String<\/span>, ByVal strDatabase As String<\/span>, _\r\n Optional<\/span> ByVal bolTrustedConnection As Boolean<\/span> = True, Optional<\/span> ByVal strUser As String<\/span> = \"\", _\r\n Optional<\/span> ByVal strPassword As String<\/span> = \"\") As String<\/span>\r\n \r\n Dim <\/span>strTemp As String<\/span>\r\n \r\n strTemp = \"ODBC;DRIVER=ODBC Driver 18 for SQL Server;SERVER=\" & strServer & \";DATABASE=\" & strDatabase & \";\"\r\n \r\n If <\/span>bolTrustedConnection Then<\/span>\r\n strTemp = strTemp & \"Trusted_Connection=Yes;\"\r\n Else<\/span>\r\n strTemp = strTemp & \"UID=\" & strUser & \";PWD=\" & strPassword & \";\"\r\n End If<\/span>\r\n \r\n strTemp = strTemp & \"Encrypt=YES;TrustServerCertificate=YES;\"\r\n \r\n ODBCVerbindungszeichenfolgeHolen = strTemp\r\nEnd Function<\/span><\/pre>\nAlle zu verknüpfenden SQL Server-Tabellen ermitteln<\/h2>\n
Public Function <\/span>AlleSQLServerTabellenHolen(ByVal strVerbindungszeichenfolge As String<\/span>) As <\/span>ADODB.Recordset\r\n