<\/p>\n
In Ausgabe 3\/2019 haben wir einige Elemente vorgestellt, die den Zugriff auf die Daten einer Datenbank einschränken sollen – zum Beispiel eine einfache Benutzerverwaltung und die Möglichkeit, den Zugriff auf Tabellen per Datenmakro einzuschränken. Im vorliegenden Beitrag wollen wir zeigen, wie Sie diese Techniken abrunden und den direkten Zugriff des Benutzers auf die Tabellen der Datenbank endgültig verhindern. Dazu exportieren wir diese in eine Backend-Datenbank, auf die wir diesmal nicht wie gewohnt per Verknüpfung zugreifen – sondern ausschließlich per VBA. Das hat den Vorteil, dass wir das Backend mit einem Kennwort versehen können, das nur im Code des Frontends zum Einsatz kommt – und diesen können wir durch Umwandlung in eine .mde- beziehungsweise .accde-Datenbank vor den Augen des Benutzers verbergen.<\/b><\/p>\nVoraussetzungen<\/h2>\n
Die Beispieldatenbank dieses Beitrags haben wir in einigen anderen Beiträgen vorbereitet. Der Beitrag Benutzerverwaltung mit verschlüsselten Kennwörtern <\/b>(www.access-im-unternehmen.de\/1190<\/b>) zeigt, wie die Benutzerverwaltung programmiert wird.<\/p>\n
Unter dem Titel Zugriffsrechte mit Datenmakros <\/b>(www.access-im-unternehmen.de\/1193<\/b>) zeigen wir, wie Sie Tabellen so schützen, dass Sie nur noch nach der Anmeldung unter einem bestimmten Benutzerkonto auf die enthaltenen Daten zugreifen können.<\/p>\n
Die Beispieldatenbank enthält also einen Anmeldedialog namens frmAnmeldung<\/b>, mit dem der Benutzer die Zugangsdaten eingeben kann. Hat er keine Zugangsdaten eingegeben, ist durch die Definition entsprechender Datenmakros kein schreibender Zugriff auf die Tabellen der Datenbank möglich. Den lesenden Zugriff schränken wir noch durch die Prüfung der Berechtigungen beim Öffnen der jeweiligen Formulare ein.<\/p>\nGeplante Änderungen<\/h2>\n
Die erste Änderung, die wir durchführen, ist das Exportieren der Tabellen der Anwendung in eine Backend-Datenbank. Danach schützen wir diese Datenbank durch ein Datenbankkennwort. Schließlich müssen wir überall, wo wir in der Frontend-Datenbank auf die Daten der Tabellen oder Abfrage zugegriffen haben, entsprechenden VBA-Code für den Zugriff auf die Daten unter Berücksichtigung des Datenbankkennworts des Backends hinterlegen.<\/p>\n
Natürlich ist das je nach der Komplexität der Anwendung eine mehr oder weniger große Aufgabe, aber wenn Sie eine Access-Anwendung ohne Einsatz des SQL Servers oder eines ähnlichen Systems unter maximaler Datensicherheit erstellen wollen, müssen Sie dies in Kauf nehmen. Schließlich wandeln Sie die Frontend-Datenbank in eine .mde<\/b>– beziehungsweise .accde<\/b>-Datenbank um, deren Code der Benutzer nicht mehr einsehen kann. Dieser Schritt ist wichtig, da wir das Kennwort für den Zugriff auf die Tabellen des Backends im Code hinterlegen.<\/p>\nExportieren der Tabellen in eine Backend-Datenbank<\/h2>\n
Das Aufteilen der Datenbank erledigen Sie am einfachsten durch den Aufruf des Ribbon-Befehls Datenbanktools|Daten verschieben|Access-Datenbank<\/b> (siehe Bild 1). Nach dem Aufruf wählen Sie im Dialog Assistent zur Datenbankaufteilung <\/b>den Befehl Datenbank aufteilen<\/b>. Anschließend brauchen Sie nur noch den Pfad der zu erstellenden Backend-Datenbank anzugeben. Wir nennen das Backend Daten.accdb <\/b>und speichern es im gleichen Verzeichnis wie die Frontend-Datenbank. Danach zeigt die Frontend-Datenbank nicht mehr die Tabellen selbst im Bereich Tabellen <\/b>des Navigationsbereich an, sondern nur noch die Verknüpfungen auf die Tabellen (siehe Bild 2). Diese befinden sich nun in der neu erstellten Backend-Datenbank.<\/p>\n
![\"Aufruf](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_001.png\")
<\/p>\n
Bild 1: Aufruf des Befehls zum Aufteilen einer Datenbank<\/span><\/b><\/p>\n Bild 2: Verknüpfungen zu den Tabellen des Backends<\/span><\/b><\/p>\n Solange sich diese Verknüpfungen in der Frontend-Datenbank befinden, kann der Benutzer der Datenbank zumindest lesend auf die Daten der Tabellen zugreifen, da er diese über einen Doppelklick auf die Verknüpfungen öffnen kann. Um das zu verhindern, greifen wir zu einer harten Maßnahme: Wir löschen die Verknüpfungen schlicht und einfach. Damit funktionieren die Abfragen und Formulare, die an die Tabellen gebunden sind, nun nicht mehr, da die Datenquelle nicht mehr verfügbar ist. Und auch die Formulare wie etwa frmBerechtigungenVerwalten<\/b>, die per VBA auf die Tabellen zugreifen, um die Daten in einer HTML-Tabelle anzuzeigen, versagen ihren Dienst.<\/p>\n Bevor wir die notwendigen Änderungen am Frontend vornehmen, um wieder auf die Daten der Tabellen zuzugreifen, legen wir ein Datenbankkennwort für die Backend-Datenbank fest. Dazu öffnen Sie diese direkt in einer weiteren Access-Instanz. Dazu genügt ein Doppelklick auf die Datei Daten.accdb<\/b>.<\/p>\n Anschließend öffnen Sie mit einem Klick auf den Ribbon-Reiter Datei <\/b>den Backstage-Bereich. Unter Informationen finden Sie hier die Schaltfläche Mit Kennwort verschlüsseln <\/b>(siehe Bild 3). Wenn Sie die Datenbank per Doppelklick geöffnet haben, ist diese noch nicht im Exklusiv-Modus geöffnet. Dies können Sie erledigen, indem Sie die Datenbank mit dem Ribbon-Befehl Datei|Schließen <\/b>schließen. Danach betätigen Sie den Ribbon-Befehl Datei|Öffnen<\/b>. Hier wählen Sie den Befehl Durchsuchen <\/b>aus. Im nun erscheinenden Öffnen<\/b>-Dialog wählen Sie die gewünschte Datei aus, in diesem Fall Daten.accdb<\/b>, und wählen den Untereintrag Exklusiv öffnen <\/b>der Schaltfläche Öffnen <\/b>aus.<\/p>\n Bild 3: Zuweisen eines Datenbankkennworts zur Backend-Datenbank<\/span><\/b><\/p>\n Danach können Sie erneut den Ribbon-Reiter Datei <\/b>anklicken und im Bereich Information <\/b>die Schaltfläche Mit Kennwort verschlüsseln <\/b>betätigen. Nun erscheint der Dialog Datenbankkennwort festlegen<\/b>, in dem Sie das Kennwort zwei Mal eingeben und dieses dann durch einen Klick auf die Schaltfläche OK <\/b>bestätigen (siehe Bild 4). Zu Beispielzwecken haben wir hier das Kennwort kennwort <\/b>eingetragen.<\/p>\n Bild 4: Festlegen des Datenbankkennworts<\/span><\/b><\/p>\n Wenn Sie die Backend-Datenbank nun schließen und erneut öffnen, erscheint der Dialog Kennwort erforderlich <\/b>und verlangt nach der Eingabe des Kennworts.<\/p>\n Damit haben wir den Zugriff auf die Daten vom Frontend aus noch längst nicht wiederhergestellt – im Gegenteil, durch Vergabe des Kennworts haben wir diesen sogar noch erschwert. Doch nun werden wir Schritt für Schritt den Zugriff auf die Tabellen des Backends wieder hinzufügen.<\/p>\n Wenn wir die Frontend-Datenbank öffnen, sollte nach dem Bestätigen des Intro-Formulars der Dialog frmAnmelden <\/b>erscheinen. Stattdessen erhalten wir die Fehlermeldung aus Bild 5. Als fehlerhafte Zeile wird die folgende Zeile markiert:<\/p>\n Bild 5: Fehlermeldung beim Versuch, auf die Tabelle tblBenutzer zuzugreifen<\/span><\/b><\/p>\n Hier benötigen wir nur eine kleine Anpassung, die wie folgt aussieht:<\/p>\n Wir fügen also lediglich vor dem Namen der Tabelle einen Ausdruck in eckigen Klammern hinzu, der das Kennwort sowie den Pfad zur Backend-Datenbank enthält. Wenn wir das Formular frmAnmeldung <\/b>nun öffnen, erscheint dieses ohne Fehler, denn es ist auch nicht an eine der Tabellen gebunden.<\/p>\n Während der Aktualisierung des Benutzernamens bei der Eingabe der Anmeldedaten wird jedoch in der Prozedur txtBenutzername_Change <\/b>ein weiteres Recordset geöffnet, das die Tabelle tblBenutzer <\/b>als Datenquelle verwendet. Hier passen wir die Anweisung wie folgt an:<\/p>\n An dieser Stelle wird klar: Wir benötigen den Ausdruck [;PWD=kennwort;DATABASE=“ & CurrentProject.Path & „Daten.accdb] <\/b>an mehr als einer Stelle. Wir können diesen Ausdruck an jeder Stelle einfügen, an der es erforderlich ist, allerdings wartet dann eine Menge Arbeit auf uns, wenn sich der Pfad der Backend-Datenbank ändert – oder auch das Kennwort dieser Datenbank. Also erstellen wir dazu zunächst eine einfache Funktion, welche uns die gewünschte Zeichenkette zusammenstellt:<\/p>\n Der Zugriff auf diese Funktion sieht in der Anweisung aus dem ersten Beispiel wie folgt aus:<\/p>\n Und für das zweite Beispiel sieht der Aufruf so aus:<\/p>\n Der nächste Fehler lauert in der Funktion AnmeldungPruefen <\/b>im Modul mdlBenutzerverwaltung <\/b>auf uns. Hier tritt der Fehler wieder in einem Aufruf der OpenRecordset<\/b>-Methode auf. Wir machen kurzen Prozess und passen alle Aufrufe der OpenRecordset<\/b>-Methode wie oben beschrieben an.<\/p>\n Wenn wir die Schaltfläche cmdAnmelden <\/b>im Formular frmAnmeldung <\/b>betätigen, finden wir den nächsten Fehler in der folgenden DLookup<\/b>-Anweisung:<\/p>\n Welche Möglichkeit haben wir hier, um den Zugriff auf die kennwortgeschützte Backend-Datenbank zu ermöglichen Wir probieren es mit der folgenden Variante aus:<\/p>\n Wir fügen also einfach vorn an den zweiten Parameter den Ausdruck mit dem Kennwort und dem Pfad in eckigen Klammern an. Das Ergebnis ist allerdings ernüchternd und es sieht wie in Bild 6 aus.<\/p>\n Bild 6: Fehler beim Versuch, das Kennwort in die DLookup-Abfrage zu integrieren<\/span><\/b><\/p>\n Statt der gewohnten Funktion DLookup <\/b>verwenden wir eine benutzerdefinierte Version dieser Funktion, die wir PLookup <\/b>nennen (für Password-Lookup). Zunächst schauen wir uns die kleine Änderung an, die den Aufruf betrifft:<\/p>\n Die Funktion PLookup <\/b>definieren wir im Modul mdlBackend <\/b>wie folgt:<\/p>\n Die Funktion PLookup <\/b>erwartet die gleichen Parameter wie die eingebaute DLookup<\/b>-Funktion. Sie erstellt ein neues Recordset, bei dem der Abfrageausdruck aus den zu einer SELECT<\/b>-Anweisung zusammengesetzten Parametern der Funktion resultiert.<\/p>\n Dabei verwendet die Funktion beim Zusammenstellen der SELECT<\/b>-Anweisung wieder die Funktion BackendPath-Password<\/b>, welche den Ausdruck mit dem Kennwort und dem Backend-Pfad in eckigen Klammern und einen abschließenden Punkt liefert.<\/p>\n Sie können nun, ähnlich wie bei der Anpassung der Recordsets, auch alle Aufrufe der DLookup<\/b>-Funktion anpassen, indem Sie DLookup <\/b>durch PLookup <\/b>ersetzen.<\/p>\n Die Funktion BenutzerBerechtigungen <\/b>aus dem Modul mdlBenutzerverwaltung <\/b>verwendet eine SELECT<\/b>-Anweisung mit einer Abfrage als Datenquelle als Parameter einer OpenRecordset<\/b>-Methode:<\/p>\n Die Abfrage qryBenutzerBerechtigungen <\/b>referenziert logischerweise die Tabellen im Frontend beziehungsweise würde auch noch funktionieren, wenn die Verknüpfungen auf die Tabellen im Backend noch vorhanden wären.<\/p>\n Es gibt aber weder Tabellen noch Verknüpfungen im Frontend, weshalb die Abfrage nicht mehr funktionieren kann. Genau genommen können wir noch nicht einmal mehr den Entwurf ansehen – dies resultiert in der Fehlermeldung aus Bild 7.<\/p>\n Bild 7: Fehler beim Anzeigen der Entwurfsansicht einer Abfrage<\/span><\/b><\/p>\n Nach dem Schließen der Fehlermeldung erscheint immerhin noch die SQL-Ansicht der Abfrage (siehe Bild 8). Wir haben aber keine Möglichkeit, etwa über eine Eigenschaft festzulegen, dass die Abfrage auf die in der Backend-Datenbank befindlichen Tabellen zugreifen soll.<\/p>\n Bild 8: SQL-Ansicht der Abfrage<\/span><\/b><\/p>\n Wir wollen nun für jede Abfrage eine Funktion im Modul mdlBackend<\/b> hinterlegen, welche den SQL-Code der Abfrage enthält und die Klausel mit dem Pfad und dem Kennwort zur Angabe der Quelltabellen hinzufügt. Dazu vereinfachen wir die Abfrage zunächst, indem wir Alias-Bezeichnungen für die Felder im FROM<\/b>-Teil angeben und diese in der Feldliste und in den übrigen Bereichen wie den Kriterien und den Sortierungen nutzen. Vorher sieht die Abfrage noch wie folgt aus:<\/p>\n Nach den Änderungen erscheint diese schon etwas aufgeräumter:<\/p>\n <\/p>\n Hier fügen wir nun innerhalb der wie folgt zu definierenden Funktion noch dynamisch den Inhalt der Funktion BackendPathPassword <\/b>ein (siehe Listing 1). Und das ist auch der Grund, warum wir mit dem Schlüsselwort AS <\/b>angegebene Alias-Bezeichnungen für die Tabellen arbeiten. Wenn wir immer die vollen Tabellennamen verwenden würden, müssten wir vor jedem Tabellennamen den Inhalt der Funktion BackendPathPassword <\/b>einfügen. Wichtig ist noch, dass der SQL-String nicht mit einem Semikolon abschließt – gegebenenfalls wollen wir ja noch eine –WHERE<\/b>– oder ORDER BY<\/b>-Klausel anhängen.<\/p>\n Listing 1: Funktion zum Zusammenstellen der Abfrage qryBenutzerBerechtigungen<\/span><\/b><\/p>\n Das Ergebnis der Funktion sieht wie in Listing 2 aus.<\/p>\n Listing 2: Die fertige Abfrage qryBenutzerBerechtigungen<\/span><\/b><\/p>\n In der Funktion BenutzerBerechtigungen <\/b>fügen wir die Funktion qryBenutzerBerechtigungen <\/b>nun wie folgt in die OpenRecordset<\/b>-Methode ein:<\/p>\n Hier müssen wir auch noch den Tabellen-Alias für die beiden Parameter eintragen, also t2.BenutzerID <\/b>statt BenutzerID <\/b>und t1.Tabelle <\/b>statt Tabelle<\/b>. Sie sehen: So richtig komfortabel und einfach ist es nicht, es sind schon einige Anpassungen nötig.<\/p>\n Bei den gebundenen Formularen, also solchen Formularen, deren Eigenschaft Datensatzquelle <\/b>die Tabelle oder Abfrage angibt, deren Daten das Formular anzeigen soll, verlieren wir den Komfort, den die Datenbindung bietet. So müssen Sie die Eigenschaft Datensatzquelle <\/b>leeren und die Bindung an die Tabelle oder Abfrage über die Zuweisung eines Recordset<\/b>-Objekts an die VBA-Eigenschaft Recordset <\/b>erledigen.<\/p>\n Dadurch entfällt auch der Komfort, die Felder der Datensatzquelle einfach aus der Feldliste in das Formular zu ziehen.<\/p>\n Andererseits können Sie die Formulare auch zuerst bei aktivierter Datenbindung entwerfen und erst nach der Fertigstellung die Datenbindung entfernen.<\/p>\n Dazu müssten Sie natürlich temporär auch wieder die Tabellen in das Frontend holen – entweder als lokale Tabelle oder als Verknüpfung zur Tabelle im Backend.<\/p>\n Wir gehen an dieser Stelle davon aus, dass etwa das Formular frmKunden <\/b>aktuell an die Tabelle tblKunden <\/b>gebunden ist.<\/p>\n In diesem Fall führt das Öffnen des Formulars nach dem Entfernen der Tabellen und Verknüpfungen aus dem Frontend zu der Fehlermeldung Die auf diesem Formular oder in diesem Bericht angegebene Datensatzquelle “tblKunden“ ist nicht vorhanden<\/b>. <\/p>\n Danach wird das Formular in der Entwurfsansicht angezeigt, wo auch gleich alle gebundenen Felder markiert sind. Ein Klick auf die Schaltfläche mit dem Ausrufezeichen aus Bild 9 zeigt den Grund für die Markierung – die für die Eigenschaft Steuerelementinhalt <\/b>angegebenen Felder sind nicht in der Feldliste vorhanden.<\/p>\n Bild 9: Meldung bei Steuerelementen mit fehlerhaftem Steuerelementinhalt<\/span><\/b><\/p>\n Damit das Formular die Daten der Tabelle tblKunden <\/b>aus dem Backend anzeigt, sind zwei Schritte nötig: das Entfernen der Tabelle tblKunden <\/b>aus der Eigenschaft Datensatzquelle<\/b> und das Erstellen und Zuweisen eines geeigneten Recordsets.<\/p>\n Nach dem Leeren der Eigenschaft Datensatzquelle <\/b>verschwinden interessanterweise die Markierungen der gebundenen Steuer-elemente im Formular.<\/p>\n Offensichtlich prüft Access also nur bei Vorhandensein einer Tabelle oder Abfrage, ob die für die Eigenschaft Steuerelementinhalt <\/b>angegebenen Felder in der Feldliste enthalten sind. <\/p>\n Damit das Formular nun die Daten der Tabelle tblKunden <\/b>anzeigt, hinterlegen wir für die Ereigniseigenschaft Beim Laden <\/b>die Prozedur aus Listing 3. Diese füllt ein Database<\/b>-Objekt namens db<\/b>, das die aktuelle Datenbank referenziert.<\/p>\n Listing 3: Zuweisen eines Recordsets beim Laden des Formulars<\/span><\/b><\/p>\n Mit der OpenRecordset<\/b>-Methode öffnet die Prozedur dann ein Recordset auf Basis der Tabelle tblKunden<\/b>, wobei wieder die Funktion BackendPathPassword <\/b>verwendet wird, um Pfad und Kennwort der Datenbank in eckigen Klammern anzugeben.<\/p>\n Damit landen dann die gewünschten Daten in den Steuerelementen des Formulars und über die Navigationsleiste können Sie auch durch die Datensätze blättern (siehe Bild 10).<\/p>\n Bild 10: Per Recordset zugewiesene Datensatzquelle im Formular frmKunden<\/span><\/b><\/p>\n Als Nächstes schauen wir uns das Formular frmBenutzerVerwalten <\/b>an, das nicht nur an die Tabelle tblBenutzer <\/b>gebunden ist, sondern in zwei Listenfeldern noch die über die Tabelle tblGruppenzuordnungen <\/b>zugewiesenen und nicht zugewiesenen Benutzergruppen aus der Tabelle tblBenutzergruppen <\/b>anzeigen soll. Das Formular sieht im Entwurf wie in Bild 11 aus. Beim Anzeigen in der Formularansicht erscheint auch hier zunächst eine Fehlermeldung, die darauf hinweist, dass die als Datensatzquelle angegebene Tabelle tblBenutzer <\/b>nicht vorhanden ist.<\/p>\n Bild 11: Das Formular frmBenutzerVerwalten mit zwei Listenfeldern<\/span><\/b><\/p>\n Auch hier leeren wir die Eigenschaft Datensatzquelle <\/b>und hinterlegen eine entsprechende Ereignisprozedur für das Ereignis Beim Laden <\/b>des Formulars. Diesmal weisen wir der Eigenschaft Recordset <\/b>die Daten der Tabelle tblBenutzer <\/b>zu. Die entscheidende Anweisung sieht dann wie folgt aus:<\/p>\n Der nächste Versuch, das Formular in der Formularansicht anzuzeigen, liefert mehrere Fehler wegen der fehlenden Datensatzherkünfte der beiden Listenfelder lstZugewiesen <\/b>und lstNichtZugewiesen<\/b>. Das Listenfeld lstZugewiesen <\/b>verwendet etwa die folgende Abfrage als Datensatzherkunft:<\/p>\n Für das Listenfeld lstNichtZugewiesen <\/b>sieht die Datensatzherkunft noch etwas umfangreicher aus:<\/p>\n Diese Datensatzherkünfte entfernen wir aus den jeweiligen Eigenschaften der Listenfeld-Steuerelemente und erweitern stattdessen die Ereignisprozedur Form_Load <\/b>wie in Listing 4. Hier haben wir auch wieder AS<\/b>-Bezeichnungen für alle verwendeten Tabellen vergeben (t1<\/b>, t2<\/b>, …) und an den relevanten Stellen die Funktion BackendPathPassword <\/b>eingefügt.<\/p>\n Listing 4: Zuweisen der Recordsets der beiden Listenfelder<\/span><\/b><\/p>\n Wenn wir das Formular nun in der Formularansicht öffnen, zeigt dieses bereits alle Daten aus den Tabellen des Backends an (siehe Bild 12).<\/p>\n Bild 12: Anzeige aller gewünschten Daten in Steuerelementen und Listenfeldern<\/span><\/b><\/p>\n Wenn wir dann allerdings etwa auf einen der Einträge im rechten Listenfeld klicken, erscheint die Fehlermeldung aus Bild 13.<\/p>\n Bild 13: Fehler bei Ausführen einer Aktionsabfrage<\/span><\/b><\/p>\n Diesen verhindern wir, indem wir wie in Listing 5 die Funktion BackendPathPassword<\/b> in die Prozedur integrieren, die durch den Doppelklick auf einen der Einträge des Listenfeldes lstNichtZugewiesen <\/b>ausgelöst wird. Das Gleiche erledigen wir auch für die Aktionsabfrage, die wir mit der Execute<\/b>-Methode in der Prozedur lstZugewiesen_DblClick <\/b>aufrufen.<\/p>\n Listing 5: Anpassen der Prozedur lstNichtZugewiesen_DblClick<\/span><\/b><\/p>\n Nun erscheint keine Fehlermeldung mehr, wenn wir doppelt auf einen der Einträge der beiden Listenfelder klicken. Allerdings werden die Inhalte der Listenfelder allerdings auch trotz Aufruf der Requery<\/b>-Methode nicht aktualisiert. Also gliedern wir die Anweisungen, mit denen wir die Listenfelder durch Zuweisen der Recordsets zur Recordset-Eigenschaft gefüllt haben, in eine eigene Prozedur aus. Diese sieht wie in Listing 6 aus.<\/p>\n Listing 6: Die Prozedur zum Aktualisieren der Listenfelder<\/span><\/b><\/p>\n Den Aufruf platzieren wir beispielsweise wie folgt in der Prozedur lstNichtZugewiesen_DblClick<\/b>:<\/p>\n Außerdem ersetzen wir die Requery<\/b>-Methoden in der Prozedur lstZugewiesen_DblClick <\/b>durch den Aufruf der Prozedur ListenfelderAktualisieren<\/b>.<\/p>\n Und auch die Prozedur Form_Load<\/b>, die bisher die Anweisung der Prozedur ListenfelderAktualisieren <\/b>enthielt, können wir merklich verkürzen, indem wir den Aufruf der Prozedur ListenfelderAktualisieren <\/b>statt der darin enthaltenen Anweisungen einfügen:<\/p>\n![\"Verknüpfungen](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_002.png\")
<\/p>\nSchützen der Backend-Datenbank durch ein Kennwort<\/h2>\n
![\"Zuweisen](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_003.png\")
<\/p>\n![\"Festlegen](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_004.png\")
<\/p>\nErsetzen der Bindung durch Zuweisen von Recordsets<\/h2>\n
![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_005.png\")
<\/p>\nSet<\/span> rst = db.OpenRecordset(\"SELECT Benutzername FROM tblBenutzer\", dbOpenDynaset)<\/pre>\nSet<\/span> rst = db.OpenRecordset(\"SELECT Benutzername FROM [;PWD=kennwort;DATABASE=\" & CurrentProject.Path _\r\n & \"Daten.accdb].tblBenutzer\", dbOpenDynaset)<\/pre>\nSet<\/span> rstBenutzer = db.OpenRecordset(\"SELECT * FROM [;PWD=kennwort;DATABASE=\" & CurrentProject.Path _\r\n & \"Daten.accdb].tblBenutzer WHERE Benutzername = ''\" & strBenutzername & \"''\", dbOpenDynaset)<\/pre>\nPublic Function <\/span>BackendPathPassword() As String<\/span>\r\n BackendPathPassword = \"[;PWD=kennwort;DATABASE=\" _\r\n & CurrentProject.Path & \"Daten.accdb].\"\r\nEnd Function<\/span><\/pre>\nSet<\/span> rst = db.OpenRecordset(\"SELECT Benutzername FROM \" & BackendPathPassword & \"tblBenutzer\", dbOpenDynaset)<\/pre>\nSet<\/span> rstBenutzer = db.OpenRecordset(\"SELECT * FROM \" _\r\n & BackendPathPassword & \"tblBenutzer WHERE Benutzername = ''\" & strBenutzername & \"''\", dbOpenDynaset)<\/pre>\nKennwortgeschützter Zugriff per DLookup<\/h2>\n
lngBenutzerID = DLookup(\"BenutzerID\", \"tblBenutzer\", \"Benutzername = ''\" & strBenutzername & \"''\")<\/pre>\n
lngBenutzerID = DLookup(\"BenutzerID\", BackendPathPassword & \"tblBenutzer\", _\r\n \"Benutzername = ''\" & strBenutzername & \"''\")<\/pre>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_006.png\")
<\/p>\nPLookup statt DLookup<\/h2>\n
lngBenutzerID = PLookup(\"BenutzerID\", \"tblBenutzer\", \"Benutzername = ''\" & strBenutzername & \"''\")<\/pre>\n
Public Function <\/span>PLookup(strField As String<\/span>, strTable As String<\/span>, strCriteria As String<\/span>) As Variant<\/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 \" & strField & \" FROM \" & BackendPathPassword & strTable _\r\n & \" WHERE \" & strCriteria, dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n PLookup = rst.Fields(0)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nAbfragen anpassen<\/h2>\n
Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM qryBenutzerBerechtigungen WHERE BenutzerID = \" _\r\n & lngBenutzerID & \" AND Tabelle = ''\" & strTabelle & \"''\", dbOpenDynaset)<\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_007.png\")
<\/p>\n![\"SQL-Ansicht](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_008.png\")
<\/p>\nSELECT tblBenutzer.BenutzerID, tblBenutzer.Benutzername, tblTabellen.Tabelle, tblBerechtigungen.Berechtigung, tblBerechtigungszuordnungen.BerechtigungID FROM tblTabellen INNER JOIN (tblBenutzer INNER JOIN ((tblBerechtigungen INNER JOIN (tblBenutzergruppen INNER JOIN tblBerechtigungszuordnungen ON tblBenutzergruppen.BenutzergruppeID = tblBerechtigungszuordnungen.BenutzergruppeID) ON tblBerechtigungen.BerechtigungID = tblBerechtigungszuordnungen.BerechtigungID) INNER JOIN tblGruppenzuordnungen ON tblBenutzergruppen.BenutzergruppeID = tblGruppenzuordnungen.BenutzergruppeID) ON tblBenutzer.BenutzerID = tblGruppenzuordnungen.BenutzerID) ON tblTabellen.TabelleID = tblBerechtigungszuordnungen.TabelleID;<\/pre>\n
SELECT t2.BenutzerID, t2.Benutzername, t1.Tabelle, t3.Berechtigung, t5.BerechtigungID\r\nFROM tblTabellen AS t1 \r\nINNER JOIN (tblBenutzer AS t2 INNER JOIN ((tblBerechtigungen AS t3 INNER JOIN (tblBenutzergruppen AS t4 INNER JOIN tblBerechtigungszuordnungen AS t5 ON t4.BenutzergruppeID = t5.BenutzergruppeID) ON t2.BerechtigungID = t5.BerechtigungID) INNER JOIN tblGruppenzuordnungen AS t6 ON t4.BenutzergruppeID = t6.BenutzergruppeID) ON t2.BenutzerID = t6.BenutzerID) ON t1.TabelleID = t5.TabelleID;<\/pre>\n
Public Function <\/span>qryBenutzerBerechtigungen() As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n strSQL = \"SELECT t2.BenutzerID, t2.Benutzername, t1.Tabelle, t3.Berechtigung, t5.BerechtigungID \"\r\n strSQL = strSQL & \"FROM \" & BackendPathPassword & \"tblTabellen AS t1 \"\r\n strSQL = strSQL & \"INNER JOIN (\" & BackendPathPassword & \"tblBerechtigungen AS t3 \"\r\n strSQL = strSQL & \"INNER JOIN (\" & BackendPathPassword & \"tblBenutzer AS t2 \"\r\n strSQL = strSQL & \"INNER JOIN ((\" & BackendPathPassword & \"tblBenutzergruppen AS t4 \"\r\n strSQL = strSQL & \"INNER JOIN \" & BackendPathPassword & \"tblGruppenzuordnungen AS t6 \"\r\n strSQL = strSQL & \"ON t4.BenutzergruppeID = t6.BenutzergruppeID) \"\r\n strSQL = strSQL & \"INNER JOIN \" & BackendPathPassword & \"tblBerechtigungszuordnungen AS t5 \"\r\n strSQL = strSQL & \"ON t4.BenutzergruppeID = t5.BenutzergruppeID) \"\r\n strSQL = strSQL & \"ON t2.BenutzerID = t6.BenutzerID) \"\r\n strSQL = strSQL & \"ON t3.BerechtigungID = t5.BerechtigungID) \"\r\n strSQL = strSQL & \"ON t1.TabelleID = t5.TabelleID\"\r\n qryBenutzerBerechtigungen = strSQL\r\nEnd Function<\/span><\/pre>\nSELECT t2.BenutzerID, t2.Benutzername, t1.Tabelle, t3.Berechtigung, t5.BerechtigungID \r\nFROM [;PWD=kennwort;DATABASE=C:...Daten.accdb].tblTabellen AS t1 \r\nINNER JOIN ([;PWD=kennwort;DATABASE=C:...Daten.accdb].tblBerechtigungen AS t3 \r\nINNER JOIN ([;PWD=kennwort;DATABASE=C:...Daten.accdb].tblBenutzer AS t2 \r\nINNER JOIN (([;PWD=kennwort;DATABASE=C:...Daten.accdb].tblBenutzergruppen AS t4 \r\nINNER JOIN [;PWD=kennwort;DATABASE=C:...Daten.accdb].tblGruppenzuordnungen AS t6 \r\nON t4.BenutzergruppeID = t6.BenutzergruppeID) \r\nINNER JOIN [;PWD=kennwort;DATABASE=C:...Daten.accdb].tblBerechtigungszuordnungen AS t5 \r\nON t4.BenutzergruppeID = t5.BenutzergruppeID) \r\nON t2.BenutzerID = t6.BenutzerID) \r\nON t3.BerechtigungID = t5.BerechtigungID) \r\nON t1.TabelleID = t5.TabelleID<\/pre>\n
Set<\/span> rst = db.OpenRecordset(qryBenutzerBerechtigungen & \" WHERE t2.BenutzerID = \" & lngBenutzerID _\r\n & \" AND t1.Tabelle = ''\" & strTabelle & \"''\", dbOpenDynaset)<\/pre>\nGebundene Formulare<\/h2>\n
![\"Meldung](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_009.png\")
<\/p>\nDatensatzquelle ersetzen<\/h2>\n
Private Sub <\/span>Form_Load()\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 \" & BackendPathPassword & \"tblKunden\", dbOpenDynaset)\r\n Set<\/span> Me.Recordset = rst\r\nEnd Sub<\/span><\/pre>\n![\"Per](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_010.png\")
<\/p>\nFormular mit Listenfeldern<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_011.png\")
<\/p>\nSet<\/span> rst = db.OpenRecordset(\"SELECT * FROM \" & BackendPathPassword & \"tblBenutzer\", dbOpenDynaset)<\/pre>\nSELECT tblBenutzergruppen.BenutzergruppeID, tblBenutzergruppen.Benutzergruppe, tblGruppenzuordnungen.BenutzerID FROM tblBenutzergruppen INNER JOIN tblGruppenzuordnungen ON tblBenutzergruppen.BenutzergruppeID = tblGruppenzuordnungen.BenutzergruppeID WHERE (((tblGruppenzuordnungen.BenutzerID)=[Forms]![frmBenutzerVerwalten]![BenutzerID]));<\/pre>\n
SELECT tblBenutzergruppen.BenutzergruppeID, tblBenutzergruppen.Benutzergruppe FROM tblBenutzergruppen WHERE (((tblBenutzergruppen.BenutzergruppeID) Not<\/span> In (SELECT tblBenutzergruppen.BenutzergruppeID FROM tblBenutzergruppen INNER JOIN tblGruppenzuordnungen ON tblBenutzergruppen.BenutzergruppeID = tblGruppenzuordnungen.BenutzergruppeID WHERE (((tblGruppenzuordnungen.BenutzerID)=[Forms]![frmBenutzerVerwalten]![BenutzerID])))));<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>rstLstZugewiesen As <\/span>DAO.Recordset\r\n Dim <\/span>rstLstNichtZugewiesen As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM \" & BackendPathPassword & \"tblBenutzer\", dbOpenDynaset)\r\n Set<\/span> Me.Recordset = rst\r\n Set<\/span> rstLstZugewiesen = db.OpenRecordset(\"SELECT t1.BenutzergruppeID, t1.Benutzergruppe, t2.BenutzerID FROM \" _\r\n & BackendPathPassword & \"tblBenutzergruppen AS t1 INNER JOIN \" & BackendPathPassword _\r\n & \"tblGruppenzuordnungen AS t2 ON t1.BenutzergruppeID = t2.BenutzergruppeID WHERE t2.BenutzerID = \" _\r\n & Me!BenutzerID, dbOpenDynaset)\r\n Set<\/span> Me!lstZugewiesen.Recordset = rstLstZugewiesen\r\n Set<\/span> rstLstNichtZugewiesen = db.OpenRecordset(\"SELECT t1.BenutzergruppeID, t1.Benutzergruppe FROM \" _\r\n & BackendPathPassword & \"tblBenutzergruppen AS t1 WHERE t1.BenutzergruppeID Not<\/span> In (SELECT t2.\" _\r\n & \"BenutzergruppeID FROM \" & BackendPathPassword & \"tblBenutzergruppen AS t2 INNER JOIN \" _\r\n & BackendPathPassword & \"tblGruppenzuordnungen AS t3 ON t2.BenutzergruppeID = t3.BenutzergruppeID \" _\r\n & \"WHERE t3.BenutzerID = \" & Me!BenutzerID & \")\", dbOpenDynaset)\r\n Set<\/span> Me!lstNichtZugewiesen.Recordset = rstLstNichtZugewiesen\r\nEnd Sub<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_012.png\")
<\/p>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2019_04\/pic_1196_013.png\")
<\/p>\nPrivate Sub <\/span>lstNichtZugewiesen_DblClick(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n If <\/span>Not<\/span> IsNull(Me!BenutzerID) And Not<\/span> IsNull(Me!lstNichtZugewiesen) Then<\/span>\r\n db.Execute \"INSERT INTO \" & BackendPathPassword & \"tblGruppenzuordnungen(BenutzerID, BenutzergruppeID) \" _\r\n & \"VALUES(\" & Me!BenutzerID & \", \" & Me!lstNichtZugewiesen & \")\", dbFailOnError\r\n Me!lstZugewiesen.Requery\r\n Me!lstNichtZugewiesen.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListenfelder aktualisieren<\/h2>\n
Private Sub <\/span>ListenfelderAktualisieren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstLstZugewiesen As <\/span>DAO.Recordset\r\n Dim <\/span>rstLstNichtZugewiesen As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstLstZugewiesen = db.OpenRecordset(\"SELECT t1.BenutzergruppeID, t1.Benutzergruppe, t2.BenutzerID FROM \" _\r\n & BackendPathPassword & \"tblBenutzergruppen AS t1 INNER JOIN \" & BackendPathPassword _\r\n & \"tblGruppenzuordnungen AS t2 ON t1.BenutzergruppeID = t2.BenutzergruppeID WHERE t2.BenutzerID = \" _\r\n & Me!BenutzerID, dbOpenDynaset)\r\n Set<\/span> Me!lstZugewiesen.Recordset = rstLstZugewiesen\r\n Set<\/span> rstLstNichtZugewiesen = db.OpenRecordset(\"SELECT t1.BenutzergruppeID, t1.Benutzergruppe FROM \" _\r\n & BackendPathPassword & \"tblBenutzergruppen AS t1 WHERE t1.BenutzergruppeID Not<\/span> In (\" _\r\n & \"SELECT t2.BenutzergruppeID FROM \" & BackendPathPassword & \"tblBenutzergruppen AS t2 INNER JOIN \" _\r\n & BackendPathPassword & \"tblGruppenzuordnungen AS t3 ON t2.BenutzergruppeID = t3.BenutzergruppeID \" _\r\n & \"WHERE t3.BenutzerID = \" & Me!BenutzerID & \")\", dbOpenDynaset)\r\n Set<\/span> Me!lstNichtZugewiesen.Recordset = rstLstNichtZugewiesen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstNichtZugewiesen_DblClick(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n If <\/span>Not<\/span> IsNull(Me!BenutzerID) And Not<\/span> IsNull(Me!lstNichtZugewiesen) Then<\/span>\r\n db.Execute \"...\", dbFailOnError\r\n ListenfelderAktualisieren\r\n'' Me!lstZugewiesen.Requery\r\n'' Me!lstNichtZugewiesen.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\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 \" & BackendPathPassword & \"tblBenutzer\", dbOpenDynaset)\r\n Set<\/span> Me.Recordset = rst\r\n ListenfelderAktualisieren\r\n