<\/p>\n
Wenn mehrere Benutzer über Frontend-Anwendungen an verschiedenen Arbeitsplätzen auf die Daten einer Backend-Datenbank zugreifen, ist das kein Problem. In vielen Anwendungen ist es dabei sinnvoll, die Möglichkeit zum Speichern von Optionen je Benutzer vorzusehen. Oft legt man dabei eine Tabelle namens „tblOptionen“ im Frontend an. Das ist aber nur sinnvoll, wenn auch immer der gleiche Benutzer am gleichen Frontend arbeitet – anderenfalls würde er ja die Optionen eines anderen Benutzers vorgesetzt bekommen. Oder Sie führen ein Update des Frontends durch – auch dann wären die Optionen des Benutzers nicht mehr vorhanden. Welche Alternativen dazu gibt es Sie könnten zum Beispiel die Optionen in einer Tabelle im Backend speichern und diese beim Anmelden des Benutzers auslesen und in eine lokale Optionentabelle übertragen. Oder Sie fügen dem Frontend ein lokales Backend hinzu, das nur die Daten enthält, die beim Update des Frontends nicht überschrieben werden sollen. Wie das gelingt, zeigen wir im vorliegenden Artikel.<\/b><\/p>\n
Am einfachsten ist das Speichern der Optionen eines Benutzers im Frontend. Und auch wenn wir das schon so in früheren Beiträgen propagiert haben: Die Lösung ist nur unter ganz bestimmten Rahmenbedingungen pragmatisch. Die folgenden Bedingungen würden es erlauben, die Optionen einfach in einer Tabelle namens tblOptionen <\/b>im Frontend zu speichern:<\/p>\n Es kann sein, dass beide Bedingungen erfüllt werden. Gerade wenn ein Frontend auf einem Notebook läuft, das einem Mitarbeiter fest zugeteilt ist, wird sich dort kaum ein anderer Mitarbeiter anmelden und die Access-Anwendung nutzen, der seinen eigenen Satz von Optionen erwartet. Und es gibt sicher auch Anwendungen, die bereits fertig programmiert sind und keinerlei Erweiterungen oder Änderungen mehr benötigen, sodass es schlicht und einfach keine Updates mehr zu diesen Anwendungen gibt.<\/p>\n Tatsächlich ist aber nicht sichergestellt, dass Microsoft nicht einmal einen Fehler in ein Update integriert, der die übliche Funktion von Access verhindert – und dann kann es gegebenenfalls doch einmal nötig sein, dass ein Update über die aktuelle Version mit den gespeicherten Optionen des Benutzers kopiert werden muss (tatsächlich ist genau das vor kurzem geschehen – plötzlich funktionierten nämlich Abfragen nicht mehr fehlerfrei, was sich entweder kurzfristig durch eine Änderung der Programmierung beheben ließ oder durch das Warten auf das nächste Update oder den Bugfix von Microsoft).<\/p>\n Wir gehen in diesem Beitrag zunächst davon aus, dass jeder Benutzer seinen eigenen Rechner hat und wir die Optionentabelle einfach in einem lokalen Backend anlegen. Später schauen wir uns an, wie die Lösung für das Speichern der Optionen aller Benutzer im Backend auf dem Server aussehen kann.<\/p>\n Die Optionentabelle<\/b><\/p>\n Die Optionentabelle kann unterschiedlich aufgebaut sein. Die erste Möglichkeit ist, die Optionentabelle so zu gestalten, dass jede Option fest als Feld vorgesehen ist. Das sieht dann etwa wie in Bild 1 aus. Diese Variante hat den Vorteil, dass man für jede Option den Felddatentyp individuell festlegen kann – so, wie wir es hier auch gemacht haben. <\/p>\n Bild 1: Optionstabelle mit je einem Feld pro Option<\/span><\/b><\/p>\n In dieser Variante braucht man eigentlich kein Primärschlüsselfeld, denn es gibt ja zumindest in einer Anwendung für nur einen Arbeitsplatz auch nur einen Datensatz mit Optionen. Da wir aber auch davon ausgehen müssen, dass einmal die Optionen für mehr als einen Anwender gespeichert werden müssen, haben wir vorsichtshalber schon einmal ein Primärschlüsselfeld hinzugefügt.<\/p>\n Die Alternative ist, für jede Option einen eigenen Datensatz anzulegen, der dann in einem Feld den Namen der Option enthält und in einem weiteren Feld den Optionswert. Das sieht im Entwurf wie in Bild 2 aus.<\/p>\n Bild 2: Optionstabelle mit einer Option je Datensatz<\/span><\/b><\/p>\n Der Vorteil dieser Variante ist, dass Sie für das Anlegen neuer Optionen nicht in den Entwurf des Datenmodells eingreifen müssen, sondern nur einen neuen Datensatz hinzuzufügen brauchen. Der Nachteil ist, dass wir ausschließlich Werte eines zuvor festzulegenden Datentyps als Optionswerte festlegen können. Dieser Nachteil ist aber nicht allzu gewichtig, denn wir können ja alle Datentypen auch im Textformat speichern und gegebenenfalls in den benötigten Datentyp umwandeln.<\/p>\n Optionentabelle im lokalen Backend<\/b><\/p>\n Wenn wir die Optionen updatesicher speichern wollen, müssen wir diese außerhalb des Frontends unterbringen. Updatesicher speichern bedeutet dabei, dass wir sicherstellen wollen, dass wir das Frontend durch eine neue Version ersetzen können, ohne dass die für den Benutzer der Anwendung gespeicherten Optionen verloren gehen. Das erledigen wir, indem wir die Optionentabelle in eine eigene Backenddatenbank auslagern, die wir dann im gleichen Verzeichnis wie die Frontendanwendung speichern. Wir fügen dem Frontend dann eine Verknüpfung zu dieser Tabelle hinzu, die automatisch beim Öffnen der Frontendanwendung geprüft und erneuert wird.<\/p>\n Verknüpfung beim Start aktualisieren<\/b><\/p>\n Die Aktualisierung der Verknüpfung zur Optionentabelle erledigen wir direkt beim Start der Anwendung. Dazu gibt es verschiedene Möglichkeiten, wo wir den Aufruf des dazu notwendigen VBA-Code platzieren:<\/p>\n Wir gehen an dieser Stelle davon aus, dass Sie bereits eine Frontendanwendung vorliegen haben und eine Backenddatenbank, welche die Optionentabelle enthält. Was kann bei der Verknüpfung alles geschehen und den Vorgang blockieren<\/p>\n Die folgenden Funktionen sollen all dies addressieren, um die in der Konstanten cStrOptionentabelle <\/b>angegebene Tabelle der in der Konstanten cStrOptionenbackend <\/b>angegebenen Datenbank aus dem Verzeichnis des Frontends zu verknüpfen.<\/p>\n Name von Backend und Tabelle speichern<\/b><\/p>\n Wir müssen an irgendeiner Stelle die Informationen darüber speichern, wie die Datenbankdatei mit der Optionentabelle und wie die darin enthaltene Optionentabelle heißt – was auch dem Namen der Verknüpfung für die Optionentabelle in der Frontend-Datenbank entspricht. Dazu legen wir im Modul mdlBackendoptionen<\/b>, dem wir nachfolgend die Funktionen zum Prüfen und Wiederherstellen der Verknüpfung hinzufügen, die folgenden beiden Konstanten mit dem Datentyp String <\/b>an:<\/p>\n Die Backenddatenbank soll also Backend_Op-tio-nen.accdb <\/b>heißen, als Backendtabelle mit den Optionen verwenden wir die Tabelle namens tblOptionen_Felder<\/b>.<\/p>\n Wo aber speichern wir den Pfad, in dem sich die Back-end-datenbank befindet Diesen speichern wir gar nicht, denn die Backenddatenbank mit der Optionentabelle soll sich schlicht im gleichen Verzeichnis wie die Frontenddaten-bank befinden. Und diesen ermitteln wir per VBA zur Laufzeit mit der Eigenschaft CurrentProject.Path<\/b>.<\/p>\n Prüfen, ob die Backenddatenbank vorhanden ist<\/b><\/p>\n Die erste Möglichkeit für eine Fehlfunktion ist, dass die Backenddatenbank gar nicht an Ort und Stelle ist. Das prüfen wir mit einer Funktion namens IstBackendVorhanden<\/b>. Diese stellt in der Variablen strPfad <\/b>den Pfad zum Backend zusammen, der aus dem Verzeichnis der aktuellen Datenbank und dem Datenbanknamen aus der Konstanten cStrOptionenbackend <\/b>besteht.<\/p>\n Mit der Dir<\/b>-Funktion ermitteln wir die erste Datei, die unter dieser Pfadangabe gefunden werden kann. Dies sollte die in cStrOptionenBackend <\/b>angegebene Datei liefern oder, wenn diese Datei nicht gefunden werden kann, eine leere Zeichenkette. Beides landet in der Variablen strBackenddatei<\/b>. Um zu prüfen, ob diese Variable nicht leer ist, ermitteln wir die Anzahl der Zeichen des Wertes dieser Variablen. Ist diese gleich 0<\/b>, konnte die Datei nicht im angegebenen Verzeichnis gefunden werden und die Funktion liefert den Wert False <\/b>zurück. Wenn die Zeichenkette aus strBackenddatei <\/b>jedoch eine Länge größer als 0 <\/b>aufweist, dann ist die Datei vorhanden und die Funktion liefert den Wert True <\/b>zurück:<\/p>\n Prüfen, ob die Optionentabelle im Backend vorliegt<\/b><\/p>\n Damit gehen wir einen Schritt weiter, nämlich zur Prüfung des Vorhandenseins der Optionentabelle in der Backenddatenbank. Dazu referenzieren wir die Backenddatenbank und prüfen, ob dort ein TableDef<\/b>-Objekt mit dem angegebenen Namen vorhanden ist.<\/p>\n Dazu stellen wir wieder in strPfad<\/b> den Pfad zur Backenddatenbank zusammen. Diesmal prüfen wir allerdings nicht, ob diese vorhanden ist, sondern öffnen mit der OpenDatabase<\/b>-Methode ein Database<\/b>-Objekt auf Basis dieser Datenbank und speichern dieses in der Variablen db<\/b>. Dann versuchen wir wieder, bei deaktivierter Fehlerbehandlung auf das TableDef<\/b>-Objekt aus cStrOptionenbackend <\/b>zuzugreifen. Ist die damit gefüllte Variable tdf <\/b>danach nicht leer, ist die Tabelle in der Backenddatenbank enthalten:<\/p>\n Prüfen, ob Verknüpfung vorhanden ist<\/b><\/p>\n Die erste Hilfsfunktion prüft, ob die Verknüpfung überhaupt im Frontend vorhanden ist. Sie heißt IstVerknuep-fungVorhanden <\/b>und liefert einen Rückgabewert des Typs Boolean<\/b>. Die Funktion erstellt ein Objekt mit einem Verweis auf das Database<\/b>-Objekt der Frontenddatenbank. Dann deaktiviert sie die eingebaute Fehlerbehandlung und versucht, über die TableDefs<\/b>-Auflistung des Database<\/b>-Objekts auf die Tabelle mit dem in cStrOptionenTabelle <\/b>gespeicherten Namen zuzugreifen und einen Verweis darauf mit der Variablen tdf <\/b>zu referenzieren.<\/p>\n Wir prüfen danach gar nicht erst, ob dabei ein Fehler aufgetreten ist oder nicht (ein Fehler würde beim Zugriff auf ein nicht vorhandenes TableDef<\/b>-Element ausgelöst werden), sondern aktivieren danach einfach die Fehlerbehandlung wieder und prüfen dann, ob tdf<\/b> mit einem Objektverweis gefüllt ist. Falls ja, wurde die Verknüpfung offensichtlich gefunden, falls nicht, fehlt sie in der aktuellen Datenbank:<\/p>\n Wenn die Verknüpfung gar nicht vorhanden ist, müssen wir diese anlegen. Das erledigen wir gleich in der Hauptfunktion, die auch die Funktion IstVerknuepfungVorhanden <\/b>aufruft.<\/p>\n Prüfen, ob die Verknüpfung auf die richtige Tabelle in der richtigen Datenbank verweist<\/b><\/p>\n Es kann auch sein, dass die Verknüpfung zwar vorhanden ist, aber nicht auf die richtige Tabelle verweist. Oder dass sie zwar auf die Tabelle mit dem richtigen Namen verweist, diese sich aber nicht in der richtigen Datenbank im richtigen Verzeichnis befindet.<\/p>\n Dies prüfen wir beides in der Funktion IstVerknuepfungKorrekt<\/b> (siehe Listing 1). Diese referenziert das TableDefs<\/b>-Objekt aus cStrOptionentabelle <\/b>und schreibt daraus die Inhalte der Connect<\/b>-Eigenschaft in die Variable strConnect <\/b>und der SourceTableName<\/b>-Eigenschaft in die Variable strTabelle<\/b>. Die Connect<\/b>-Eigenschaft liefert einen Ausdruck, der mit ;DATABASE= <\/b>beginnt und dann den Pfad zu der Datenbank liefert, in welcher sich die verknüpfte Tabelle befindet. Die SourceTableName<\/b>-Eigenschaft enthält den Namen der Tabelle in dieser Backenddatenbank.<\/p>\n <\/p>\n Listing 1: Prüfen, ob die Verknüpfung die richtige Datenbank und Tabelle addressiert<\/span><\/b><\/p>\n Wir prüfen zunächst, ob der Wert in strTabelle <\/b>mit dem Namen aus cStrOptionentabelle <\/b>übereinstimmt. Ist das der Fall, untersuchen wir, ob der Wert aus strConnect <\/b>mit der Zeichenkette bestehend aus ;DATABASE=<\/b>, dem Verzeichnis der aktuellen Datenbank und dem Datenbanknamen aus cStrOptionenbackend <\/b>besteht. Sind beide Bedingungen erfüllt, stellen wir den Rückgabewert der Funktion auf True <\/b>ein.<\/p>\n Prozedur zum Prüfen und Korrigieren der Verknüpfung <\/b><\/p>\n Mit diesen Hilfsfunktionen können wir nun entspannt in die Hauptprozedur einsteigen, die prüft, ob alle Bedingungen erfüllt sind und gegebenenfalls Korrekturen vornimmt, damit dies der Fall ist. Aber in welcher Reihenfolge prüfen wir die Bedingungen und wann und wie greifen wir korrigierend ein <\/p>\n Wir können beispielsweise damit einsteigen, dass wir mit der Funktion IstVerknuepfungVorhanden <\/b>prüfen, ob die Verknüpfung zur Optionentabelle überhaupt im Frontend vorliegt. Aber was tun, wenn das schon nicht der Fall ist Sollen wir diese dann einfach anlegen und dann die weiteren Bedingungen prüfen Das ist wenig sinnvoll, denn wenn wir nicht wissen, ob die Backenddatenbank überhaupt vorhanden ist, brauchen wir auch nicht die Verknüpfung zu reparieren. Also starten wir in der ersten Version der Funktion OptionentabelleVerknuepfen <\/b>bei den wesentlichen Voraussetzungen (siehe Listing 2). Die Erste lautet: Ist die Backenddatenbank überhaupt an Ort und Stelle Das prüfen wir mit der Funktion IstBackendVorhanden<\/b>. Falls ja, gehen wir mit der Prüfung der nächsten Bedingung weiter. Falls nicht, müssen wir dem Benutzer mitteilen, was nicht in Ordnung ist oder dies selbst beheben.<\/p>\n Listing 2: Prüfen aller Bedingungen in einer Funktion<\/span><\/b><\/p>\n Die nächste Bedingung prüfen wir mit der Funktion IstOptionentabelleVorhanden<\/b>. Auch hier geben wir eine Meldung aus, wenn die Bedingung nicht erfüllt wurde.<\/p>\n Liefert die Funktion jedoch den Wert True<\/b>, dann gehen wir mit der Prüfung der nächsten Bedingung weiter – also IstVerknuepfungVorhanden <\/b>– und dann mit IstVerknuep-fungKorrekt<\/b>. In beiden Fällen wird für den Wert False <\/b>eine entsprechende Meldung ausgegeben.<\/p>\n Optionentabelle verknüpfen mit Korrekturmöglichkeit<\/b><\/p>\n Nun wollen wir dem Benutzer noch die Möglichkeit geben, selbst die nicht erfüllten Bedingungen zu erfüllen und die Bedingungen dann erneut zu prüfen. Dazu müssen wir die ganzen If…Then<\/b>-Bedingungen in eine Schleife einfassen, die prüft, ob bol <\/b>den Wert True <\/b>liefert, was der Fall ist, wenn alle Bedingungen erfüllt sind. <\/p>\n Wir müssen aber auch in Erwägung ziehen, dass der Benutzer oder die Anwendung selbst die Bedingungen nicht erfüllen können – beispielsweise wenn der Benutzer die Backend-Datenbank per Dateiauswahl-Dialog auswählen soll, weil diese gegebenenfalls an einem anderen Ort liegt, an dem sich auch die Frontend-Datenbank vorher befunden hat, aber diese Datenbank nicht findet. Dann soll der Benutzer die Möglichkeit erhalten, die Schleife abzubrechen.<\/p>\n Dazu haben wir die Funktion OptionentabelleVerknuep-fen <\/b>wie in Listing 3 ordentlich aufgebohrt. Als Erstes finden wir hier die schon angesproche Do While<\/b>-Schleife, die erst abgebrochen wird, wenn die Variable bol <\/b>den Wert True <\/b>aufweist. Diese Variable wird erst in der inneren der vier verschachtelten If…Then<\/b>-Bedingungen auf True <\/b>eingestellt. Dadurch ist die Funktion noch nicht beendet, nur weil eine der vier Bedingungen nicht erfüllt ist. In diesem Fall erfolgt die für das Nichterfüllen der Bedingung vorgesehe Aktion, die wir uns gleich anschauen, und nach einer eventuellen Korrektur dieser Bedingung werden die Bedingungen nochmals geprüft.<\/p>\n Listing 3: Prüfen aller Bedingungen in einer Funktion, erweiterte Fassung<\/span><\/b><\/p>\n Wenn die erste Bedingung, das Vorhandensein der Backend-Datenbank, nicht erfüllt ist, soll der Benutzer die Gelegenheit erhalten, diese gegebenenfalls beim Verschieben liegengebliebene oder anderweitig entfernte Datenbankdatei aufzufinden und zu erlauben, diese in das Verzeichnis der Frontend-Datenbank zu kopieren.<\/p>\n Dazu haben wir im Else<\/b>-Teil dieser Bedingung den Aufruf einer Funktion namens BackendAuswaehlen <\/b>eingefügt, die wie in Listing 4 aussieht. Hier rufen wir mit der Funktion OpenFileName <\/b>einen Dateiauswahl-Dialog auf, mit dem der Benutzer ausgehend vom aktuellen Verzeichnis die Optionen-Backend-Datenbank auswählen kann. Wurde eine Datei ausgewählt, fragt die Prozedur den Benutzer, ob die gewählte Datei in das Verzeichnis der Frontend-Datenbank kopiert werden darf. Dies wird bei Bestätigung mit der Ja<\/b>-Schaltfläche durch die FileCopy<\/b>-Methode erledigt. Danach prüft die Funktion erneut durch einen Aufruf der weiter oben beschriebenen Funktion IstBackendVorhanden<\/b>, ob das Backend nun vorhanden ist und gibt in diesem Fall den Wert True <\/b>zurück.<\/p>\n Listing 4: Auswählen des Backends und Kopieren in das Datenbankverzeichnis<\/span><\/b><\/p>\n Ist dies der Fall, steigt die aufrufende Funktion OptionentabelleVerknuepfen <\/b>erneut in die Do While<\/b>-Schleife ein, wobei diesmal die Backend-Datenbank gefunden werden sollte. Damit folgt die zweite Bedingung, die – wenn die Optionentabelle nicht im Backend gefunden wird – zum Abbruch der Funktion führt mit der Meldung, dass der Benutzer sich an den Entwickler der Datenbank wenden soll. Das könnte man auch noch anders lösen, indem man die Tabelle einfach neu in der Datenbank anlegt. Allerdings wissen wir an dieser Stelle ja noch nicht einmal, wie die Optionentabelle aussieht und lassen dies daher aus.<\/p>\n Die dritte Bedingung führt dann, wenn sie nicht erfüllt ist, wieder zum Aufruf einer weiteren Funktion, nämlich VerknuepfungstabelleAnlegen<\/b>. Diese finden Sie in Listing 5. Diese Funktion erstellt ein neues TableDef<\/b>-Objekt in der Frontend-Datenbank. Sie stellt die Eigenschaft SourceTableName <\/b>auf den Wert aus cStrOptionenTabelle <\/b>ein. Außerdem legt sie den Wert der Eigenschaft Connect <\/b>auf die Zeichenkette ;DATABASE=<\/b>, das Frontend-Verzeichnis und den Namen der Datenbank aus cStrOptionenbackend <\/b>fest. Die Verknüpfung ist nun zwar erstellt, aber noch nicht an die Liste der Tabellendefinitionen angehängt. Das erledigt die Prozedur, indem sie die \n
![\"Optionstabelle](\"..\/fileadmin\/_temp_\/2020_01\/pic_1220_001.png\")
<\/p>\n![\"Optionstabelle](\"..\/fileadmin\/_temp_\/2020_01\/pic_1220_002.png\")
<\/p>\n\n
\n
Const cStrOptionenbackend As String<\/span> = \"Backend_Optionen.accdb\"\r\nConst cStrOptionentabelle As String<\/span> = \"tblOptionen_Felder\"<\/pre>\nPublic Function <\/span>IstBackendVorhanden() As Boolean<\/span>\r\n Dim <\/span>strPfad As String<\/span>\r\n Dim <\/span>strBackenddatei As String<\/span>\r\n strPfad = CurrentProject.Path & \"\" & cStrOptionenbackend\r\n strBackenddatei = Dir(strPfad)\r\n If <\/span>Not<\/span> Len<\/span>(strBackenddatei) = 0 Then<\/span>\r\n IstBackendVorhanden = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>IstOptionentabelleVorhanden() As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strPfad As String<\/span>\r\n strPfad = CurrentProject.Path & \"\" & cStrOptionenbackend\r\n Set<\/span> db = OpenDatabase(strPfad)\r\n On Error Resume Next<\/span>\r\n Set<\/span> tdf = db.TableDefs(cStrOptionentabelle)\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> tdf Is Nothing Then<\/span>\r\n IstOptionentabelleVorhanden = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>IstVerknuepfungVorhanden() As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n Set<\/span> tdf = db.TableDefs(cStrOptionentabelle)\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> tdf Is Nothing Then<\/span>\r\n IstVerknuepfungVorhanden = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>IstVerknuepfungKorrekt() As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strConnect As String<\/span>\r\n Dim <\/span>strTabelle As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> tdf = db.TableDefs(cStrOptionentabelle)\r\n strConnect = tdf.Connect\r\n strTabelle = tdf.SourceTableName\r\n If <\/span>strTabelle = cStrOptionentabelle Then<\/span>\r\n If strConnect = \";DATABASE=\" & CurrentProject.Path & \"\" _\r\n & cStrOptionenbackend Then\r\n IstVerknuepfungKorrekt = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>OptionentabelleVerknuepfen() As Boolean<\/span>\r\n Dim <\/span>bol As Boolean<\/span>\r\n If <\/span>IstBackendVorhanden Then<\/span>\r\n If <\/span>IstOptionentabelleVorhanden Then<\/span>\r\n If <\/span>IstVerknuepfungVorhanden Then<\/span>\r\n If <\/span>IstVerknuepfungKorrekt Then<\/span>\r\n bol = True<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Verknüpfung ist nicht korrekt.\"\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Verknüpfungstabelle fehlt.\"\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Tabelle '\" & cStrOptionentabelle & \"' konnte nicht in der folgenden Datenbank gefunden \" _\r\n & \"werden:\" & vbCrLf<\/span> & vbCrLf<\/span> & CurrentProject.Path & \"\" & cStrOptionenbackend\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Datenbank '\" & cStrOptionenbackend & \"' mit der Optionentabelle konnte nicht gefunden werden.\"\r\n End If<\/span>\r\n OptionentabelleVerknuepfen = bol\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>OptionentabelleVerknuepfen() As Boolean<\/span>\r\n Dim <\/span>bol As Boolean<\/span>\r\n Do While<\/span> bol = False<\/span>\r\n If <\/span>IstBackendVorhanden Then<\/span>\r\n If <\/span>IstOptionentabelleVorhanden Then<\/span>\r\n If <\/span>IstVerknuepfungVorhanden Then<\/span>\r\n If <\/span>IstVerknuepfungKorrekt Then<\/span>\r\n bol = True<\/span>\r\n Else<\/span>\r\n VerknuepfungKorrigieren\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> VerknuepfungstabelleAnlegen Then<\/span>\r\n MsgBox<\/span> \"Die Verknüpfungstabelle '\" & cStrOptionentabelle & \"' konnte nicht angelegt \" _\r\n & \"werden. Wenden Sie sich an den Entwickler.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Tabelle '\" & cStrOptionentabelle & \"' konnte nicht in der folgenden Datenbank \" _\r\n & \"gefunden werden:\" & vbCrLf<\/span> & vbCrLf<\/span> & CurrentProject.Path & \"\" & cStrOptionenbackend & vbCrLf<\/span> _\r\n & vbCrLf<\/span> & \"Setzen Sie sich mit dem Hersteller in Verbindung, um die Optionendatenbank \" _\r\n & \"wiederherzustellen.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Datenbank '\" & cStrOptionenbackend & \"' mit der Optionentabelle konnte nicht gefunden \" _\r\n & \"werden. Wählen Sie diese nun selbst aus.\"\r\n If <\/span>BackendAuswaehlen = False<\/span> Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n OptionentabelleVerknuepfen = bol\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>BackendAuswaehlen() As Boolean<\/span>\r\n Dim <\/span>strPfad As String<\/span>\r\n strPfad = OpenFileName(CurrentProject.Path, \"Optionen-Backend auswählen:\", \"Access-Datenbank (*.accdb)\")\r\n If <\/span>Not<\/span> Len<\/span>(strPfad) = 0 Then<\/span>\r\n If MsgBox<\/span>(\"Die Backenddatenbank wird nun in das Verzeichnis der aktuellen Datenbank kopiert. Fortsetzen\", _\r\n vbYesNo) = vbYes Then\r\n FileCopy strPfad, CurrentProject.Path & \"\" & cStrOptionenbackend\r\n If <\/span>IstBackendVorhanden Then<\/span>\r\n BackendAuswaehlen = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n