Die Bordmittel von Access zum Herstellen oder Aktualisieren von Tabellenverknüpfungen zum SQL Server sind teilweise etwas umständlich zu bedienen und erfordern zwangsläufig den Einsatz von Data Source Names (DSN). Diese möchte man unter Umständen aber gar nicht nutzen, sondern einfach alle Informationen in die Verbindungszeichenfolge für die Tabelle schreiben. Natürlich kann man sich ein Set von Tabellen und Formularen zusammenstellen, mit denen man die Verbindungszeichenfolgen und Tabellenverknüpfungen verwaltet. Diese werden dann bei Bedarf der Datenbank hinzugefügt, deren Tabellenverknüpfungen man pflegen möchte. Aber manchmal möchte man einfach nur schnell mal etwas ausprobieren und dazu ist der Aufwand, die Datenbank um diese Tools zu erweitern, zu aufwendig. Wie wäre es also, wenn wir diese Tools einfach in ein Access-Add-In auslagern, mit dem wir unsere Verbindungszeichenfolgen und Verknüpfungen verwalten können? In diesem Beitrag schauen wir uns an, wie dies aussieht.<\/b><\/p>\n
Anlass zur Programmierung dieses Access-Add-Ins war der Umstand, dass ich immer wieder mal Testdatenbanken vom Kunden bekomme oder selbst Beispiele programmiere, deren Daten im SQL Server liegen und für die ich schnell eine Tabellenverknüpfung erstellen möchte. Das ist mir allerdings über den Assistenten zum Importieren oder Verknüpfen von Tabellen aus ODBC-Datenbanken etwas zu aufwendig (siehe Bild 1).<\/p>\n
![\"Herstellen](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_001.png\")
<\/p>\n
Bild 1: Herstellen einer Tabellenverknüpfung mit Bordmitteln<\/span><\/b><\/p>\n Ich möchte einmal die Verbindungszeichenfolge festlegen und dann so schnell wie möglich Tabellenverknüpfungen erstellen oder aktualisieren.<\/p>\n Das gelingt mit dem Access-Add-In, das wir in diesem Beitrag vorstellen, ganz einfach.<\/p>\n Dazu brauchen wir nur über den Ribbon-Befehl Datenbanktools|Add-Ins|Add-Ins|amvTableLinker <\/b>das Hauptformular unseres Add-Ins zu starten, das direkt nach dem Aufruf wie in Bild 2 aussieht. Hier finden wir nur wenige Elemente vor:<\/p>\n Bild 2: Hauptformular unseres Access-Add-Ins<\/span><\/b><\/p>\n Nach Auswahl einer Verbindung bzw. beim Öffnen des Formulars werden in dem Listenfeld zudem alle Namen der Tabellen markiert, deren Namen den Tabellenverknüpfungen in der Access-Datenbank entsprechen. Um alle aktuell vorhandenen Tabellenverknüpfungen zu aktualisieren, braucht man also nur die richtige Verbindungszeichenfolge auszuwählen und die Schaltfläche Tabellen verknüpfen <\/b>zu betätigen.<\/p>\n Schließlich finden wir oben rechts noch eine Schaltfläche mit drei Punkten, mit der wir den Dialog zum Verwalten der Verbindungszeichenfolgen öffnen können.<\/p>\n Dieser sieht wie in Bild 3 aus und erlaubt das Eintragen der wesentlichen Merkmale einer SQL Server-Verbindung. Hier finden wir folgende Eingabemöglichkeiten:<\/p>\n Bild 3: Verwalten von Verbindungszeichenfolgen<\/span><\/b><\/p>\n Die Schaltflächen erlauben die folgenden Funktionen:<\/p>\n Oben finden wir noch das Kombinationsfeld Schnellauswahl<\/b>. Hier werden alle verfügbaren Verbindungszeichenfolgen zur Auswahl angeboten.<\/p>\n Das Formular ist an die Tabelle tblVerbindungszeichenfolgen <\/b>gebunden (siehe Bild 4).<\/p>\n Bild 4: Die Tabelle tblVerbindungszeichenfolgen<\/span><\/b><\/p>\n Die Treiber, die über das Feld TreiberID <\/b>ausgewählt werden können, stammen aus der Tabelle tblTreiber<\/b> (siehe Bild 5).<\/p>\n Bild 5: Die Tabelle tblTreiber<\/span><\/b><\/p>\n Wenn wir den Dialog zum Verwalten der Verbindungszeichenfolge vom Formular zum Verknüpfen der Tabellen aus öffnen, wird dort direkt die Verbindungszeichenfolge angezeigt, die wir im aufrufenden Formular ausgewählt haben. Legen wir hier eine neue Verbindungszeichenfolge an oder wählen eine andere aus, wird diese nach dem Schließen des Dialogs automatisch im aufrufenden Formular selektiert.<\/p>\n Außerdem wollten wir noch eine Funktion hinzufügen, die dafür sorgt, dass beim Öffnen von amvTableLinker <\/b>auf irgendeine Weise gespeichert wird, welche Verbindungszeichenfolge zuletzt zum Verknüpfen von Tabellen verwendet wurde. Damit wollen wir die Voraussetzung schaffen, dass beim nächsten Öffnen des amvTableLinkers <\/b>in der gleichen Datenbank automatisch die richtige Verbindungszeichenfolge ausgewählt wird.<\/p>\n Dies haben wir realisiert, indem wir die Bezeichnung der Verbindungszeichenfolge in einer benutzerdefinierten Eigenschaft der Datenbank speichern.<\/p>\n Beim Öffnen von amvTableLinker <\/b>prüfen wir, ob es diese Eigenschaft gibt und falls ja, wählen wir die entsprechende Verbindungszeichenfolge aus.<\/p>\n Nun schauen wir uns an, wie wir die Formulare des Access-Add-Ins programmiert haben.<\/p>\n Wir beginnen mit dem Formular frmTabellenVerknuepfen<\/b>, das in der Entwurfsansicht wie in Bild 6 aussieht.<\/p>\n Bild 6: Entwurf des Formulars frmTabellenVerknuepfen<\/span><\/b><\/p>\n Beim Laden des Formulars wird die Prozedur aus Listing 1 ausgelöst. Diese deklariert gleich zwei Variablen des Typs DAO.Database<\/b>. Die erste namens db <\/b>soll das Database<\/b>-Objekt der Datenbank referenzieren, die das Add-In aufruft. Die zweite heißt dbc <\/b>und soll das Database<\/b>-Objekt der Add-In-Datenbank aufnehmen. Außerdem deklarieren wir Variablen für ein Property<\/b>– und ein Recordset<\/b>-Objekt.<\/p>\n Listing 1: Diese Prozedur wird beim Laden des Formulars frmTabellenVerknuepfen ausgelöst.<\/span><\/b><\/p>\n Die beiden verschiedenen Database<\/b>-Objekte füllen wir mit den Funktionen CurrentDb<\/b> (für die aufrufende Datenbank) und CodeDb <\/b>(für die Add-In-Datenbank).<\/p>\n Danach versuchen wir, die Eigenschaft Verbindung <\/b>der aufrufenden Datenbank zu referenzieren.<\/p>\n In dieser haben wir gegebenenfalls zuvor die Bezeichnung der Verbindungszeichenfolge gespeichert, mit der wir die Tabellenverknüpfungen hergestellt haben. Dies erledigen wir bei deaktivierter Fehlerbehandlung, weil es auch sein kann, dass diese Eigenschaft noch gar nicht vorliegt – und das würde wiederum einen Fehler auslösen, den wir somit umgehen.<\/p>\n Ob das Zuweisen an die prp<\/b>-Variable erfolgreich war, prüfen wir anschließend, indem es mit Is Nothing <\/b>vergleichen. In diesem Fall ist prp <\/b>vorhanden und wir lesen den Wert über die Eigenschaft Value <\/b>in die Variable strVerbindung <\/b>ein.<\/p>\n Damit können wir nun das Recordset rst <\/b>füllen, und zwar mit einen Recordset auf Basis der Tabelle tblVerbindungszeichenfolgen<\/b>. Für dieses legen wir fest, dass das Feld Bezeichnung <\/b>mit dem Wert aus strVerbindung <\/b>übereinstimmen soll. Das Recordset öffnen wir dabei mit der OpenRecordset<\/b>-Methode der CodeDb<\/b>-Datenbank aus dbc<\/b>.<\/p>\n Ist das Recordset anschließend nicht leer, stellen wir das Kombinationsfeld cboVerbindung <\/b>auf den Primärschlüsselwert des Recordsets ein und rufen die Prozedur cboVerbindung_AfterUpdate <\/b>auf, die auch nach der manuellen Auswahl einer Verbindungszeichenfolge ausgelöst wird.<\/p>\n Die oben erwähnte Prozedur cboVerbindung_AfterUpdate <\/b>soll nach dem Selektieren eines Eintrags dieses Kombinationsfeldes alle Tabellen der Datenbank anzeigen, die in dieser Verbindungszeichenfolge referenziert wird.<\/p>\n Die Prozedur sehen wir in Listing 2. Sie verwendet ebenfalls zwei Database<\/b>-Objektvariablen. Außerdem deklariert sie eine QueryDef<\/b>-Variable und eine Recordset<\/b>-Variable. Daneben benötigen wir eine String<\/b>-Variable für die Verbindungszeichenfolge sowie eine Variant<\/b>-Variable zum Durchlaufen der Listenfeld-Einträge.<\/p>\n Listing 2: Anzeigen aller Tabellen der gewählten Verbindungszeichenfolge<\/span><\/b><\/p>\n Nach dem Füllen der Database<\/b>-Variablen ermitteln wir die eventuell festgelegten Daten für die Anmeldung an die Datenbank und speichern diese in den Variablen strBenutzername <\/b>und strKennwort<\/b>, die als öffentliche Variablen im Modul mdlSQLServer <\/b>deklariert sind. Hier würden wir normalerweise der Einfachheit halber DLookup<\/b>-Funktionen nutzen. Aber damit würden wir immer auf die Datenbank zugreifen, die das Add-In aufgerufen hat. Daher müssen wir hier die OpenRecordset<\/b>-Methode für das mit der Variablen dbc <\/b>referenzierte Database<\/b>-Objekt der Add-In-Datenbank verwenden.<\/p>\n Anschließend ruft die Prozedur die Funktion VerbindungTesten <\/b>auf und übergibt den Primärschlüsselwert der zu untersuchenden Verbindungszeichenfolge sowie die beiden Variablen lngErrorNumber <\/b>und strErrorDescription <\/b>für eventuelle Rückmeldungen über Fehler und erwartet für den Parameter strVerbindungszeichenfolge <\/b>die entsprechende Zeichenfolge zurück. Diese Funktion beschreiben wir weiter unten.<\/p>\n War der Aufruf erfolgreich, erstellt die Prozedur mit der CreateQueryDef<\/b>-Methode ein neues, temporäres QueryDef<\/b>-Objekt. Das erreichen wir, indem wir für den Parameter Name<\/b> eine leere Zeichenkette übergeben.<\/p>\n Dieser weisen wir nun über die Eigenschaft SQL <\/b>eine SQL-Anweisung zu, die alle Tabellennamen aus der Systemtabelle Information_Schema.Table <\/b>holt, deren Typ BASE TABLE <\/b>oder VIEW <\/b>lautet. Als Verbindungszeichenfolge geben wir für die Eigenschaft Connect <\/b>den Wert aus strVerbindungszeichenfolge <\/b>an. Schließlich stellen wir die Eigenschaft ReturnsRecords <\/b>auf True <\/b>ein, damit die Abfrage Datensätze zurückliefert (im Gegensatz zu einer Aktionsabfrage).<\/p>\n Das mit der OpenRecordset<\/b>-Methode auf Basis des QueryDef<\/b>-Objekts aus der Variablen qdf <\/b>geöffnete Recordset weisen wir direkt der gleichnamigen Eigenschaft des Listenfeldes lstTabellen <\/b>zu.<\/p>\n Außerdem erstellen wir ein Recordset namens rstTables<\/b>, das wir mit Datensätzen der Systemtabelle MSysObjects <\/b>der aufrufenden Access-Datenbank füllen. Diese beschränken wir auf alle Datensätze, deren Eigenschaft Connect <\/b>nicht leer ist – was in der Regel die per ODBC eingebundenen Tabellen eindeutig identifiziert.<\/p>\n Dieses Recordset durchlaufen wir in einer Do While<\/b>-Schleife. Innerhalb der Schleife durchlaufen wir in einer For…Each<\/b>-Schleife alle Elemente des Listenfeldes lstTabellen<\/b>. Dabei vergleichen wir jeweils den Eintrag des Listenfeldes mit dem Namen der aktuellen Tabelle aus dem Recordset.<\/p>\n Sind beide gleich, bedeutet dies, dass die Tabelle aus dem SQL Server bereits in Form einer Tabellenverknüpfung in der aufrufenden Datenbank hinterlegt ist. In diesem Fall soll dieser Eintrag im Listenfeld selektiert werden, was wir durch Einstellen der Eigenschaft Selected <\/b>für das Element var <\/b>auf den Wert True <\/b>erledigen.<\/p>\n Auf diese Weise füllen wir das Listenfeld lstTabellen <\/b>und markieren gleichzeitig alle bereits verknüpften Tabellen. Dies gelingt übrigens nur, wenn der Name der Tabelle im SQL Server mit dem Namen der Verknüpfung übereinstimmt.<\/p>\n Damit wir Tabellenverknüpfungen herstellen können, benötigen wir eine funktionsfähige Verbindungszeichenfolge. Diese prüfen wir zuvor mit der Funktion VerbindungTesten<\/b>, die wir in Listing 3 finden. Sie nimmt den Primärschlüsselwert des Eintrags der Tabelle tblVerbindungszeichenfolgen <\/b>für die zu untersuchende Verbindungszeichenfolge entgegen. Außerdem enthält sie einen zweiten Parameter, mit dem die ermittelte Verbindungszeichenfolge zurückgegeben werden kann. Daneben hat die Funktion den Datentyp Boolean <\/b>und liefert mit dem Rückgabewert die Information, ob die Verbindungszeichenfolge erfolgreich getestet werden konnte.<\/p>\n Listing 3: Testen der Verbindung für die Verbindungszeichenfolge<\/span><\/b><\/p>\n Die Prozedur ermittelt auf Basis des Feldes TrustedConnection<\/b>, ob es sich um eine Verbindungszeichenfolge für den Zugriff mit Windows-Authentifizierung oder mit SQL Server-Authentifizierung handelt.<\/p>\n Wenn Benutzername und\/oder Kennwort leer sind und die SQL Server-Authentifizierung verwendet werden soll, benötigen wir vermutlich noch die Anmeldedaten, wozu die Funktion LogindatenErmitteln <\/b>mit der Verbindungszeichenfolge als Parameter aufgerufen wird (mehr dazu weiter unten). Liefert diese Funktion wiederum den Wert False<\/b> zurück, wird der Test erfolglos abgebrochen.<\/p>\n Anderenfalls geht es mit den Daten, die durch diese Funktion in die Variablen strBenutzername <\/b>und strKennwort <\/b>geschrieben wurden, weiter.<\/p>\n Die Hilfsfunktion VerbindungszeichenfolgeNachID <\/b>(siehe unten) erhält den Primärschlüsselwert der Verbindungszeichenfolge und soll den entsprechenden String ermitteln. Dieser landet anschließend in der Variablen strVerbindungszeichenfolge<\/b>.<\/p>\n Damit rufen wir bei deaktivierter Fehlerbehandlung eine weitere Funktion namens VerbindungHerstellen <\/b>auf und übergeben dieser die Verbindungszeichenfolge.<\/p>\n Das Ergebnis landet in der Variablen bolVerbindungHergestellt<\/b>.<\/p>\n Enthält diese nun den Wert False<\/b>, wird auch False <\/b>als Ergebnis der Funktion VerbindungTesten <\/b>zurückgegeben und die Funktion mit Exit Function <\/b>verlassen. Anderenfalls wird der Wert True <\/b>als Ergebnis von VerbindungTesten <\/b>zurückgeliefert.<\/p>\n Die Funktion LogindatenErmitteln <\/b>öffnet ein Formular, das in der Entwurfsansicht wie in Bild 7 aussieht. Sie öffnet das Formular als modalen Dialog und übergibt dieser die ID der zu verwendenden Verbindungszeichenfolgt als Öffnungsargument.<\/p>\n Bild 7: Entwurf des Formulars frmLogin<\/span><\/b><\/p>\n Nachdem das Formular mit der OK<\/b>-Schaltfläche ausgeblendet wurde, läuft die aufrufende Prozedur weiter und liest den Benutzernamen und das Kennwort aus den dafür vorgesehenen Textfeldern des Formulars in die Variablen strBenutzername <\/b>und strKennwort <\/b>ein. Dann schließt sie das Formular und stellt den Rückgabewert der Funktion auf True <\/b>ein:<\/p>\n Das Formular löst beim Öffnen die Prozedur aus Listing 4 aus. Diese liest aus dem Öffnungsargument die zu verwendende Verbindungszeichenfolge ein und speichert sie in lngVerbindungszeichenfolgeID<\/b>. Hat diese den Wert 0<\/b>, verwendet die Prozedur die Standardverbindungszeichenfolge, die mit der Funktion StandardverbindungszeichenfolgeErmitteln <\/b>eingelesen wird.<\/p>\n Listing 4: Einstellen des Loginformulars beim Öffnen<\/span><\/b><\/p>\n Mit diesem Wert liest die Prozedur die in der Tabelle tblVerbindungszeichenfolgen <\/b>gespeicherten Daten ein und trägt diese in die beiden Textfelder txtBenutzername <\/b>und txtKennwort <\/b>ein.<\/p>\n Die weiter oben bereits erwähnte Funktion VerbindungszeichenfolgeNachID <\/b>stellt die Verbindungszeichenfolge für den mit der Variablen lngVerbindungszeichenfolgeID<\/b> angegebenen Wert zusammen (siehe Listing 5). Sie erstellt ein Recordset mit dem Datensatz der Tabelle tblVerbindungszeichenfolgen<\/b>, der im Primärschlüsselfeld den mit dem Parameter übergebenen Wert enthält. Hier verwenden wir auch wieder CodeDb<\/b>, um das Database<\/b>-Objekt der Add-In-Datenbank zu erfassen.<\/p>\nTabellen per Add-In verknüpfen<\/h2>\n
![\"Hauptformular](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_002.png\")
<\/p>\n\n
Verbindungszeichenfolgen verwalten<\/h2>\n
![\"Verwalten](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_003.png\")
<\/p>\n\n
\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_006.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_007.png\")
<\/p>\nAutomatische Übernahme der Verbindungszeichenfolge<\/h2>\n
Datenbank merkt sich die Verbindungszeichenfolge<\/h2>\n
Programmieren der Formulare für amvTableLinker<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strVerbindung As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = db.Properties(\"Verbindung\")\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> prp Is Nothing Then<\/span>\r\n strVerbindung = prp.Value\r\n Set<\/span> rst = dbc.OpenRecordset(\"SELECT * FROM tblVerbindungszeichenfolgen WHERE Bezeichnung = ''\" _\r\n & strVerbindung & \"''\", dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n Me.cboVerbindung = rst!VerbindungszeichenfolgeID\r\n Call<\/span> cboVerbindung_AfterUpdate\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAnzeigen der Tabellen einer Verbindungszeichenfolge<\/h2>\n
Private Sub <\/span>cboVerbindung_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rstTables As <\/span>DAO.Recordset\r\n Dim <\/span>strVerbindungszeichenfolge As String<\/span>\r\n Dim <\/span>lngErrorNumber As Long<\/span>\r\n Dim <\/span>strErrorDescription As String<\/span>\r\n Dim <\/span>var As Variant<\/span>\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> db = CurrentDb\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_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE IN (''BASE TABLE'', ''VIEW'') \" _\r\n & \"ORDER BY TABLE_TYPE, TABLE_NAME\"\r\n .Connect = strVerbindungszeichenfolge\r\n .ReturnsRecords = True<\/span>\r\n End With<\/span>\r\n Set<\/span> Me!lstTabellen.Recordset = qdf.OpenRecordset\r\n Set<\/span> rstTables = db.OpenRecordset(\"SELECT Name FROM MSysObjects WHERE NOT Connect IS NULL\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstTables.EOF\r\n For var = 0 To Me.lstTabellen.ListCount - 1\r\n If <\/span>Me!lstTabellen.ItemData(var) = rstTables!Name Then<\/span>\r\n Me.lstTabellen.Selected(var) = True<\/span>\r\n End If<\/span>\r\n Next<\/span> var\r\n rstTables.MoveNext<\/span>\r\n Loop<\/span>\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>\nTesten der Verbindung<\/h2>\n
Public Function <\/span>VerbindungTesten(lngVerbindungszeichenfolgeID As Long<\/span>, _\r\n Optional<\/span> strVerbindungszeichenfolge As String<\/span>, Optional<\/span> lngErrorNumber As Long<\/span>, _\r\n Optional<\/span> strErrorDescription As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>dbc As <\/span>dao.Database\r\n Dim <\/span>bolTrustedConnection As Boolean<\/span>\r\n Dim <\/span>bolVerbindungHergestellt As Boolean<\/span>\r\n Set<\/span> dbc = CodeDb\r\n bolTrustedConnection = dbc.OpenRecordset(\"SELECT TrustedConnection FROM tblVerbindungszeichenfolgen \" _\r\n & \"WHERE VerbindungszeichenfolgeID = \" & lngVerbindungszeichenfolgeID).Fields(0)\r\n If <\/span>(Len<\/span>(strBenutzername) * Len<\/span>(strKennwort) = 0) And Not<\/span> bolTrustedConnection Then<\/span>\r\n If <\/span>LogindatenErmitteln(lngVerbindungszeichenfolgeID) = False<\/span> Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n strVerbindungszeichenfolge = VerbindungszeichenfolgeNachID(lngVerbindungszeichenfolgeID)\r\n On Error Resume Next<\/span>\r\n bolVerbindungHergestellt = VerbindungHerstellen(strVerbindungszeichenfolge, lngErrorNumber, strErrorDescription)\r\n If <\/span>bolVerbindungHergestellt = False<\/span> Then<\/span>\r\n VerbindungTesten = False<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n VerbindungTesten = True<\/span>\r\nEnd Function<\/span><\/pre>\nErmitteln der Login-Daten per Formular<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_02\/pic_1540_005.png\")
<\/p>\nPublic Function <\/span>LogindatenErmitteln( _\r\n lngVerbindungszeichenfolgeID) As Boolean<\/span>\r\n DoCmd.OpenForm \"frmLogin\", WindowMode:=acDialog, _\r\n OpenArgs:=lngVerbindungszeichenfolgeID\r\n If <\/span>IstFormularGeoeffnet(\"frmLogin\") Then<\/span>\r\n strBenutzername = Forms!frmLogin!txtBenutzername\r\n strKennwort = Forms!frmLogin!txtKennwort\r\n DoCmd.Close acForm, \"frmLogin\"\r\n LogindatenErmitteln = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>strVerbindungszeichenfolge As String<\/span>\r\n Set<\/span> dbc = CodeDb\r\n lngVerbindungszeichenfolgeID = Nz(Me.OpenArgs)\r\n If <\/span>lngVerbindungszeichenfolgeID = 0 Then<\/span>\r\n lngVerbindungszeichenfolgeID = StandardverbindungszeichenfolgeID\r\n End If<\/span>\r\n Me!txtBenutzername = Nz(dbc.OpenRecordset(\"SELECT Benutzername FROM tblVerbindungszeichenfolgen \" _\r\n & \"WHERE VerbindungszeichenfolgeID = \" & lngVerbindungszeichenfolgeID).Fields(0), strBenutzername)\r\n Me!txtKennwort = Nz(dbc.OpenRecordset(\"SELECT Kennwort FROM tblVerbindungszeichenfolgen \" _\r\n & \"WHERE VerbindungszeichenfolgeID = \" & lngVerbindungszeichenfolgeID).Fields(0), strKennwort)\r\nEnd Sub<\/span><\/pre>\nVerbindungszeichenfolge aus der Tabelle zusammenstellen<\/h2>\n
Public Function <\/span>VerbindungszeichenfolgeNachID(lngVerbindungszeichenfolgeID As Long<\/span>) As String<\/span>\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>strTreiber As String<\/span>\r\n Dim <\/span>strServer As String<\/span>\r\n