Der SQL Server-Tabellenverknüpfungsassistent, den wir im Beitrag „SQL Server-Tabellenverknüpfungsassistent“ (www.access-im-unternehmen.de\/1540) vorgestellt haben, funktioniert in vielen Settings bereits recht gut. Die generelle Praxistauglichkeit zeigt sichjedoch erst, wenn die Anwendung einmal auf andere Benutzer und\/oder Verwendungszwecke stößt. Da dies nun geschehen ist, wollen wir im zweiten Teil der Beitragsreihe zum Thema SQL Server-Tabellenverknüpfungsassistent einige Änderungen und Erweiterungen nachreichen. Dabei geht es im Wesentlichen um die Benennung der Tabellenverknüpfungen, die von dem Assistenten entweder initial angelegt oder aktualisiert werden sollen.<\/b><\/p>\n
Probleme beim Einsatz des Tabellenverknüpfungsassistenten<\/h2>\n
Das Hauptproblem, das uns zurückgemeldet wurde, ist die Inflexibilität bei der Verwendung der Bezeichnungen für die Tabellenverknüpfungen. Im ersten Teil gingen wir davon aus, dass wir allein mit dem Namen der Tabelle auskommen – so sah auch das Formular zum Verwalten der zu verknüpfenden Tabellen aus (siehe Bild 1).<\/p>\n
![\"Hauptformular](\"..\/fileadmin\/_temp_\/2025_03\/pic_1551_002.png\")
<\/p>\n
Bild 1: Hauptformular Access-Add-Ins<\/span><\/b><\/p>\n Das Add-In erledigt die folgenden Aufgaben:<\/p>\n Das initiale Verknüpfen ist somit normalerweise immer funktional, außer man möchte, dass die Tabellenverknüpfungen anders benannt werden als die Tabellen auf dem SQL Server.<\/p>\n Das Aktualisieren der Tabellenverknüpfungen offenbart allerdings weitere Schwachstellen:<\/p>\n Diese Probleme adressieren wir in der Überarbeitung des Assistenten im vorliegenden Beitrag.<\/p>\n Wir wollen also folgende Änderungen erreichen:<\/p>\n Da wir nun nicht mehr nur mit den Tabellennamen arbeiten wollen, wie sie im SQL Server vorkommen, sondern auch noch die Namen der vorhandenen Tabellenverknüpfungen berücksichtigen wollen, nutzen wir zur Übersicht eine Tabelle namens tblTablesTemp<\/b>. Diese ist wie in Bild 2 aufgebaut. Hier speichern wir neben dem Namen der Tabelle im SQL Server auch den Namen der Tabellenverknüpfung in der Access-Datenbank. Außerdem wollen wir auch noch das Schema (zum Beispiel dbo<\/b>) und den Tabellennamen ohne Schema in eigenen Feldern speichern.<\/p>\n Bild 2: Tabelle zum Speichern der Tabelleninformationen<\/span><\/b><\/p>\n Beim Laden des Formulars wird in der Ereignisprozedur Form_Load <\/b>die Methode cboVerbindung_AfterUpdate <\/b>aufgerufen. Diese wird auch als Ereignis ausgelöst, wenn der Benutzer eine neue Verbindung über das Kombinationsfeld cboVerbindung <\/b>auswählt.<\/p>\n Die Prozedur cboVerbindung_AfterUpdate <\/b>haben wir so angepasst, dass alle für die Tabelle tblTablesTemp <\/b>benötigten Daten eingelesen werden (siehe Listing 1).<\/p>\n Listing 1: Einlesen der Tabellendaten beim Laden des Formulars<\/span><\/b><\/p>\n Wir deklarieren und initialisieren zwei DAO.Database<\/b>-Variablen namens dbc <\/b>und db<\/b>, mit denen wir das Database<\/b>-Objekt der Add-In-Datenbank und der geöffneten Datenbank referenzieren.<\/p>\n Im ersten Schritt leeren wir die Tabelle tblTablesTemp<\/b>. Dann folgen die bereits bekannten Schritte, um den aktuellen Benutzer und sein Kennwort zu ermitteln, die wir zum Testen der Verbindung mit der Funktion VerbindungTesten <\/b>benötigen.<\/p>\n Ist dieser Aufruf erfolgreich, haben wir in strVerbindungszeichenfolge <\/b>eine funktionierende Zeichenkette mit den Verbindungsdaten.<\/p>\n Zum Aufbau der Verbindung erstellen wir nun mit CreateQueryDef <\/b>eine temporäre Abfrage, die wir mit qdf <\/b>referenzieren.<\/p>\n Diese versehen wir über die SQL<\/b>-Eigenschaft mit einer Abfrage, die uns die Felder TABLE_SCHEMA<\/b>, TABLE_NAME <\/b>und den mit dem Schema versehenen Tabellennamen (CONCAT(TABLE_SCHEMA, “.“, TABLE_NAME<\/b>) für das Feld TABLE_SCHEMA_NAME <\/b>aus der Systemtabelle INFORMATION_SCHEMA.TABLES <\/b>des SQL Servers, bei denen der Tabellentyp über das Kriterium TABLE_TYPE IN (“BASE TABLE“, “VIEW“) <\/b>als Tabelle oder View erkannt wird.<\/p>\n Die Verbindungszeichenfolge stellen wir auf den Inhalt der Variablen strVerbindungszeichenfolge <\/b>ein und legen mit .ReturnsRecords = True <\/b>fest, dass diese Abfrage Datensätze zurückliefern soll.<\/p>\n Auf Basis dieser Abfrage erstellen wir mit OpenRecordset <\/b>ein Recordset, das wir mit rstTablesSQL <\/b>referenzieren.<\/p>\n Danach erstellen wir noch ein zweites Recordset namens rstTablesLocal<\/b>, das wir mit den Daten der Access-Systemtabelle MSysObjects <\/b>füllen, bei denen das Feld Connect <\/b>gefüllt ist.<\/p>\n Dies weist darauf hin, dass es sich um eine Tabellenverknüpfung handelt. Die Abfrage enthält einen weiteren Parameter, nämlich NOT Name Like “~*“<\/b>.<\/p>\n Er sorgt für den Fall vor, dass wir in der aktuellen Session, also seit dem Öffnen der Access-Datenbank, bereits manuell Tabellenverknüpfungen gelöscht haben.<\/p>\n Diese werden nicht direkt vollständig gelöscht, sondern sind noch unter einem temporären Namen wie ~TMPCLP215381 <\/b>in der Datenbank vorhanden.<\/p>\n Sie enthalten wie die gelöschte Tabellenverknüpfung noch die Eigenschaft Connect <\/b>und werden so zu der entsprechenden SQL Server-Tabelle zugeordnet. Damit diese in der Liste nicht angezeigt werden, geben wir den entsprechenden zusätzlichen Filter an.<\/p>\n In der folgenden Do While<\/b>-Schleife durchlaufen wir alle Datensätze des Recordsets rstTableSQL<\/b> und schreiben dort den Namen der Tabelle in die Variable strTableSQL<\/b>.<\/p>\n Damit durchlaufen wir in einer inneren Do While<\/b>-Schleife alle Datensätze des Recordsets mit den Tabellenverknüpfungen. Hier lesen wir aus der Eigenschaft SourceTableName <\/b>den Namen der Tabelle ein, die als Quelle für die Tabellenverknüpfung dient. Dazu greifen wir über die TableDefs<\/b>-Auflistung auf die entsprechende Tabellendefinition zu und speichern das Ergebnis in der Variablen strTableSource<\/b>.<\/p>\n Wenn nun der Wert der in der äußeren Do While<\/b>-Schleife ermittelten SQL Server-Tabelle mit dem Namen der Quelltabelle mit der in der inneren Schleife durchlaufenen Tabelle übereinstimmt, haben wir einen Treffer: Dann tragen wir in die Variable strTableLink <\/b>(für die Tabellenverknüpfung) den Namen der Tabellenverknüpfung ein und verlassen die innere Schleife.<\/p>\n Anderenfalls durchlaufen wir die lokalen Tabellen solange, bis wir eine Übereinstimmung finden oder alle Tabellen durchlaufen wurden. Damit können wir einen neuen Datensatz in die Tabelle tblTablesTemp<\/b> anlegen – unabhängig davon, ob wir eine passende Tabellenverknüpfung gefunden haben.<\/p>\n Es kann schließlich auch vorkommen, dass eine Tabelle der SQL Server-Datenbank noch nicht als Tabellenverknüpfung in der Access-Datenbank repräsentiert ist.<\/p>\n Wir tragen also den Namen der SQL Server-Tabelle, den Namen der Tabellenverknüpfung, das Schema und den reinen Tabellennamen in die Tabelle tblTablesTemp <\/b>ein.<\/p>\n Damit stellen wir das Recordset für die innere Schleife wieder auf den ersten Datensatz zurück und bewegen den Datensatzzeiger für das Recordset der äußeren Schleife zum nächsten Datensatz.<\/p>\n Bevor wir den Rest der Prozedur betrachten, schauen wir uns die notwendigen Änderungen am Listenfeld lstTabellen <\/b>zur Anzeige der Tabellen im Formular frmTabellenverknuepfungen <\/b>an (siehe Bild 3).<\/p>\n Bild 3: Neuer Entwurf des Formulars frmTabellenVerknuepfen<\/span><\/b><\/p>\n Hier haben wir zunächst eine Datensatzherkunft zugewiesen:<\/p>\n Damit nur die beiden Felder TableSQL <\/b>und TableLink <\/b>angezeigt werden, haben wir die Eigenschaften Spaltenanzahl <\/b>auf 4 <\/b>und Spaltenbreiten <\/b>auf ;;0cm;0cm <\/b>eingestellt. Die übrigen beiden Felder Schema <\/b>und Table <\/b>landen unsichtbar im Listenfeld, wodurch wir sie zwar nicht sehen, aber dennoch auf diese zugreifen können, sollte dies eventuell zum Verknüpfen erforderlich sein.<\/p>\n In der Formularansicht sieht das nun beispielsweise wie in Bild 4 aus.<\/p>\n Bild 4: Formularansicht des Formulars frmTabellenVerknuepfen<\/span><\/b><\/p>\n Es fehlt noch der Teil des Codes, der dafür sorgt, dass solche Tabellen, für die bereits eine Verknüpfung vorliegt, automatisch markiert werden.<\/p>\n Dazu durchlaufen wir die Elemente des Listenfeldes in einer For…Next<\/b>-Schleife über die Werte 0 <\/b>bis zur Anzahl der Listenelemente minus 1<\/b>.<\/p>\n Wir prüfen, ob die erste Spalte der aktuellen Zeile einen Eintrag mit einer Länge größer als 0 <\/b>enthält.<\/p>\n Ist das der Fall, wird der Eintrag durch Einstellen der Selected<\/b>-Auflistung für die Zeile mit dem entsprechenden Index auf True <\/b>eingestellt.<\/p>\n Damit haben wir den Teil zum Darstellen der vorliegenden SQL Server-Tabellen und der entsprechenden Tabellenverknüpfungen bereits erledigt.<\/p>\n Wie oben beschreiben, wollen wir nun das Verknüpfen von Tabellen optimieren. Nochmal kurz zusammengefasst:<\/p>\n Damit der Benutzer Regeln für die zu verwendenden Namen aufstellen kann, haben wir dem Formular frmTabellenVerknuepfen <\/b>weitere Steuerelemente hinzugefügt.<\/p>\n Hier sehen wir als Erstes ein Textfeld mit der Beschriftung Name für neue Tabellenverknüpfungen<\/b>. Hier können wir beliebige Texte einfügen, aber wir sollten die Platzhalter [Name]<\/b> und gegebenenfalls zusätzlich [Schema] <\/b>hinzufügen.<\/p>\n Wichtig: Wenn wir hier keinen Wert angeben, wird der Name der Tabelle ohne Schema verwendet, bei dbo.tblAnlagen <\/b>also beispielsweise nur tblAnlagen<\/b>.<\/p>\n Hier sind einige Beispiele für die Ausdrücke, die im Feld Name für neue Tabellenverknüpfungen <\/b>angegeben werden können:<\/p>\n Beachten Sie, dass die Regeln für die Benennung von Access-Objekten hier berücksichtigt werden – also nur alphanumerische Zeichen und der Unterstrich. Es sind zwar auch andere Zeichen möglich, aber ungünstig.<\/p>\n Diese Option sorgt dafür, dass alle Tabellenverknüpfungen, die im Listenfeld markiert sind, gelöscht und neu angelegt werden. Das führt auch dazu, dass die neuen Tabellenverknüpfungen unter Berücksichtigung der angegebenen Benennungskonvention erstellt werden.<\/p>\n Wenn man also beispielsweise eine Migration der Datenbank mit dem SQL Server Migration Assistant durchgeführt hat, wurden die Tabellenverknüpfungen üblicherweise mit dbo_Tabellenname <\/b>benannt.<\/p>\n Dann sollte man, wenn man die Tabellen mit der hier vorgestellten Lösung neu verknüpft, auch das Format [Schema]_[Name] <\/b>einstellen.<\/p>\n Nachdem wir festgelegt haben, welche Tabellen verknüpft werden sollen und nach welchem Schema, können wir auf die Schaltfläche cmdTabellenVerknuepfen <\/b>klicken. Diese ruft die Prozedur aus Listing 2 auf.<\/p>\n Listing 2: Aufruf der Verknüpfung von Tabellen<\/span><\/b><\/p>\n Die Prozedur deklariert drei Variablen für die Benennung von Tabellen:<\/p>\n Als Erstes prüft die Prozedur, ob die Bedingungen für das Ersetzen der Tabellenverknüpfungen erfüllt sind. Wenn der Benutzer im Textfeld txtNeuerName <\/b>nicht den Platzhalter [Name] <\/b>einträgt, der den Tabellennamen aus dem SQL Server widerspiegelt und dieses Textfeld auch nicht leer lässt, kann er nur eine Verknüpfung neu erstellen.<\/p>\n Der Grund ist, dass mit dem statischen Namen für die neue Verknüpfung sonst mehrere neue Verknüpfungen den gleichen Namen erhalten würden, was beim Anlegen des ersten doppelten Objekts zu einem Fehler führen würde.<\/p>\n Also prüfen wir zuerst, ob txtNeuerName <\/b>nicht leer ist. Ist das Textfeld leer, verwendet das Formular automatisch den Namen der SQL Server-Tabelle für die Tabellenverknüpfung und wir haben individuelle Namen je Tabellenverknüpfung.<\/p>\n Ist es nicht leer, prüft die Prozedur, ob der Benutzer den Platzhalter [Name] <\/b>in den Ausdruck für den Namen der neuen Tabellenverknüpfungen integriert hat.<\/p>\n Anderenfalls prüft sie, ob der Benutzer mehr als einen Eintrag der Liste zum Aktualisieren der Verknüpfung ausgewählt hat. Ist das der Fall, erscheint eine Meldung, dass dies nicht möglich ist und die Prozedur wird abgebrochen.<\/p>\n Ist das nicht der Fall, prüft die Prozedur mit einem Aufruf der Funktion VerbindungTesten <\/b>wieder, ob die Verbindung funktioniert, und liefert mit strVerbindungszeichenfolge <\/b>die aktuelle Verbindungszeichenfolge zurück.<\/p>\n Dann durchläuft die Prozedur in einer For…Next<\/b>-Schleife alle Elemente des Listenfeldes lstTabellen<\/b>. Dabei werden die Werte von 0 <\/b>bis zur Anzahl der Listenelement minus 1 <\/b>verwendet.<\/p>\n In die Variable strTableSQL <\/b>liest die Prozedur den Wert der ersten Spalte mit dem Index 0 <\/b>des Listenfeldes ein, also den Namen der SQL Server-Tabelle. In strTableLocal <\/b>landet der Wert der zweiten Spalte. Dieser kann auch leer sein, wenn es noch keine Tabellenverknüpfung gibt, die sich auf die aktuelle SQL Server-Tabelle bezieht. Schließlich schreiben wir in die Variable strTableNew <\/b>den durch den Benutzer definierten Namen für die neu anzulegende Tabellenverknüpfung.<\/p>\n Dabei verwendet die Prozedur den Text des Feldes txtNeuerName<\/b>, indem sich beispielsweise ein Ausdruck wie [Schema]_[Name] <\/b>befindet, und ersetzt die Platzhalter [Schema] <\/b>und [Name] <\/b>durch die Werte der dritten und vierten Spalte des Listenfeldes für den aktuellen Eintrag.<\/p>\n Wenn strTableNew <\/b>danach noch leer sein sollte, was der Fall ist, wenn der Benutzer keinen Wert in das Textfeld txtNeuerName <\/b>eingetragen hat, trägt die Prozedur einfach den Namen der SQL Server-Tabelle als Namen der anzulegenden Tabellenverknüpfung an.<\/p>\n Danach ruft sie die Funktion TabelleVerknuepfen <\/b>auf und übergibt dieser die drei Variablen strTableLocal<\/b>, strTableNew <\/b>und strTableSQL <\/b>als Parameter sowie die Verbindungszeichenfolge und den Wert der Option aus chkImmerUeberschreiben<\/b>.<\/p>\n Liefert diese den Wert True<\/b> zurück, wurde die Tabellenverknüpfung erfolgreich angelegt und wir erhöhen den Wert des Zählers lngConnected <\/b>um 1<\/b>. Damit zählen wir die Anzahl der erfolgreich hinzugefügten Tabellenverknüpfungen und geben diese anschließend aus.<\/p>\n Damit rufen wir nochmal die Prozedur cboVerbindung_AfterUpdate <\/b>auf, damit die aktualisierten Tabellenverknüpfungen im Listenfeld angezeigt werden können und geben die Anzahl der aktualisierten Elemente in einem Meldungsfenster aus.<\/p>\n Die Funktion aus Listing 3 erledigt die Hauptarbeit. Sie nimmt die von der aufrufenden Prozedur übergebenen Parameter entgegen und deklariert ein TableDef<\/b>-Objekt zum Anlegen der Tabellenverknüpfung.<\/p>\n Listing 3: Funktion zum Erstellen oder Aktualisieren von Tabellenverknüpfungen<\/span><\/b><\/p>\n Sie prüft als Erstes, ob der Parameter bolImmerUeberschreiben <\/b>den Wert True <\/b>liefert. In diesem Fall soll die Tabellenverknüpfung auf jeden Fall gelöscht werden, was mit der Delete<\/b>-Methode der TableDefs<\/b>-Auflistung für die Tabellenverknüpfung aus strTableLocal <\/b>geschieht.<\/p>\n Hat bolImmerUeberschreiben <\/b>nicht den Wert True<\/b>, untersuchen wir die Aufgabe genauer, wobei wir auch auf die Unterstützung des Benutzers zurückgreifen.<\/p>\n Danach prüft die Prozedur, ob strTableLocal<\/b> aktuell überhaupt gefüllt ist, also ob es für die aktuelle SQL Server-Tabelle bereits eine Tabellenverknüpfung gibt. Ist das der Fall, können wir gleich zum nächsten Schritt springen. Wenn es allerdings bereits eine Tabellenverknüpfung für die Tabelle gibt, müssen wir ein paar weitere Schritte unternehmen.<\/p>\n Dabei zeigen wir eine InputBox <\/b>an, die wie in Bild 5 aussieht und die den Namen der aktuellen Tabellenverknüpfung für die SQL Server-Tabelle anzeigt und auch den Namen der SQL Server-Tabelle.<\/p>\n Bild 5: Rückfrage, unter welchem Namen die Verknüpfung angelegt werden soll.<\/span><\/b><\/p>\n Unten zeigt die InputBox den zuvor ermittelten Namen für die neu zu erstellende Tabellenverknüpfung an.<\/p>\n Der Benutzer hat nun die folgenden Möglichkeiten:<\/p>\n Wie auch immer er sich entscheidet, landet das Ergebnis in der Variablen strTableNew<\/b>.<\/p>\n Hat diese die Länge 0<\/b>, hat der Benutzer auf Abbrechen <\/b>geklickt und die Tabelle soll nicht verknüpft werden. Dann wird als Funktionswert False <\/b>zurückgeliefert und die Funktion wird beendet.<\/p>\n Anderenfalls prüft die Prozedur, ob bereits eine Tabellenverknüpfung für diese Tabelle vorhanden war und löscht diese gegebenenfalls.<\/p>\n Anschließend folgt das Anlegen der neuen Tabellenverknüpfung. Mit der CreateTableDef<\/b>-Methode erstellt die Funktion ein neues TableDef<\/b>-Objekt mit dem Namen aus strTableNew<\/b>.<\/p>\n Sie stellt die Verbindungszeichenfolge des TableDef<\/b>-Objekts auf den Inhalt aus strVerbindungszeichenfolge <\/b>ein und die Quelltabelle auf die Tabelle aus strTableSQL<\/b>. Dann hängt sie das neue TableDef<\/b>-Objekt an die TableDefs<\/b>-Auflistung an und aktualisiert die Tabellenverknüpfung mit der RefreshLink<\/b>-Methode.<\/p>\n Schließlich aktualisiert die Methode RefreshDatabaseWindow<\/b> auch noch den Navigationsbereich von Access und sorgt so für die Anzeige der neu erstellten Tabellenverknüpfungen.<\/p>\n Als Funktionswert liefert die Funktion den Wert True <\/b>zurück.<\/p>\n Wenn wir ein wenig mit der Listenansicht experimentieren, sehen wir, dass wir bei der ausgewählten Einstellung Erweitert <\/b>für die Eigenschaft Mehrfachauswahl <\/b>nicht einfach mit einer Tastenkombination wie Strg + A <\/b>alle Einträge selektieren können.<\/p>\n Dies wäre jedoch wünschenswert – vor allem für SQL Server-Datenbanken, die sehr viele Tabellen enthalten und die als Tabellenverknüpfung hinzugefügt oder aktualisiert werden sollen.<\/p>\n Wir können lediglich bei gedrückter Strg<\/b>-Taste einzelne Einträge hinzufügen oder abwählen oder bei gedrückter Umschalttaste den ersten und den letzten auszuwählenden Eintrag selektieren.<\/p>\n Für das Selektieren aller Einträge können wir beispielsweise Folgendes erledigen:<\/p>\n Wir wollen hier die Methode mit der Tastenkombination hinzufügen.<\/p>\n Für diese Variante fügen wir dem Ereignis Bei Taste ab <\/b>des Listenfeldes die Ereignisprozedur aus Listing 4 hinzu.<\/p>\n\n
\n
Ziele der Anpassung<\/h2>\n
\n
Erster Schritt: Tabelle zum Speichern der Tabelleninformationen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_03\/pic_1551_013.png\")
<\/p>\nFüllen der Tabelle tblTempTables<\/h2>\n
Public Sub <\/span>cboVerbindung_AfterUpdate()\r\n '' ... Deklarationen ...\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> db = CurrentDb\r\n dbc.Execute \"DELETE FROM tblTablesTemp\", dbFailOnError\r\n If <\/span>Len<\/span>(strBenutzername) = 0 Then<\/span>\r\n strBenutzername = Nz(dbc.OpenRecordset(\"SELECT Benutzername FROM tblVerbindungszeichenfolgen \" _\r\n & \"WHERE VerbindungszeichenfolgeID = \" & Me!cboVerbindung).Fields(0), \"\")\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strKennwort) = 0 Then<\/span>\r\n strKennwort = Nz(dbc.OpenRecordset(\"SELECT Kennwort FROM tblVerbindungszeichenfolgen \" _\r\n & \"WHERE VerbindungszeichenfolgeID = \" & Me!cboVerbindung).Fields(0), \"\")\r\n End If<\/span>\r\n If <\/span>VerbindungTesten(Me!cboVerbindung, strVerbindungszeichenfolge, lngErrorNumber, strErrorDescription) = True<\/span> Then<\/span>\r\n Set<\/span> qdf = db.CreateQueryDef(\"\")\r\n With<\/span> qdf\r\n .SQL = \"SELECT TABLE_SCHEMA, TABLE_NAME, CONCAT(TABLE_SCHEMA, ''.'', TABLE_NAME) AS TABLE_SCHEMA_NAME \" _\r\n & \"FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE IN (''BASE TABLE'', ''VIEW'') ORDER BY TABLE_TYPE, TABLE_NAME\"\r\n .Connect = strVerbindungszeichenfolge\r\n .ReturnsRecords = True<\/span>\r\n End With<\/span>\r\n Set<\/span> rstTablesSQL = qdf.OpenRecordset\r\n Set<\/span> rstTablesLocal = db.OpenRecordset(\"SELECT Name FROM MSysObjects WHERE NOT Connect IS NULL \" _\r\n & \"AND NOT Name LIKE ''~*''\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstTablesSQL.EOF\r\n strTableSQL = rstTablesSQL!TABLE_SCHEMA_NAME\r\n Do While<\/span> Not<\/span> rstTablesLocal.EOF\r\n strTableSource = db.TableDefs(rstTablesLocal!Name).SourceTableName\r\n strTableLink = \"\"\r\n If <\/span>rstTablesSQL!TABLE_SCHEMA_NAME = strTableSource Then<\/span>\r\n strTableLink = rstTablesLocal!Name\r\n Exit Do<\/span>\r\n End If<\/span>\r\n rstTablesLocal.MoveNext<\/span>\r\n Loop<\/span>\r\n dbc.Execute \"INSERT INTO tblTablesTemp(TableSQL, TableLink, [Schema], [Table]) VALUES(''\" & strTableSQL & \"'', ''\" _\r\n & strTableLink & \"'', ''\" & rstTablesSQL!TABLE_SCHEMA & \"'', ''\" & rstTablesSQL!TABLE_NAME & \"'')\", dbFailOnError\r\n If <\/span>Not<\/span> rstTablesLocal.BOF Then<\/span>\r\n rstTablesLocal.MoveFirst\r\n End If<\/span>\r\n rstTablesSQL.MoveNext<\/span>\r\n Loop<\/span>\r\n Me.lstTabellen.RowSource = \"SELECT TableSQL, TableLink, Schema, Table FROM tblTablesTemp ORDER BY TableSQL, TableLink\"\r\n For i = 0 To Me.lstTabellen.ListCount\r\n If <\/span>Not<\/span> Len<\/span>(Me.lstTabellen.Column(1, i)) = 0 Then<\/span>\r\n Me.lstTabellen.Selected(i) = True<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n Else<\/span>\r\n MsgBox<\/span> \"Keine gültige Verbindung.\" & vbCrLf<\/span> & vbCrLf<\/span> & strErrorDescription\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nSQL Server-Tabellen und Tabellenverknüpfungen im Listenfeld anzeigen<\/h2>\n
![\"Neuer](\"..\/fileadmin\/_temp_\/2025_03\/pic_1551_014.png\")
<\/p>\nSELECT TableSQL, TableLink, Schema, Table FROM tblTablesTemp ORDER BY TableSQL, TableLink;<\/pre>\n
![\"Formularansicht](\"..\/fileadmin\/_temp_\/2025_03\/pic_1551_020.png\")
<\/p>\nErweiterte Optionen zum Verknüpfen von Tabellen<\/h2>\n
\n
Beispiele für die Benennung der neuen Tabellenverknüpfungen<\/h2>\n
\n
Option „Vorhandene Tabellen immer überschreiben“<\/h2>\n
Durchführung der Verknüpfung<\/h2>\n
Private Sub <\/span>cmdTabellenVerknuepfen_Click()\r\n Dim <\/span>strTableLocal As String<\/span>\r\n Dim <\/span>strTableSQL As String<\/span>\r\n Dim <\/span>strTableNew As String<\/span>\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Dim <\/span>lngConnected As Long<\/span>\r\n Dim <\/span>lngSelected As Long<\/span>\r\n Dim <\/span>strVerbindungszeichenfolge As String<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Nz(Me.txtNeuerName, \"\")) = 0 Then<\/span>\r\n If <\/span>InStr<\/span>(1, Me.txtNeuerName, \"[Name]\") = 0 Then<\/span>\r\n If <\/span>Me.lstTabellen.ItemsSelected.Count > 1 Then<\/span>\r\n MsgBox<\/span> \"Der Ausdruck für den neuen Namen der Verknüpfung muss zumindest den Platzhalter [Name] \" _\r\n & \"enthalten.\" & vbCrLf<\/span> & vbCrLf<\/span> & \"Wenn das nicht der Fall ist, kann nur eine Verknüpfung \" _\r\n & \"angelegt werden.\" & vbCrLf<\/span> & vbCrLf<\/span> & \" Der Vorgang wird abgebrochen.\", vbOKOnly + _\r\n vbExclamation, \"Fehlender Platzhalter\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>VerbindungTesten(Me!cboVerbindung, strVerbindungszeichenfolge) = True<\/span> Then<\/span>\r\n For lngSelected = 0 To Me!lstTabellen.ItemsSelected.Count - 1\r\n lngIndex = Me.lstTabellen.ItemsSelected(lngSelected)\r\n strTableSQL = Me.lstTabellen.Column(0, lngIndex)\r\n strTableLocal = Me.lstTabellen.Column(1, lngIndex)\r\n strTableNew<\/span> = Replace<\/span>(Replace<\/span>(Nz(Me.txtNeuerName, \"\"), \"[Schema]\", Me.lstTabellen.Column(2, lngIndex)), _\r\n \"[Name]\", Me.lstTabellen.Column(3, lngIndex))\r\n If <\/span>Len<\/span>(strTableNew<\/span>) = 0 Then<\/span>\r\n strTableNew<\/span> = Me.lstTabellen.Column(3, lngIndex)\r\n End If<\/span>\r\n If TabelleVerknuepfen(strTableLocal, strTableNew, strTableSQL, strVerbindungszeichenfolge, _\r\n Me!chkImmerUeberschreiben) = True<\/span> Then\r\n lngConnected = lngConnected + 1\r\n End If<\/span>\r\n Next<\/span> lngSelected\r\n Call<\/span> cboVerbindung_AfterUpdate\r\n MsgBox<\/span> lngConnected & \" Tabellen wurden verknüpft.\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Verbindung konnte nicht hergestellt werden.\"\r\n End If<\/span>\r\n Call<\/span> VerknuepfungInDatenbankSpeichern(Me.cboVerbindung)\r\nEnd Sub<\/span><\/pre>\n\n
Verknüpfen der Tabelle in der Funktion „TabelleVerknuepfen“<\/h2>\n
Public Function <\/span>TabelleVerknuepfen(strTableLocal As String<\/span>, strTableNew As String<\/span>, ByVal strTableSQL As String<\/span>, _\r\n strVerbindungszeichenfolge As String<\/span>, bolImmerUeberschreiben As Boolean<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>tdf As <\/span>dao.TableDef\r\n \r\n Set<\/span> db = CurrentDb\r\n If <\/span>bolImmerUeberschreiben = True<\/span> Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strTableLocal) = 0 Then<\/span>\r\n db.TableDefs.Delete strTableLocal\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strTableLocal) = 0 Then<\/span>\r\n strTableNew<\/span> = InputBox(\"Das Objekt namens ''\" & strTableLocal & \"'' ist bereits mit der \" _\r\n & \"SQL Server-Tabelle ''\" & strTableSQL & \"'' verknüpft.\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & \"Klicke auf OK, um es zu löschen, und unter dem folgenden Namen neu zu erstellen.\" & vbCrLf<\/span> _\r\n & vbCrLf<\/span> & \"Du kannst den Namen auch manuell anpassen.\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & \"Oder klicke auf Abbrechen, um die Tabellenverknüpfung nicht zu erstellen.\", _\r\n \"Bereits vorhandenes Objekt\", strTableNew<\/span>)\r\n If <\/span>Len<\/span>(strTableNew<\/span>) = 0 Then<\/span>\r\n TabelleVerknuepfen = False<\/span>\r\n Exit Function<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strTableLocal) = 0 Then<\/span>\r\n db.TableDefs.Delete strTableLocal\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Set<\/span> tdf = db.CreateTableDef(strTableNew<\/span>)\r\n tdf.Connect = strVerbindungszeichenfolge\r\n tdf.SourceTableName = strTableSQL\r\n db.TableDefs.Append tdf\r\n db.TableDefs(strTableNew<\/span>).RefreshLink\r\n Application.RefreshDatabaseWindow\r\n TabelleVerknuepfen = True<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Rückfrage,](\"..\/fileadmin\/_temp_\/2025_03\/pic_1551_021.png\")
<\/p>\n\n
Optimierung: Alle Listeneinträge markieren oder abwählen<\/h2>\n
\n
Alle Listeneinträge mit Strg + A selektieren<\/h2>\n
Private Sub <\/span>lstTabellen_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Select Case Shift\r\n Case <\/span>acCtrlMask\r\n Select Case KeyCode\r\n Case <\/span>vbKeyA\r\n For lngIndex = 0 To Me.lstTabellen.ListCount - 1\r\n Me.lstTabellen.Selected(lngIndex) = True<\/span>\r\n Next<\/span> lngIndex\r\n KeyCode = 0\r\n End Select<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n