<\/p>\n
Wenn Sie von Access aus auf die Daten einer SQL Server-Datenbank (und neuerdings auch auf LocalDB-Datenbanken) zugreifen wollen, müssen Sie mit Bordmitteln arbeiten, die häufig nicht zufriedenstellend sind. Wir haben einen Satz von Tools entwickelt, mit denen Sie eine Reihe von Aufgaben sehr schnell erledigen können: Verbindungen definieren, Tabellen verknüpfen und SQL-Abfragen direkt an den Server schicken. Dieser Beitrag zeigt, wie Sie mithilfe eines Teils dieser Tools per VBA auf SQL Server und Co. zugreifen.<\/b><\/p>\n
Mal eben eine Auswahlabfrage oder Pass-Through-Abfrage per VBA an den SQL Server absetzen – das wäre doch eine praktische Sache. <\/p>\n
Sie werden an verschiedenen Stellen per VBA auf die Tabellen der SQL Server-Datenbank zugreifen müssen – sei es, um eine ODBC-Verknüpfung herzustellen oder zu aktualisieren, das Ergebnis einer gespeicherten Abfrage abzurufen oder eine solche auszuführen oder auch um ein Recordset auf Basis einer gespeicherten Prozedur einem Formular oder einem Steuerelement zuzuweisen. Alles, was Sie wissen müssen, um dies zu erledigen, erfahren Sie in diesem Beitrag.<\/p>\n
Als Beispieldatenbank verwenden wir die Datenbank Suedsturm.mdf<\/b>, die Sie wie im Beitrag Access und LocalDB <\/b>(www.access-im-unternehmen.de\/1057<\/b>) beschrieben nutzen können. Alternativ können Sie diese natürlich auch per SQL Server nutzen. Die Tools, mit denen Sie die in diesem Beitrag verwendeten Verbindungszeichenfolgen zusammenstellen können, stellen wir im Beitrag SQL Server-Tools <\/b>(www.access-im-unternehmen.de\/1061<\/b>) in der nächsten Ausgabe vor.<\/p>\nVerbindungszeichenfolgen<\/h2>\n
Als Erstes benötigen Sie Zugriff auf die SQL Server-Datenbank. Voraussetzung dafür ist eine geeignete Verbindungszeichenfolge. Bei den Verbindungszeichenfolgen gibt es verschiedene Ansätze.<\/p>\n
Sie sind relativ flexibel, wenn Sie die notwendigen Informationen in einer lokalen Tabelle im Access-Frontend speichern und von Access aus per VBA darauf zugreifen, um Verbindungszeichen-fol-gen daraus zu erstellen. Alternativ können Sie Verbindungszeichenfolgen in einer DSN-Datei oder als System-DSN in der Registry speichern – wir gehen an dieser Stelle jedoch auf die Variante der tabellenbasierten Verbindungszeichenfolge ein. Die notwendigen Daten speichern wir in den Beispieldatenbanken in einer Tabelle namens tblVerbindungszeichenfolgen<\/b> (s. Bild 1). Diese Tabelle haben Sie bereits im Beitrag RDBMS-Tools: Verbindungen verwalten <\/b>(www.access-im-unternehmen.de\/976<\/b>) kennengelernt.<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2016_05\/pic_1054_001.png\")
<\/p>\n
Bild 1: Entwurf der Tabelle zum Speichern der Verbindungszeichenfolgen<\/span><\/b><\/p>\n Außerdem benötigen wir eine Tabelle namens tblTreiber<\/b>, welche die Daten der gängigen Treiber enthält (s. Bild 2). Die Tabelle tblVerbindungszeichenfolgen <\/b>ist über das Fremdschlüsselfeld TreiberID <\/b>mit der Tabelle tblTreiber <\/b>verknüpft.<\/p>\n Bild 2: Entwurf der Tabelle zum Speichern der Treiber<\/span><\/b><\/p>\n In der Beispielanwendung verwenden wir die Prozedur aus Listing 1, um eine Verbindungszeichen-folge aus den Daten der Tabelle tblVerbindungszeichenfolgen <\/b>zu ermitteln.<\/p>\n Listing 1: Ermitteln einer Verbindungszeichenfolge aus der Tabelle tblVerbindungszeichenfolgen<\/span><\/b><\/p>\n Die Funktion arbeitet direkt mit der Tabelle tblVerbindungszeichenfolgen<\/b>, in der die Verbindungsprarameter gespeichert sind. Dabei liest sie den Datensatz der Tabelle tblVerbindungszeichenfolgen <\/b>ein, dessen Primär-schlüs-selwert dem mit dem Parameter lngVerbindungszeichenfolgeID <\/b>übergebenen Wert entspricht. Der zweite Parameter der Funktion heißt bolZugangsdatenAusVariablen <\/b>und legt fest, ob auf jeden Fall die Zugangsdaten aus den beiden Variablen strBenutzername <\/b>und strKennwort <\/b>verwendet werden sollen. Dies benötigen wir für einen Aufruf aus der später erläuterten Funktion VerbindungTesten<\/b>, die gegebenenfalls die Zugangsdaten vorher per Dialog abfragt und diese aus Sicherheitsgründen nur in den beiden Variablen strBenutzername <\/b>und strKennwort <\/b>speichert, aber nicht in der Tabelle.<\/p>\n Es gibt zwei Variablen namens strBenutzername<\/b> und strKennwort<\/b>, die speziell für den Einsatz mit der SQL Server-Authentifizierung vorgesehen sind (oder auch für die Anmeldung an einem anderen SQL-Server-System wie MySQL mit der Anforderung von Benutzerdaten). In diesem Fall muss die Access-Anwendung die Benutzerdaten bereitstellen, um eine Verbindung herzustellen. Diese sollen aber nicht in der Datenbank gespeichert werden, da die Daten sonst für jedermann zugänglich wären. Die Variablen sollen zuvor per Formular vom Benutzer einmalig pro Sitzung abgefragt und in entsprechenden Variablen gespeichert werden, die wie folgt deklariert werden:<\/p>\n Die Funktion VerbindungszeichenfolgeNachID<\/b> prüft dann, ob die Tabelle eigene Werte für Benutzername und Kennwort enthält, und trägt diese gegebenenfalls in die Variablen strBenutzername <\/b>und strKennwort <\/b>ein. Danach setzt die Funktion die einzelnen Elemente dann zu einer Verbindungszeichen-folge zu-sammen. Abhängig davon, ob die Windows-Authentifizierung oder SQL Server-Authentifizie-rung gewählt wurde, erhält die Verbindungszeichenfolge das Name-Wert-Paar Trusted_Con-nec-tion=Yes<\/b>, anderenfalls die Benutzerdaten in der Form UID= Aus dem obersten Eintrag der Tabelle tblVerbindungszeichenfolgen<\/b> aus Bild 3 würde die Funktion mit dem Wert 9 <\/b>als Parameter etwa folgendes Ergebnis liefern:<\/p>\n Bild 3: Tabelle mit den Daten einer Verbindungszeichenfolge<\/span><\/b><\/p>\n In der Tabelle tblVerbindungszeichenfolgen <\/b>finden Sie auch ein Boolean<\/b>-Feld namens Aktiv<\/b>. Dieses legt fest, welche Verbindungszeichenfolge für die aktuelle Datenbank standardmäßig verwendet werden soll.<\/p>\n Der generelle Vorteil des Speicherns der Daten für die Verbindungszeichenfolge in einer Tabelle ist, dass Sie diese bei Bedarf einfach ändern können. Der zweite Vorteil ist: Sie können auch mehrere Verbindungszeichenfolgen angeben und zwischen diesen Zeichenfolgen wechseln. Genau dies ermöglicht das Feld Aktiv<\/b>.<\/p>\n Während Sie nun mit der Funktion VerbindungszeichenfolgeNachID <\/b>immer die ID der aktuell benötigten Verbindungszeichenfolge angeben müssen, ermöglicht die Funktion Standardverbindungszeichenfolge<\/b>, direkt die als Aktiv <\/b>markierte Verbindungszeichenfolge zu ermitteln (s. Listing 2).<\/p>\n <\/p>\n Listing 2: Ermitteln der Standardverbindungszeichenfolge aus der Tabelle tblVerbindungszeichenfolgen<\/span><\/b><\/p>\n Die Funktion ermittelt per DLookup<\/b>-Funktion den ersten Eintrag der Tabelle tblVerbindungszei-chen-folgen<\/b>, dessen Feld Aktiv <\/b>den Wert True <\/b>aufweist. Dieser wird dann der Funktion Ver-bin-dungs-zeichenfolgeNachID <\/b>übergeben, um die entsprechende Verbindungszeichenfolge zu ermitteln. Sollte keine Verbindungszeichenfolge als aktiv markiert sein, erscheint eine entsprechende Mel-dung.<\/p>\n Wenn hingegen mehr als eine Verbindungszeichenfolge den Wert True <\/b>im Feld Aktiv <\/b>enthält, liefert die Funktion die Verbindungszeichenfolge für den ersten markierten Eintrag zurück.<\/p>\n Andere Routinen erwarten gegebenenfalls die ID der zu verwendenden Verbindungszeichenfolge. Wenn Sie nicht explizit einen Wert des Feldes VerbindungszeichenfolgeID<\/b> der Tabelle tblVerbindungszeichenfolgen <\/b>übergeben möchten, können Sie mit der Funktion aus Listing 3 den Wert für den aktiven Datensatz ermitteln.<\/p>\n Listing 3: Ermitteln der ID der Standardverbindungszeichenfolge aus der Tabelle tblVerbindungszeichenfolgen<\/span><\/b><\/p>\n Auch diese Funktion liefert eine Meldung, wenn keine aktive Verbindungszeichenfolge gefunden werden konnte.<\/p>\n Aufbauend auf den vorherigen Funktionen wollen wir nun eine weitere Funktion einführen, die prüft, ob eine Verbindungszeichenfolge funktioniert. Diese heißt VerbindungTesten<\/b> (s. Listing 4). Die Funktion erledigt gleich drei Aufgaben:<\/p>\n Listing 4: Testen einer per VerbindungszeichenfolgeID angegebenen Verbindungszeichenfolge<\/span><\/b><\/p>\n Die Funktion erwartet folgende Parameter:<\/p>\n Nun hat diese Funktion nicht nur die Aufgabe, einfach nur Verbindungen zu testen, sondern spe-ziell im Falle von Verbindungen auf Basis der SQL Server-Authentifizierung gleich noch eventuell fehlende Daten wie Benutzername <\/b>oder Kennwort <\/b>abzufragen.<\/p>\n Diese sollen, sofern ermittelt, natürlich nicht etwa in die Tabelle tblVerbindungszeichenfolgen <\/b>eingetragen werden, wo sie leicht abzugreifen wären, sondern nur in globalen Variablen, die wie weiter oben bereits erläutert deklariert werden.<\/p>\n Die Funktion deklariert zunächst zwei Variable. bolTrustedConnection <\/b>ermittelt, ob eine Ver-bin-dung mit Windows-Authentifizierung aufgebaut werden soll, bolVerbindungHergestellt <\/b>nimmt das Ergebnis einer Funktion zum Herstellen der Verbindung auf.<\/p>\n bolTrustedConnection <\/b>wird gleich zu Beginn mit dem entsprechenden Wert der Tabelle tblVerbindungszeichenfolgen<\/b> gefüllt.<\/p>\n Anschließend prüft die Funktion, ob die Felder Benutzername <\/b>und Kennwort <\/b>des betroffenen Datensatzes der Tabelle tblVerbindungszeichenfolgen<\/b> Werte enthalten und trägt diese gegebenenfalls für die beiden Variablen strBenutzername <\/b>und strKennwort <\/b>ein. Sollten strBenutzername <\/b>und\/oder strKennwort <\/b>danach immer noch leer sein, ruft die Routine eine weitere Funktion auf, die einen Dialog namens frmLogin<\/b> zum Eingeben der fehlenden Daten anzeigt – mehr dazu weiter unten. Liefert dieser Dialog keine Anmeldedaten, weil der Benutzer diesen abbricht, wird die Funktion beendet und liefert den Wert False <\/b>zurück. In diesem Fall wird die Funktion auch gleich verlassen, wobei als Ergebnis der Standardwert False <\/b>zurückgegeben wird.<\/p>\n Nun ermittelt die Funktion VerbindungszeichenfolgeNachID <\/b>eine Verbindungszeichenfolge, und zwar auf Basis der ID der zu verwendenden Verbindung aus der Tabelle tblVerbindungszeichenfolgen<\/b> und – sofern SQL-Server-Authentifizierung erforderlich ist – mithilfe der Werte aus strBenutzername <\/b>und strKennwort<\/b> beziehungsweise aus den entsprechenden Feldern der Tabelle tblVerbindungszeichenfolgen<\/b>.<\/p>\n Dann folgt der Aufruf der Funktion VerbindungHerstellen<\/b>. Diese prüft, ob mit dieser Verbindungszeichenfolge ein Zugriff auf die Datenbank möglich ist, das Ergebnis landet in der Variablen bolVerbindungHergestellt<\/b> (die Funktion VerbindungHerstellen <\/b>schauen wir uns weiter unten an):<\/p>\n Die folgende Do While<\/b>-Schleife wird überhaupt nur durchlaufen, wenn noch keine Verbindung mit den erfassten Daten hergestellt werden konnte, beispielsweise weil die Zugangsdaten nicht korrekt eingegeben wurden. Sollte die Verbindung hergestellt worden sein, ist bolVerbindungHergestellt <\/b>gleich True <\/b>und die Abbruchbedingung direkt erfüllt und die Funktion wird mit dem Rückgabewert True <\/b>beendet.<\/p>\n Sollte der Benutzer jedoch noch nicht die korrekten Daten eingegeben haben, beginnt der Durchlauf der Do While<\/b>-Schleife. Diese gibt zunächst eine Meldung aus, dass der erste Versuch nicht gelungen ist. Dann prüft die Funktion, ob es sich um Windows-Authentifizierung oder SQL Server-Authentifizierung handelt. Im ersteren Fall lässt sich das Problem an dieser Stelle nicht beheben, die Funktion endet mit dem Rückgabewert False<\/b>. Bei SQL Server-Authentifizierung erscheint ebenfalls die Meldung, der Benutzer kann jedoch den Benutzernamen korrigieren.<\/p>\n Beim Verbinden können beispielsweise die folgenden Probleme auftreten:<\/p>\n In den meisten Fällen liefert der Treiber jedoch nur einen wagen Hinweis auf den Fehler. Eine genaue Ermittlung des Problems würde hier den Rahmen sprengen.<\/p>\n Die Funktion LoginDatenErmitteln<\/b>, die von der Funktion VerbindungTesten <\/b>aufgerufen wird, wenn weder die Variablen strBenutzername <\/b>und strKennwort <\/b>noch die entsprechenden Felder der Tabelle tblVerbindungszeichenfolgen <\/b>einen Zugriff ermöglichen, öffnet das Formular frmLogin<\/b> und übergibt als öffnungs-ar-gu-ment die ID der zu verwendenden Verbindungszeichenfolge (s. Listing 5). Der Code dieser Funktion wird nach dem öffnen des Formulars so lange angehalten, bis der Benutzer das Formular mit der Schaltfläche OK <\/b>unsichtbar macht oder es mit Abbrechen <\/b>schließt. Danach prüft die Funktion, ob das Formular noch geöffnet, aber unsichtbar ist, und liest in diesem Fall die eingegebenen Anmeldedaten in die beiden Variablen strBenutzername <\/b>und strKennwort <\/b>ein. Schließlich schließt sie das Formular endgültig und liefert den Wert True <\/b>als Rückgabewert.<\/p>\n Listing 5: Funktion zum öffnen und Ermitteln der Zugangsdaten für eine Verbindung mittels Dialog<\/span><\/b><\/p>\n Das Formular sieht im Entwurf wie in Bild 4 aus.<\/p>\n Bild 4: Das Login-Formular in der Entwurfsansicht<\/span><\/b><\/p>\n Damit das Formular beim öffnen gleich die in der Tabelle tblVerbindungszeichenfolgen<\/b> enthaltenen Anmeldedaten in den beiden Textfeldern anzeigt, löst es die Ereignisprozedur aus Listing 6 aus.<\/p>\n Listing 6: Ereignisprozedur, die beim öffnen des Login-Formulars ausgelöst wird<\/span><\/b><\/p>\n Die Prozedur schreibt die per öffnungsargument übergebene VerbindungszeichenfolgeID<\/b> in eine entsprechende Variable. Sollte lngVerbindungszeichenfolgeID <\/b>den Wert 0 <\/b>erhalten, weil kein Wert mit dem öffnungsargument übergeben wurde, ermittelt die Prozedur mit der Funktion StandardverbindungszeichenfolgeID <\/b>die ID der als aktiv markierten Verbindungszeichenfolge. Die ID wird nachfolgend im Kriterium zweier DLookup<\/b>-Aufrufe eingesetzt, um Benutzername und Kennwort des entsprechenden Eintrags der Tabelle tblVerbindungs-zei-chen-folgen <\/b>zu ermitteln. Sollten diese Einträge leer sein, verwendet die Prozedur die in den Variablen strBenutzername <\/b>und strKennwort <\/b>gespeicherten Zugangsdaten.<\/p>\n Die Funktion VerbindungHerstellen <\/b>erwartet die Verbindungszeichenfolge als Parameter. Sie erstellt ein neues temporäres QueryDef<\/b>-Objekt und weist diesem die Verbindungszeichenfolge sowie eine Dummy-Abfrage (hier SELECT 1 AS Test<\/b>) zu (s. Listing 7). Außerdem erhält die Eigenschaft ReturnsRecords <\/b>den Wert True<\/b>. Nach einer temporären Deaktivierung der eingebauten Fehlerbehandlung versucht sie dann, die Abfrage mit der OpenRecordset<\/b>-Methode des QueryDef<\/b>-Objekts auszuführen. Sollte dies keinen Fehler liefern, war der Verbindungsaufbau erfolgreich und die Funktion liefert den Wert True <\/b>zurück.<\/p>\n Listing 7: Diese Funktion baut eine testweise Verbindung zur SQL Server-Datenbank auf.<\/span><\/b><\/p>\n Die Funktion VerbindungTesten<\/b> prüft nicht nur, ob der Zugriff auf die Tabellen der SQL Server-Datenbank gelingt, sondern liefert auch gleich noch die korrekte Verbindungszeichenfolge zurück. Mit dieser Zeichenfolge im Gepäck können Sie gleich einige wichtige Schritte durchführen, die Probleme mit dem Zugriff auf eingebundene Objekte wie per ODCB verknüpfte Tabellen oder Pass-Through-Abfragen verhindern.<\/p>\n Im Falle der verknüpften Tabellen treten Probleme auf, wenn Sie diese unter Windows-Au-then-ti-fizierung eingebunden haben und der Kunde dann per SQL Server-Authentifizierung darauf zugreifen will – dies zeigt wiederum den eingebauten Anmeldedialog an. Andersherum verhält es sich ebenso.<\/p>\n Steht also ein Wechsel zwischen den beiden Authentifizierungsarten an, ist ein erneutes Ein-bin-den aller Tabellen nötig. Haben Sie die Tabellen unter SQL Server-Au-then-ti-fi-zie-rung eingebunden und melden sich dann unter einem anderen SQL Server-Account an, greifen Sie automatisch unter diesem Account auf die Tabellen zu.<\/p>\n Den Unterschied machen die in der Systemtabelle MSysObjects <\/b>gespeicherten Verbindungseigenschaften.<\/p>\n Enthalten diese den Ausdruck Trusted_Connection=Yes<\/b>, können Sie mit Windows-Au-then-ti-fi-zierung darauf zugreifen, sonst nur mit SQL Server-Authentifizierung. Alternativ müssen Sie die Ver-knüpfungen aktualisieren. Dies ist dank der Funktion VerknuepfungErstellen <\/b>aus dem Beitrag Tabellen per VBA verknüpfen<\/b> (www.access-im-unternehmen.de\/974<\/b>) zwar auch kein Problem, je nach Anzahl der eingebundenen Ta-bel-len kann dieser Vor-gang jedoch entsprechend Zeit beanspruchen.<\/p>\n Pass-Through-Abfragen sollten Sie grundsätzlich beim Starten der Anwendung mit der aktuellen Verbindungszeichenfolge ausstatten, bei SQL Server-Authentifizierung allerdings ohne Angabe des Kennwortes – dieses könnte sonst einfach ausgelesen werden. Dies beschreiben wir im Beitrag RDBMS per VBA: Daten abfragen <\/b>(www.access-im-unternehmen.de\/1062<\/b>) in der nächsten Ausgabe.<\/p>\n Dieser Beitrag hat Funktionen geliefert, mit denen Sie Verbindungen zum SQL Server und anderen RDBMS aufbauen können. In weiteren Teilen dieser Beitragsreihe erfahren Sie, wie Sie auf Basis der hier vorgestellten Grundlagen Pass-Through-Abfragen erstellen, Tabellen verknüpfen, Recordsets füllen oder Aktionsabfragen ausführen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n RDBMSPerVBA_Verbindungen.accdb<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2016_05\/pic_1054_002.png\")
<\/p>\nPublic Function <\/span>VerbindungszeichenfolgeNachID(lngVerbindungszeichenfolgeID As Long<\/span>, _\r\n Optional<\/span> bolZugangsdatenAusVariablen As Boolean<\/span>) As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strTemp As String<\/span>, strTreiber As String<\/span>, strServer As String<\/span>, strDatenbank As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVerbindungszeichenfolgen WHERE VerbindungszeichenfolgeID = \" _\r\n & lngVerbindungszeichenfolgeID)\r\n strTreiber = DLookup(\"Treiber\", \"tblTreiber\", \"TreiberID = \" & rst!TreiberID)\r\n strServer = rst!Server\r\n strDatenbank = rst!Datenbank\r\n strTemp = \"ODBC;DRIVER={\" & strTreiber & \"};\" & \"SERVER=\" & strServer & \";\" _\r\n & \"DATABASE=\" & strDatenbank & \";\"\r\n If <\/span>rst!TrustedConnection = True<\/span> Then<\/span>\r\n strTemp = strTemp & \"Trusted_Connection=Yes\"\r\n Else<\/span>\r\n If <\/span>Len<\/span>(Nz(rst!Benutzername, \"\")) > 0 And bolZugangsdatenAusVariablen = False<\/span> Then<\/span>\r\n strBenutzername = rst!Benutzername\r\n End If<\/span>\r\n If <\/span>Len<\/span>(Nz(rst!Kennwort, \"\")) > 0 And bolZugangsdatenAusVariablen = False<\/span> Then<\/span>\r\n strKennwort = rst!Kennwort\r\n End If<\/span>\r\n strTemp = strTemp & \"UID=\" & strBenutzername & \";\"\r\n strTemp = strTemp & \"PWD=\" & strKennwort\r\n End If<\/span>\r\n VerbindungszeichenfolgeNachID = strTemp\r\nEnd Function<\/span><\/pre>\nPublic <\/span>strBenutzername As String<\/span>\r\nPublic <\/span>strKennwort As String<\/span><\/pre>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2016_05\/pic_1054_003.png\")
<\/p>\n VerbindungszeichenfolgeNachID(9)\r\nODBC;DRIVER={ODBC Driver 11 for SQL Server};SERVER=(localdb)\\MSSQLLocalDB;DATABASE=Suedsturm;Trusted_Connection=Yes<\/pre>\nStandardverbindungszeichenfolge<\/h2>\n
Public Function <\/span>Standardverbindungszeichenfolge() As String<\/span>\r\n Dim <\/span>lngAktivID As Long<\/span>\r\n If <\/span>Not<\/span> lngAktivID = 0 Then<\/span>\r\n Standardverbindungszeichenfolge = VerbindungszeichenfolgeNachID(lngAktivID)\r\n Else<\/span>\r\n MsgBox<\/span> \"Achtung: Es ist keine Verbindungszeichenfolge als aktiv gekennzeichnet.\"\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nID der aktiven Verbindungszeichenfolge ermitteln<\/h2>\n
Public Function <\/span>AktiveVerbindungszeichenfolgeID() As Long<\/span>\r\n Dim <\/span>lngAktivID As Long<\/span>\r\n lngAktivID = Nz(DLookup(\"VerbindungszeichenfolgeID\", \"tblVerbindungszeichenfolgen\", \"Aktiv = True\"), 0)\r\n If <\/span>lngAktivID = 0 Then<\/span>\r\n MsgBox<\/span> \"Achtung: Es ist keine Verbindungszeichenfolge als aktiv gekennzeichnet.\"\r\n End If<\/span>\r\n AktiveVerbindungszeichenfolgeID = lngAktivID\r\nEnd Function<\/span><\/pre>\nVerbindung und Zugriffsdaten prüfen<\/h2>\n
Public Function <\/span>VerbindungTesten(lngVerbindungszeichenfolgeID As Long<\/span>, _\r\n Optional<\/span> strVerbindungszeichenfolge As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>bolTrustedConnection As Boolean<\/span>\r\n Dim <\/span>bolVerbindungHergestellt As Boolean<\/span>\r\n bolTrustedConnection = DLookup(\"TrustedConnection\", \"tblVerbindungszeichenfolgen\", \"VerbindungszeichenfolgeID = \" _\r\n & lngVerbindungszeichenfolgeID)\r\n strBenutzername = Nz(DLookup(\"Benutzername\", \"tblVerbindungszeichenfolgen\", \"VerbindungszeichenfolgeID = \" _\r\n & lngVerbindungszeichenfolgeID), strBenutzername)\r\n strKennwort = Nz(DLookup(\"Kennwort\", \"tblVerbindungszeichenfolgen\", \"VerbindungszeichenfolgeID = \" _\r\n & lngVerbindungszeichenfolgeID), strKennwort)\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)\r\n Do While<\/span> Not<\/span> bolVerbindungHergestellt\r\n MsgBox<\/span> \"Die Verbindung konnte nicht hergestellt werden.\"\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> bolTrustedConnection Then<\/span>\r\n If <\/span>LogindatenErmitteln(lngVerbindungszeichenfolgeID) = True<\/span> Then<\/span>\r\n strVerbindungszeichenfolge = VerbindungszeichenfolgeNachID(lngVerbindungszeichenfolgeID)\r\n bolVerbindungHergestellt = VerbindungHerstellen(strVerbindungszeichenfolge)\r\n Else<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n VerbindungTesten = True<\/span>\r\nEnd Function<\/span><\/pre>\n\n
\n
Testen der Verbindung<\/h2>\n
Verbindung herstellen<\/h2>\n
bolVerbindungHergestellt = VerbindungHerstellen(strVerbindungszeichenfolge)<\/pre>\n
\n
Login-Formular<\/h2>\n
Public Function <\/span>LogindatenErmitteln(lngVerbindungszeichenfolgeID) As Boolean<\/span>\r\n DoCmd.OpenForm \"frmLogin\", WindowMode:=acDialog, 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>\n![\"Das](\"..\/fileadmin\/_temp_\/2016_05\/pic_1054_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>strVerbindungszeichenfolge As String<\/span>\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(DLookup(\"Benutzername\", \"tblVerbindungszeichenfolgen\", \"VerbindungszeichenfolgeID = \" _\r\n & lngVerbindungszeichenfolgeID), strBenutzername)\r\n Me!txtKennwort = Nz(DLookup(\"Kennwort\", \"tblVerbindungszeichenfolgen\", \"VerbindungszeichenfolgeID = \" _\r\n & lngVerbindungszeichenfolgeID), strKennwort)\r\nEnd Sub<\/span><\/pre>\nHerstellen einer Verbindung<\/h2>\n
Public Function <\/span>VerbindungHerstellen(strVerbindungszeichenfolge As String<\/span>) As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.CreateQueryDef(\"\")\r\n With<\/span> qdf\r\n .Connect = strVerbindungszeichenfolge\r\n .ReturnsRecords = True<\/span>\r\n .SQL = \"SELECT 1 AS Test\"\r\n On Error Resume Next<\/span>\r\n .OpenRecordset\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n VerbindungHerstellen = True<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\nVerwendung dieser Funktionen<\/h2>\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n