<\/p>\n
Wenn Sie per ODBC auf die Tabellen etwa eines SQL Servers zugreifen, kennen Sie das Dilemma: Entweder Sie nutzen die Windows-Authentifizierung, was nicht überall möglich ist, aber ohne größere Probleme funktioniert. Oder Sie verwenden die SQL Server-Authentifizierung. Dann haben Sie zwei Möglichkeiten: Entweder Sie erlauben das Speichern des Kennworts in den Systemtabellen von Access. Oder der Benutzer muss nach dem eigentlichen Anmelden nochmal seine Benutzerdaten eingeben, wenn der erste Zugriff auf eine Tabelle erfolgt. In dieser Lösung schauen wir uns diese Varianten an – und eine bessere, bei der Sie einfach die Tabellen beim Start neu verknüpfen.<\/b><\/p>\n
Wir gehen an dieser Stelle davon aus, dass Sie einen SQL Server auf dem Rechner installiert haben und dort eine Datenbank mit einer oder mehreren gewünschten Tabellen mit Zugriffsrechten für ein bestimmtes Konto eingerichtet haben. Wichtig ist letzteres – sonst können Sie ja nicht per SQL Server-Authentifizierung auf die Tabelle zugreifen.<\/p>\n
Der gängige Weg, eine Verknüpfung zu einer SQL Server-Tabelle herzustellen, ist der über den Assistenten. Dabei rufen Sie diesen über den Ribbon-Eintrag Externe Daten|Importieren und Verknüpfen|Neue Datenquelle|Aus Datenbank|Aus SQL Server <\/b>auf (siehe Bild 1).<\/p>\n
![\"Manuelles](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_001.png\")
<\/p>\n
Bild 1: Manuelles Verknüpfen mit einer SQL Server-Tabelle<\/span><\/b><\/p>\n Dies öffnet den Dialog aus Bild 2, wo Sie die zweite Option zum Erstellen einer Verknüpfung auswählen und dann auf OK <\/b>klicken.<\/p>\n Bild 2: Start der Erstellung einer Verknüpfung<\/span><\/b><\/p>\n Der nächste Dialog heißt Datenquelle auswählen und hat zwei Registerreiter.<\/p>\n Wir wählen den zweiten namens Computerdatenquelle <\/b>an und klicken dort auf die Schaltfläche Neu… <\/b>(siehe Bild 3).<\/p>\n Bild 3: Anlegen einer neuen Computerdatenquelle<\/span><\/b><\/p>\n Einen Schritt weiter legen Sie noch genau fest, ob Sie eine Benutzerdatenquelle oder eine Systemdatenquelle anlegen wollen – wir wählen die Benutzerdatenquelle (siehe Bild 4). <\/p>\n Bild 4: Auswahl des Datenquellentyps<\/span><\/b><\/p>\n Der folgende Schritt fragt ab, welchen Datenbanktreiber wir verwenden wollen. Mit dem Treiber SQL Server <\/b>macht man nichts verkehrt (siehe Bild 5). Die SQL Server Native Client x.0<\/b>-Treiber können Sie verwenden, wenn diese spezielle Features für den Zugriff auf die jeweilige Version des SQL Servers bereithalten.<\/p>\n Bild 5: Auswahl des Datenbanktreibers<\/span><\/b><\/p>\n Der nächste Schritt ermittelt einen Namen für die Datenquelle. Diese nennen wir einfach Datenquelle_Suedsturm_SQL<\/b>. Außerdem möchte der Assistent hier wissen, auf welchen SQL Server wir zugreifen wollen, um die Verknüpfung herzustellen. Diese heißt in unserem Fall wie der Rechner, auf dem der SQL Server läuft. Wenn Sie die LocalDb-Version nutzen, würden Sie hier beispielsweise (localdb)\\SQLServerLocalDB <\/b>angeben (siehe Bild 6).<\/p>\n Bild 6: Angeben eines Namens für die Datenquelle und des Servers<\/span><\/b><\/p>\n Ist dieser Schritt erledigt, fragt der Assistent im nächsten Schritt ab, ob wir Windows-Authentifizierung oder SQL Server-Authentifizierung verwenden wollen. Wir entscheiden uns für letzteres und tragen unsere Benutzerdaten in die beiden nun freigeschalteten Textfelder Login ID <\/b>und Password <\/b>ein (siehe Bild 7). Der Benutzer heißt hier Benutzer3<\/b>, das Kennwort password<\/b>.<\/p>\n Bild 7: Einstellen der SQL Server-Authentifizierung und Angabe der Zugangsdaten<\/span><\/b><\/p>\n Wie Sie einen Benutzer für die SQL Server-Authentifizierung für eine Datenbank anlegen, hier Benutzer3<\/b>, erfahren Sie im Beitrag SQL Server-Authentifizierung <\/b>(www.access-im-unternehmen.de\/1155<\/b>).<\/p>\n Im folgenden Schritt können Sie noch die Standarddatenbank auf Suedsturm_SQL <\/b>einstellen (siehe Bild 8), die Einstellungen im darauffolgenden Dialog behalten wir bei.<\/p>\n Bild 8: Einstellen der Standarddatenbank<\/span><\/b><\/p>\n Es folgt ein Abschlussdialog, der die Einstellungen nochmal zusammenfasst und eine Schaltfläche anbietet, mit der Sie die Datenquelle testen können (Test Data Source…<\/b>). Diese klicken Sie an und sollten dann das Ergebnis aus Bild 9 erhalten.<\/p>\n Bild 9: Testen der Datenbankverbindung<\/span><\/b><\/p>\n Damit ist die Computerdatenquelle angelegt und wir finden diese im Dialog Datenquelle auswählen <\/b>vor. Die neue Datenquelle sollte nun ausgewählt sein und wir schließen den Dialog mit der OK<\/b>-Schaltfläche.<\/p>\n Nun erscheint ein Dialog namens SQL Server Login<\/b>. Hier ist der Benutzername bereits voreingestellt und wir müssen noch das Kennwort eingeben (siehe Bild 10). Mit einem Klick auf die Schaltfläche Optionen >> <\/b>können Sie noch weitere Optionen einblenden – etwa, um das Kennwort zu ändern.<\/p>\n Bild 10: Herstellen der Verbindung<\/span><\/b><\/p>\n Im abschließenden Dialog Tabellen verknüpfen <\/b>können Sie nun die zu verknüpfenden Tabellen auswählen (siehe Bild 11). Wir wählen alle Tabellen aus, die wir selbst angelegt haben – die anderen sind Systemtabellen der SQL Server-Datenbank.<\/p>\n Bild 11: Auswahl der zu verknüpfenden Tabellen<\/span><\/b><\/p>\n Direkt im Anschluss erscheinen die ausgewählten Tabellen im Navigationsbereich von Access – allerdings jeweils mit dem Präfix dbo_<\/b> (siehe Bild 12).<\/p>\n Bild 12: Die frisch angelegten Verknüpfungen<\/span><\/b><\/p>\n Nun öffnen wir die Systemtabelle MSysObjects von Access und schauen uns den Inhalt der Spalte Connect an. Diese liefert uns die Verbindungszeichenfolge, die der Verknüpfungsassistent eingerichtet hat (siehe Bild 13). Wir sehen hier eine Verbindungszeichenfolge mit einer DSN <\/b>namens Test <\/b>sowie die Angabe einer APP <\/b>und der DATABASE<\/b>:<\/p>\n Bild 13: Die Tabelle MSysObjects mit den Verbindungszeichenfolgen<\/span><\/b><\/p>\n Die hinter der DSN steckenden Informationen finden wir in der Registry unter dem Zweig HKEY_CURRENT_USER\\Software\\ODBC\\ODBC.INI\\Test <\/b>– siehe Bild 14. Hier wird nur der zuletzt verwendete Benutzername gespeichert, aber nicht das Kennworts.<\/p>\n Bild 14: Die DSN in der Systemregistrierung<\/span><\/b><\/p>\n Das Kennwort wurde in früheren Versionen noch optional gespeichert, aber aus Sicherheitsgründen hat Microsoft diese Option entfernt.<\/p>\n Die Tabellen können Sie nun direkt öffnen – Sie brauchen nicht erneut die Zugangsdaten einzugeben. Wenn Sie die Access-Sitzung allerdings beenden und erneut starten (dies erfordert das Schließen der Access-Anwendung – das Schließen der Datenbank allein reicht nicht aus), erscheint beim ersten Zugriff auf eine der Tabellen der Dialog zum Eingeben der Zugriffsdaten (siehe Bild 15).<\/p>\n Bild 15: SQL Server-Logindialog<\/span><\/b><\/p>\n Die Lösung ist zwar sicher, aber wenig komfortabel – für den Benutzer ist es aber nicht die perfekte Lösung. Das Problem ist, dass wir ihn nicht mit dem von Microsoft vorgegebenen, englischsprachigen Dialog abspeisen wollen.<\/p>\n Außerdem soll die Eingabe des Kennworts nicht erst beim erstmaligen Zugriff auf eine der Tabellen erfolgen, sondern direkt beim Start.<\/p>\n Eine für den Benutzer ergonomische, aber bezüglich der Datensicherheit bedenkliche Lösung wäre es, das Kennwort in der Verbindungszeichenfolge zu speichern. Sollte ein anderer Benutzer Zugriff auf den Rechner erhalten könnte er die Zugangsdaten direkt aus der Tabelle MSys-Objects <\/b>oder auch aus den Eigenschaften der Entwurfsansicht einer der verknüpften Tabellen auslesen. Also lassen wir diesen Ansatz gleich unter den Tisch fallen.<\/p>\n Der aus unserer Sicht beste Ansatz ist es, die Zugangsdaten in einem benutzerdefinierten Dialog beim Starten der Anwendung abzufragen und die Verknüpfungen dann zu erstellen. Dabei verwendet man eine bestimmte Option, die dafür sorgt, dass die Benutzerdaten nicht in der Verbindungszeichenfolge in der Systemtabelle MSysObjects<\/b> gespeichert werden. Die Zugangsdaten werden dann durch eine per Code realisierte Anmeldung für diese Sitzung gespeichert. Wenn der Benutzer dann das nächste Mal auf die Datenbank zugreift, müsste er die Zugangsdaten neu eingeben, sobald er auf eine der Tabellen zugreift. Dann würde der eingebaute Dialog zum Eingeben der Anmeldedaten erscheinen. Um das zu verhindern, sorgen wir dauerhaft dafür, dass der Benutzer immer beim Neustart der Anwendung die Benutzerdaten eingeben muss. Wie das gelingt, zeigen wir in den folgenden Abschnitten.<\/p>\n <\/p>\n Um die Tabellen beim Start der Anwendung zu verknüpfen, benötigen wir ein Formular, das beim Start der Anwendung geöffnet wird und die Anmeldedaten abfragt. Dann soll das Formular mit diesen Anmeldedaten eine Verbindungszeichenfolge zusammenstellen und die ODBC-Verknüpfungen zu den benötigten Tabellen herstellen.<\/p>\n Dadurch, dass die Zugangsdaten nicht in der Tabelle MSysObjects <\/b>gespeichert werden, kann selbst eine Person, die in Abwesenheit des Benutzers auf die Datenbank zugreift, nicht die Zugangsdaten ermitteln. Allerdings wäre es für diese Person auch ohne Vorhandensein der Anmeldedaten möglich, in diesem Moment über die Anwendung auf die Datenin der SQL Server-Datenbank zuzugreifen – man sollte sich grundsätzlich von seinem Rechner abmelden, wenn man den Raum verlässt und Unbefugte in der Nähe sein könnten.<\/p>\n Das Login-Formular soll die folgenden Steuer-elemente enthalten:<\/p>\n Das Formular stellen wir etwa wie in Bild 16 zusammen. Für das Steuer-element cmdAnmelden <\/b>legen wir die Eigenschaft Standard <\/b>auf den Wert Ja <\/b>fest, für das Steuer-element cmdAbbrechen <\/b>die Eigenschaft Abbrechen <\/b>auf den Wert Ja<\/b>.<\/p>\n Bild 16: Entwurf des Login-Formulars<\/span><\/b><\/p>\n Damit die durch die Schaltfläche cmdAnmelden <\/b>ausgelöste Ereignisprozedur weiß, welche Tabellen verknüpft werden sollen, legen wir noch eine Tabelle namens tblVerknuepfungen <\/b>an. Diese enthält drei Felder: VerknuepfungID<\/b>, Quelltabelle <\/b>und Zieltabelle<\/b>.<\/p>\n Quelltabelle und Zieltabelle deshalb, weil es ja sein kann, dass Sie die Verknüpfungen nicht unter dem Namen anlegen wollen, unter dem die Tabellen im SQL Server gespeichert sind. Den Entwurf dieser Tabelle finden Sie in Bild 17.<\/p>\n Bild 17: Entwurf der Tabelle zum Speichern der zu verknüpfenden Tabellen<\/span><\/b><\/p>\n Wenn Sie keine Lust haben, die zu verknüpfenden Tabellen manuell in die Tabelle tblVerknuepfungen <\/b>einzutragen, können Sie das auch mit einer kleinen Prozedur erledigen. Voraussetzung dafür ist, dass Sie – wie beispielsweise durch die zuvor beschriebene Vorgehensweise – die Verknüpfungen bereits einmal angelegt haben.<\/p>\n In diesem Fall können Sie die Prozedur AktuelleVerknuepfungenSpeichern<\/b> aufrufen, die Sie in Listing 1 finden. Die Prozedur durchläuft alle Tabellen der Datenbank über die TableDefs<\/b>-Auflistung des Database<\/b>-Objekts. In der For Each<\/b>-Schleife prüft die Prozedur zunächst, ob die Eigenschaft Connect <\/b>eine Zeichenlänge mit einer Größe größer 0 <\/b>enthält. Dies deutet darauf hin, dass es sich um eine verknüpfte Tabelle handelt. Ist dies der Fall, ermittelt die Prozedur den Namen der Quelltabelle und der Zieltabelle und schreibt diese in die beiden Variablen strQuelltabelle <\/b>und strZieltabelle<\/b>. Von dort landen sie dann innerhalb einer INSERT INTO<\/b>-Aktionsabfrage in der Tabelle tblVerknuepfungen<\/b>. Nachdem wir diese Prozedur für die Tabellen unserer Beispieldatenbank durchlaufen haben, sieht die Tabelle tblVerknuepfungen <\/b>etwa wie in Bild 18 aus.<\/p>\n Bild 18: Tabelle mit den Quell- und Zieldateien für das Wiederherstellen der Verknüpfungen<\/span><\/b><\/p>\n Wir haben hier schon das Präfix dbo_ <\/b>von den Namen der Verknüpfungen entfernt.<\/p>\n Neben der Tabelle zum Speichern der Verknüpfungen legen wir noch eine weitere Hilfstabelle namens tblOptionen <\/b>an.<\/p>\n Diese enthält lediglich das Primärschlüsselfeld OptionID <\/b>sowie die beiden Felder Bezeichnung <\/b>und Wert<\/b>. Hier speichern wir in zwei Datensätzen die Bezeichnungen für den Server und die Datenbank, auf die wir per ODBC zugreifen wollen (siehe Bild 19).<\/p>\n Bild 19: Tabelle mit Optionen<\/span><\/b><\/p>\n Den Start beim Neuanlegen der Verknüpfungen machen wir im Startformular. Dieses sieht wie in Bild 20 aus und entspricht dem Startformular der Beispieldatenbank. Hier haben wir für das grüne Bild mit dem Haken-Symbol eine Ereignisprozedur hinterlegt, die wie in Listing 2 aussieht.<\/p>\n Bild 20: Das Startformular der Anwendung<\/span><\/b><\/p>\n Die Prozedur öffnet zunächst unser Formular frmLogin <\/b>und wartet ab, bis der Benutzer entweder die OK<\/b>-Schaltfläche oder die Abbrechen<\/b>-Schaltfläche gedrückt hat und damit entweder das Formular unsichtbar gemacht oder geschlossen hat.<\/p>\n Erst dann wird die Prozedur cmdGo_Click <\/b>fortgesetzt. Sie prüft dann mit der Hilfsfunktion IstFormularGeoeffnet<\/b>, ob das Formular frmLogin <\/b>noch geöffnet ist, was der Fall ist, wenn der Benutzer es mit der Schaltfläche cmdOK <\/b>ausgeblendet hat.<\/p>\n In diesem Fall können wir den Benutzernamen und das Kennwort aus den beiden Textfeldern des Formulars in die im Modul mdlSQLServer <\/b>global deklarierten Variablen eintragen.<\/p>\n Danach wird das Formular frmLogin <\/b>geschlossen und die Prozedur liest die Werte für den Server und die Datenbank aus der Tabelle tblOptionen <\/b>ein.<\/p>\n Damit setzt sie die Verbindungszeichenfolge zusammen, die danach etwa wie folgt aussieht:<\/p>\n Damit als Parameter ruft die Prozedur nun die Funktion VerbindungTesten<\/b>. Testet diese die Verbindung erfolgreich und gibt den Wert True <\/b>zurück, geht es mit dem Aufruf der Funktion TabellenVerknuepfen weiter.<\/p>\n Diese erwartet wiederum die Verbindungszeichenfolge als Parameter und ruft die Prozedur TabellenVerknuepfen <\/b>auf, welche die Verknüpfung mit den Tabellen erledigt.<\/p>\n Das Testen der Verbindung übernimmt die Funktion VerbindungHerstellen<\/b>, die wiederum die Verbindungszeichenfolge als Parameter erwartet (siehe Listing 3). Sie erstellt mit der Methode CreateQueryDef <\/b>eine leere Abfrage.<\/p>\n Listing 3: Funktion zum Herstellen der Verbindung mit der SQL Server-Datenbank<\/span><\/b><\/p>\n Dieser weist sie über die Eigenschaft Connect <\/b>die Verbindungszeichenfolge zu. Außerdem stellt sie die Eigenschaft ReturnRecords <\/b>auf den Wert True <\/b>ein und legt für die Eigenschaft SQL <\/b>eine einfache SELECT<\/b>-Abfrage an (SELECT 1 AS Test<\/b>). Dann versucht sie, bei deaktivierter Fehlerbehandlung die Abfrage mit der Methode OpenRecordset <\/b>zu öffnen. Wenn dies gelingt, hat Err.Number <\/b>anschließend noch den Wert 0 <\/b>und der Rückgabewert der Funktion erhält den Wert True<\/b>.<\/p>\n Die Funktion TabellenVerknuepfen <\/b>erwartet wiederum die Verbindungszeichenfolge als Parameter (siehe Listing 4). Sie öffnet ein Recordset auf Basis der Tabelle tblVerknuepfungen <\/b>und durchläuft die Datensätze dieses Recordsets in einer Do While<\/b>-Schleife. Dabei ruft es für jeden Datensatz einmal die Prozedur TabelleVerknuepfen <\/b>auf.<\/p>\n Listing 4: Prozedur zum Verknüpfen der Tabellen<\/span><\/b><\/p>\n Diese Prozedur (siehe Listing 5) erwartet nicht nur die Verbindungszeichenfolge, sondern auch noch den Namen der Tabelle in der SQL Server-Datenbank und die Bezeichnung, welche die Verknüpfung in der Access-Datenbank erhalten soll. Sie referenziert zunächst die mit strTabelleAccess <\/b>angegebene Verknüpfung in Access als TableDef<\/b>-Objekt. Hat die Objektvariable tdf <\/b>danach nicht den Wert Nothing<\/b>, ist offensichtlich bereits eine Verknüpfung oder Tabelle gleichen Namens vorhanden. Sollte es bei dem bereits vorhandenen Element gleichen Namens um eine Verknüpfung handeln, wird diese einfach gelöscht. Anderenfalls handelt es sich um eine lokale Tabelle, bei der wir den Benutzer fragen sollten, ob wir diese Tabelle löschen können. Das erledigen wir per MsgBox<\/b>-Anweisung. Liefert diese den Wert vbYes<\/b>, löschen wir die Tabelle ebenfalls einfach. Anderenfalls speichern wir die zu erzeugende Verknüpfung einfach unter einem Namen, der dem Namen aus strTabelleAccess <\/b>und dem Zusatz 1 <\/b>entspricht, also beispielsweise tblArtikel1<\/b>.<\/p>\n Listing 5: Prozedur zum Verknüpfen einer Tabelle<\/span><\/b><\/p>\n Anschließend leeren wir das Objekt tdf <\/b>und füllen es mit der zu erstellenden Tabelle. Diese legen wir mit der CreateTableDef<\/b>-Methode an, der wir als Parameter den Namen der Verknüpfung aus strTabelleAccess <\/b>übergeben. Dann weisen wir der Eigenschaft Connect <\/b>den Inhalt der Variablen strVerbindungszeichenfolge <\/b>zu. Diese enthält zu diesem Zeitpunkt den Benutzernamen und das Kennwort und sieht etwa wie folgt aus:<\/p>\n Danach stellen wir noch den Namen der Quelltabelle, also der Tabelle des SQL Servers, auf den Wert aus strTabelleSQLServer <\/b>ein. Zu diesem Zeitpunkt ist die Verknüpfung zwar in Form eines TableDef<\/b>-Objekts existent, aber noch nicht zur Auflistung der TableDefs <\/b>der aktuellen Datenbank hinzugefügt. Das holen wir dann mit der Append<\/b>-Methode der TableDefs<\/b>-Auflistung nach. Danach folgt noch ein Aufruf der SysCmd<\/b>-Funktion, die den Fortschritt in der Statusleiste von Access anzeigt.<\/p>\n Die DoEvents<\/b>-Anweisung sorgt dafür, dass diese zuverlässig aktualisiert wird. Schließlich sollen die neu erstellten Verknüpfungen auch noch im Navigationsbereich dargestellt werden – dazu rufen wir die Methode RefreshDatabaseWindow <\/b>des Application<\/b>-Objekts auf.<\/p>\n Damit sind die Arbeiten für den Login und für das Erstellen der Verknüpfungen abgeschlossen.<\/p>\n Um die Neu-Verknüpfung zu testen, löschen wir nun zunächst die bestehenden Verknüpfungen aus der Datenbank und schließen diese und auch Access selbst. Das Formular frmIntro <\/b>wird automatisch aufgerufen, da es für die Eigenschaft Startformular in den Access-Optionen eingesetzt wurde. Wenn der Benutzer die Schaltfläche cmdGo<\/b> anklickt, wird die weiter oben beschriebene Prozedur ausgelöst und zeigt den Dialog frmLogin <\/b>an.<\/p>\n Gibt der Benutzer hier die korrekten Zugangsdaten ein, hier also Benutzer3 <\/b>und password<\/b>, werden eventuell bestehende Verknüpfungen gelöscht und durch die neuen Verknüpfungen ersetzt.<\/p>\n Dabei erfolgt durch die Funktion VerbindungHerstellen <\/b>der Aufruf einer SELECT<\/b>-Anweisung auf der Zieldatenbank, wodurch die Zugangsdaten für diese Session gespeichert werden und solange gültig bleiben, sich der Benutzer die Access-Session beendet – und zwar durch Beenden von Access. Ein Schließen der Anwendung allein reicht nicht aus.<\/p>\n Ist VerbindungHerstellen <\/b>erfolgreich, werden durch die Prozedur TabellenVerknuepfen <\/b>die Tabellen erneut verknüpft. Nun wollen wir wissen, ob die Zugangsdaten tatsächlich nicht in der Tabelle MSysObjects <\/b>gespeichert wurden. Also öffnen wir diese und finden das Resultat aus Bild 21 vor – die sensiblen Daten wurden also nicht gespeichert.<\/p>\n Bild 21: Prüfung, ob Benutzername und Kennwort in der Tabelle MSysObjects gespeichert werden<\/span><\/b><\/p>\n Können wir uns auch Anmelden, ohne die Verknüpfungen erneut anzulegen Auch das ist möglich. Dazu brauchen wir nur den Aufruf der Prozedur TabellenVerknuepfen <\/b>in cmdGo_Click <\/b>zu entfernen. Nach dem Einloggen des Benutzers können Sie problemlos auf die Tabellen der Datenbank Suedsturm_SQL <\/b>zugreifen.<\/p>\n Um sicherzugehen, dass wir nichts übersehen, wollen wir auch noch einmal versuchen, nach dem erneuten öffnen der Anwendung ohne Anmeldung auf die Tabellen zuzugreifen.<\/p>\n Das Unerwartete geschah auf meinem Rechner: Ich konnte dennoch auf die Tabellen der SQL Server-Datenbank zugreifen. Was ist da passiert Wurden Benutzername und Kennwort nun doch an einer versteckten Stelle in der Datenbankdatei gespeichert Gibt es dadurch nun doch eine Sicherheitslücke<\/p>\n Wenn Sie die Datenbank wie ich über das SQL-Skript aus dem Download angelegt und den Benutzer Benutzer3 <\/b>angelegt haben, dürften Sie das gleiche Phänomen sehen.<\/p>\n Aber was ist hier schiefgelaufen Um das herauszufinden, haben wir ein spezielles Tool des SQL Server Management Studio verwendet, nämlich die erweiterten Ereignisse.<\/p>\n Dabei handelt es sich um den Nachfolger des SQL Server Profilers, mit dem man zuvor die Zugriffe auf eine SQL Server-Datenbank getrackt und untersucht hat.<\/p>\n Wie wir die erweiterten Ereignisse im Detail eingesetzt haben, zeigen wir in einem weiteren Beitrag namens SQL Server: Zugriffe untersuchen mit XEvents <\/b>(www.access-im-unternehmen.de\/1158<\/b>).<\/p>\n Des Rätsels Lösung ist: Wir haben die Datenbank im Kontext des aktuell angemeldeten Windows-Benutzers erstellt, der somit gleichzeitig Besitzer dieser Datenbank ist – und mit universellen Berechtigungen auf alle Objekte der Datenbank ausgestattet.<\/p>\n Wenn wir nun versuchen, auf die Datenbank zuzugreifen, ohne eine explizite SQL Server-Anmeldung zu verwenden, versucht der SQL Server offensichtlich, eine Anmeldung für den aktuellen Windows-Benutzer durchzuführen. Was auch geklappt hat, wie wir sehen – und wie wir im Beitrag SQL Server: Zugriffe untersuchen mit erweiterten Ereignissen <\/b>nachweisen werden.<\/p>\n Wenn Sie die Datenbank von einem anderen Benutzerkonto aus öffnen, das keine Berechtigungen für die Datenbank (oder auch den SQL Server) besitzt, erscheint in diesem Falle eine Meldung, dass die Verbindung fehlgeschlagen ist und der Benutzer die Tabelle nicht öffnen kann.<\/p>\n Dieser Beitrag hat gezeigt, wie Sie Verknüpfungen auf die Tabellen eines SQL Servers per Assistent erstellen und welche Nachteile sich bei ihrer Verwendung ergeben – nämlich, dass beim ersten Zugriff auf eine Datenbank jeweils der systemeigene Dialog zum Eingeben der Zugangsdaten erscheint.<\/p>\n Diesen wollen wir gleich beim Start einer Anwendung durch einen benutzerdefinierten Anmelde-Dialog ersetzen und bei dieser Gelegenheit gleich noch die Verknüpfungen zu den Tabellen der SQL Server-Datenbank aktualisieren, was wir in diesem Beitrag gezeigt haben.<\/p>\n Die letzte Aufgabe lag darin, herauszufinden, warum auf dem Rechner, auf dem die Datenbank erstellt wurde, ein Zugriff auf die Tabellen einer SQL Server-Datenbank ohne vorherige Anmeldung möglich war. Wie Sie dies prüfen, erfahren Sie im bereits erwähnten Beitrag SQL Server: Zugriffe untersuchen mit XEvents<\/b>.<\/p>\n Enthaltene Beispieldateien:<\/p>\n SQLServerOhnePWD.accdb<\/p>\n Suedsturm_SQL.sql<\/p>\n![\"Start](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_002.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_003.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_004.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_005.png\")
<\/p>\n![\"Angeben](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_006.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_007.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_009.png\")
<\/p>\n![\"Testen](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0010.png\")
<\/p>\n![\"Herstellen](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0011.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0012.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0014.png\")
<\/p>\nVer-bin-dungs-zeichen-folgen ansehen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0013.png\")
<\/p>\nDSN=Test;APP=Microsoft Office 2016;DATABASE=Suedsturm_SQL;<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0015.png\")
<\/p>\nZugriff auf die Tabellen<\/h2>\n
![\"SQL](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0016.png\")
<\/p>\nKennwort in der Verbindungszeichenfolge speichern<\/h2>\n
Verknüpfen und löschen<\/h2>\n
Tabellen beim Start verknüpfen <\/h2>\n
Login-Formular programmieren<\/h2>\n
\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0017.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0018.png\")
<\/p>\nAutomatisches Füllen der Tabelle<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0019.png\")
<\/p>\nDie Optionen-Tabelle<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0020.png\")
<\/p>\nVerknuepfungen anlegen per Startformular<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0021.png\")
<\/p>\nDBC;DRIVER={SQL Server};SERVER=Desktop-PC-I5;DATABASE=Suedsturm_SQL;UID=Benutzer3;PWD=password;OPTION=3;LOG_QUERY=1;<\/pre>\nVerbindung testen<\/h2>\n
Public Function <\/span>VerbindungHerstellen(strVerbindungszeichenfolge As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database, 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>\nTabellen verknüpfen<\/h2>\n
Public Sub <\/span>TabellenVerknuepfen(strVerbindungszeichenfolge As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVerknuepfungen\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n TabelleVerknuepfen rst!Zieltabelle, rst!Quelltabelle, strVerbindungszeichenfolge\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nTabelle verknüpfen<\/h2>\n
Public Sub <\/span>TabelleVerknuepfen(strTabelleAccess As String<\/span>, ByVal strTabelleSQLServer As String<\/span>, _\r\n strVerbindungszeichenfolge As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>TableDef\r\n Dim <\/span>bolVorhanden As Boolean<\/span>\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n Set<\/span> tdf = db.TableDefs(strTabelleAccess)\r\n If <\/span>Not<\/span> tdf Is Nothing Then<\/span>\r\n If <\/span>Len<\/span>(tdf.Connect) = 0 Then<\/span>\r\n If MsgBox<\/span>(\"Es ist bereits eine lokale Tabelle namens ''''\" & strTabelleAccess & \"'''' gespeichert. \" _\r\n & \"überschreiben (Ja) oder zu verknüpfende Tabelle umbenennen (Nein)\", vbYesNo) = vbYes Then\r\n db.TableDefs.Delete strTabelleAccess\r\n Else<\/span>\r\n db.TableDefs.Delete strTabelleAccess & \"1\"\r\n strTabelleAccess = strTabelleAccess & \"1\"\r\n End If<\/span>\r\n Else<\/span>\r\n db.TableDefs.Delete strTabelleAccess\r\n End If<\/span>\r\n End If<\/span>\r\n Set<\/span> tdf = Nothing\r\n On Error GoTo<\/span> 0\r\n Set<\/span> tdf = db.CreateTableDef(strTabelleAccess)\r\n tdf.Connect = strVerbindungszeichenfolge\r\n tdf.SourceTableName = strTabelleSQLServer\r\n db.TableDefs.Append tdf\r\n SysCmd acSysCmdSetStatus, \"Tabelle ''''\" & strTabelleSQLServer & \"'''' verknüpfen ...\"\r\n DoEvents\r\n Application.RefreshDatabaseWindow\r\nEnd Sub<\/span><\/pre>\nODBC;DRIVER={SQL Server};SERVER=Desktop-PC-I5;DATABASE=Suedsturm_SQL;UID=Benutzer3;PWD=password;OPTION=3;LOG_QUERY=1;<\/pre>\nTest der Verknüpfung<\/h2>\n
![\"Prüfung,](\"..\/fileadmin\/_temp_\/2018_05\/pic_1156_0022.png\")
<\/p>\nAnmelden ohne Neuverknüpfen<\/h2>\n
Zur Sicherheit: Zugriff ohne Anmeldung<\/h2>\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n