Access-Datenbankanwendungen sind bekanntlich niemals fertig. Das ist an sich kein Nachteil, sondern stellt eher einen Vorteil dar: Im Gegensatz zu fertigen Anwendungen, bei denen Anpassungen entweder gar nicht möglich sind oder viel Geld kosten, kann man Access-Datenbanken einfach selbst um neue Funktionen erweitern. Spannend wird das, wenn die Datenbank von mehreren Nutzern eingesetzt wird. Dann stellt sich die Frage: Wie bekomme ich die neue Version einer Datenbank am einfachsten auf die unterschiedlichen Arbeitsplätze? Das gelingt auf verschiedene Arten, und in diesem Beitrag schauen wir uns eine an, mit der das Update vom Arbeitsplatz des Benutzers aus getriggert werden soll.<\/b><\/p>\n
Wenn wir eine klassische Konstellation vorliegen haben, bei der jeder Benutzer einen eigenen Rechner hat, der an das Firmennetzwerk angeschlossen ist, ist die nachfolgende beschriebene Vorgehensweise perfekt geeignet. In diesem Fall agieren wir also als Entwickler in oder für das entsprechende Unternehmen. Es gibt noch einen anderen Fall, den wir in einem weiteren Beitrag besprechen wollen – hier ist der Entwickler selbständig und verteilt seine Anwendung an Anwender aus verschiedenen Unternehmen.<\/p>\n
Im ersten Fall würden wir die neue Version der Anwendung auf einem Server im Unternehmen platzieren, von wo aus diese dann heruntergeladen werden kann. Im zweiten Fall steht die Datenbankdatei im Internet zum Download bereit.<\/p>\n
Normalerweise startet der Benutzer seine Kopie der Datenbankanwendung, indem er eine entsprechende Verknüpfung aufruft oder doppelt auf die Datenbankdatei klickt.<\/p>\n
Wir wollen diesen Ablauf so ändern, dass er nicht direkt die eigentliche Datenbankanwendung startet, sondern dass die Verknüpfung eine Startdatenbank öffnet. Diese prüft dann, ob es eine neue Version der eigentlichen Datenbank gibt und lädt diese gegebenenfalls herunter und kopiert sie über die vorhandene Version der Anwendung.<\/p>\n
Anschließend soll die Startdatenbank die eigentliche Datenbank starten. Wenn keine neue Version vorliegt, soll die Startdatenbank einfach die vorhandene Anwendung aufrufen.<\/p>\n
Die erste Technik, die wir benötigen, ist ein automatischer Aufruf der Prozeduren zum Prüfen auf Updates und der weiteren Schritte beim Start der Startdatenbank.<\/p>\n
Das erledigen wir zuverlässig mit einem AutoExec<\/b>-Makro. Wir legen also ein neues Makro an und speichern dieses unter dem Namen AutoExec<\/b>. Dieses wird beim Starten von Access automatisch aufgerufen.<\/p>\n
Dem Makro weisen wir eine einzige Makroaktion zu. Diese heißt AusführenCode <\/b>und erhält für den Parameter Funktionsname <\/b>den Wert =StartDb()<\/b>. Das Makro sieht in der Entwurfsansicht wie in Bild 1 aus.<\/p>\n
![\"AutoExec-Makro,](\"..\/fileadmin\/_temp_\/2025_04\/pic_1556_001.png\")
<\/p>\n
Bild 1: AutoExec-Makro, das beim Start automatisch ausgeführt wird<\/span><\/b><\/p>\n Die aufzurufende Funktion gestalten wir erst einmal wie folgt:<\/p>\n Das Speichern aller Änderungen und das Schließen und erneute Öffnen der Anwendung sollte nun die Anwendung öffnen und das Meldungsfenster anzeigen.<\/p>\n Bevor wir uns die Techniken ansehen, mit denen wir eine Datenbank durch eine neuere Version ersetzen, benötigen wir erst einmal die Merkmale, mit denen wir eine neue Version erkennen können.<\/p>\n Üblicherweise verwendet man hier eine Versionsnummer, die auf unterschiedliche Arten gestaltet sein kann. Am einfachsten, auch für den hier vorgesehenen Zweck, ist ein einfacher Long<\/b>-Wert für die Version. Damit können wir schnell und einfach vergleichen: Ist der Versionswert der aktuellen Version kleiner als der entsprechenden Version der Datenbank auf dem Serverlaufwerk?<\/p>\n Gelegentlich verwendet man auch umfangreichere Versionsnummern wie 1.0.0.4<\/b>. Auch das können wir umsetzen, allerdings ist der Aufwand minimal höher, da wir Stelle für Stelle vergleichen müssen.<\/p>\n Wenn man davon ausgeht, dass es maximal eine neue Version pro Tag gibt, könnten wir auch einfach das Datum der jeweiligen Version heranziehen. Dann spielt es keine Rolle, ob wir nur einen einfachen Long<\/b>-Wert als Versionsnummer verwenden oder einen Ausdruck wie 1.0.0.4<\/b>.<\/p>\n Wir wollen an dieser Stelle Komplexität herausnehmen und verwenden einfach ein Datumsfeld als Kriterium für die Notwendigkeit, die Anwendung mit einer neueren Version zu aktualisieren. Zusätzlich wollen wir die Versionsnummer in einem weiteren Feld speichern, dem wir den Datentyp Kurzer Text <\/b>geben.<\/p>\n Die folgende Tabelle tblVersion <\/b>legen wir in der jeweiligen Produktdatenbank an.<\/p>\n Die Tabelle tblVersion<\/b> sieht in der Entwurfsansicht wie in Bild 2 aus. Hier kann man bei Bedarf noch weitere Felder hinzufügen, zum Beispiel zur Angabe von weiteren Informationen zu dieser Version wie den Neuerungen oder Fehlerkorrekturen, die in dieser Version enthalten sind.<\/p>\n Bild 2: Tabelle zum Speichern der Versionsinformationen in der Entwurfansicht<\/span><\/b><\/p>\n Wechseln wir in dieser Tabelle zur Datenblattansicht, tragen wir beispielsweise Informationen wie in Bild 3 ein.<\/p>\n Bild 3: Tabelle mit der Versionsnummer<\/span><\/b><\/p>\n Für die Versionsnummer können wir nun ein beliebiges Format verwenden. Wir sollten nur sicherstellen, dass diese korrekt erhöht werden, damit der Benutzer nicht plötzlich eine neue Version mit einer niedrigeren Versionsnummer vorfindet.<\/p>\n Der Einfachheit halber sollten die Startdatenbank und die Produktivdatenbank immer im gleichen Verzeichnis liegen.<\/p>\n So können wir von der Startdatenbank ganz einfach den Pfad zur Produktivdatenbank ermitteln, indem wir mit CurrentProject.Path <\/b>den Pfad der beiden Datenbankdateien ermitteln und dann den Namen der Produktivdatenbank anhängen.<\/p>\n Die jeweils neuere Version, durch welche die aktuell auf dem Clientrechner vorliegende Version ersetzt werden soll, wird logischerweise nicht im gleichen Verzeichnis liegen, sondern an einer zentral zugänglichen Stelle auf einem Server im Unternehmen oder auch in der Cloud. Hier müssen wir daher den kompletten Pfad in der Startdatenbank speichern.<\/p>\n Insgesamt benötigen wir also zwei Felder in einer Konfigurationstabelle, die wir der Startdatenbank hinzufügen. Diese Tabelle heißt tblKonfiguration<\/b> und enthält den Entwurf aus Bild 4.<\/p>\n Bild 4: Tabelle zum Speichern der Konfiguration der Startdatenbank<\/span><\/b><\/p>\n Das erste Feld namens DatenbanknameClient <\/b>nimmt den Namen der aktuellen Version der Datenbankdatei im aktuellen Verzeichnis der Startdatenbank auf. Das zweite Feld heißt DatenbankpfadServer <\/b>und enthält den vollständigen Pfad der zu prüfenden, gegebenenfalls aktuelleren Version der Datenbankdatei. Beide haben den Datentyp Kurzer Text<\/b>.<\/p>\n Gegebenenfalls kommt es vor, dass die 255 Zeichen eines Feldes mit dem Datentyp Kurzer Text <\/b>nicht ausreichen, um den vollständigen Pfad zu speichern. In diesem Fall haben wir zwei Möglichkeiten:<\/p>\n Bevor wir uns an die Details begeben, mit denen wir die verschiedenen Bedingungen prüfen und Aktionen durchführen, bauen wir eine Grundstruktur für den Vorgang auf. <\/p>\n Diese finden wir in Listing 1.<\/p>\n Listing 1: Hauptfunktion zum Aktualisieren einer Datenbankdatei<\/span><\/b><\/p>\n Die Funktion liefert als Ergebnis den Wert True <\/b>oder False <\/b>und außerdem mit dem Parameter strErgebnis <\/b>eine Meldung mit weiteren Details. Da strErgebnis <\/b>sowohl im Fehlerfall als auch bei Aktualisierung\/Nicht-Aktualisierung ohne Fehler geliefert wird, verwenden wir mit bolFehler <\/b>einen weiteren Parameter, der angibt, ob ein Fehler aufgetreten ist. bolFehler <\/b>wird immer auf True <\/b>eingestellt, wenn ein Ereignis eintritt, das die Prüfung der Versionen oder die Aktualisierung an sich verhindert.<\/p>\n Zu Beginn deklariert die Funktion einige Variablen für die Versionsdaten der beiden Datenbankdateien und ihre Pfade.<\/p>\n Danach lesen wir aus der Tabelle tblKonfiguration <\/b>den Pfad der zu prüfenden aktuellen Datenbankdatei auf dem Clientrechner aus. Dazu stellen wir den Pfad aus dem aktuellen Pfad der Startdatenbank und dem Namen der Datenbank aus der Tabelle zusammen und speichern diesen in der Variablen strClientpfad<\/b>.<\/p>\n Das Gleiche erledigen wir anschließend für den Pfad der Datenbank auf dem Server, die gegebenenfalls die Version auf dem Client ersetzen soll. Dieser Pfad landet in der Variablen strServerpfad<\/b>.<\/p>\n Danach folgt eine Reihe If…Then<\/b>-Bedingungen. Die erste prüft, ob die Datei aus strClientpfad <\/b>überhaupt vorhanden ist. Dazu nutzen wir die Hilfsfunktion DateiVorhanden<\/b>, die wir weiter unten beschreiben.<\/p>\n Ist die Daten nicht vorhanden, endet die Funktion hier mit Exit Function<\/b>, nachdem sie für strErgebnis <\/b>eine entsprechende Rückmeldung eingetragen hat. Anderenfalls wird die Funktion fortgesetzt.<\/p>\n Die nachfolgende Bedingung ist identisch aufgebaut und prüft das Vorhandensein der zu prüfenden Version der Datenbank auf dem Server. Auch hier gilt: Ist diese Datenbank nicht vorhanden, endet die Funktion mit einer entsprechenden Meldung.<\/p>\n Damit ist nun sichergestellt, dass beide betroffenen Datenbankdateien vorhanden sind.<\/p>\n Nun folgt eine weitere wichtige Prüfung für die beiden Datenbankdateien. Diese untersucht, ob diese nicht geöffnet sind. Das ist zumindest bei der aktuellen Clientdatenbank essenziell, da diese sonst nicht durch eine eventuell vorhandene neue Version ersetzt werden kann.<\/p>\n Diese Prüfung nehmen wir in zwei aufeinanderfolgenden If…Then<\/b>-Bedingungen vor, die jeweils die Funktion IstDatenbankGeoeffnet <\/b>nutzen.<\/p>\n Liefern beide Prüfungen den Wert True<\/b>, geht es weiter, ansonsten endet die Funktion hier wiederum mit entsprechenden Einträgen für den Parameter strErgebnis<\/b>.<\/p>\n Sind die Grundvoraussetzungen geschaffen, können wir endlich mit der Funktion NeuereVersionVorhanden <\/b>prüfen, ob die unter strServerPfad <\/b>gespeicherte Datenbankdatei in einer neueren Version vorhanden ist als die unter strClientPfad <\/b>gespeicherte.<\/p>\n Auch diese Funktion beschreiben wir weiter unten im Detail. Erwartungsgemäß führt ein negatives Ergebnis zum Abbruch der Funktion mit entsprechendem Eintrag für strErgebnis<\/b>.<\/p>\n Schließlich sind alle Bedingungen erfüllt und die Routine ruft die Funktion DatenbankAktualisiert <\/b>auf. Dieser übergeben wir die Pfade zu den beiden Datenbanken. Sie soll das eigentliche Ersetzen der alten durch die neue Version erledigen.<\/p>\n Nachfolgend beschreiben wir nun die verwendeten Funktionen.<\/p>\n Die Funktion DateiVorhanden <\/b>nimmt mit dem Parameter strPfad <\/b>den Pfad der Datei entgegen, deren Vorhandensein wir prüfen wollen.<\/p>\n Sie verwendet einen verschachtelten Aufruf der beiden Funktionen Len <\/b>und Dir<\/b>. Wenn wir der Dir<\/b>-Funktion einen Dateipfad übergeben, liefert sie bei Vorhandensein den Namen der Datei selbst zurück. Wenn nicht, liefert sie eine leere Zeichenkette.<\/p>\n Dieses Ergebnis unterziehen wir der Len<\/b>-Funktion. Bei einer leeren Zeichenkette liefert diese den Wert 0<\/b>, anderenfalls einen Wert ungleich 0<\/b>.<\/p>\n Im Falle des Wertes 0 <\/b>lautet das Ergebnis der Funktion True<\/b>, sonst False<\/b>. Da der Standardwert einer Funktion mit dem Rückgabedatentyp Boolean <\/b>gleich False <\/b>ist, könnten wir uns die explizite Zuweisung von DateiVorhanden <\/b>sparen. Allerdings wollen wir hier einmal alle Pfade abbilden.<\/p>\n Die Prüfung, ob die Dateien nicht geöffnet sind, übernimmt die Funktion IstDatenbankGeoeffnet<\/b>. Sie erwartet jeweils den Pfad der zu prüfenden Datenbankdatei.<\/p>\n Sie erstellt ein neues PrivDBEngine<\/b>-Objekt (den Grund dafür haben wir im Beitrag Prüfen, ob Datenbank geöffnet ist <\/b>(www.access-im-unternehmen.de\/1296<\/b>) beschrieben) und versucht damit, die OpenDatabase<\/b>-Methode für den angegebenen Datenbankpfad auszuführen. Nur wenn dies gelingt, ist die Datenbankdatei sicher noch nicht geöffnet:<\/p>\n Anschließend folgt die Funktion NeuereVersionVorhanden<\/b>, der wir die Pfade zu den beiden zu vergleichenden Datenbankdateien übergeben (siehe Listing 2). Sie deklariert Variablen namens datVersionAlt<\/b>, datVersionNeu<\/b>, strVersionAlt <\/b>und strVersionNeu<\/b>, um die jeweils gespeicherten Versionsdaten zu speichern.<\/p>\n Listing 2: Prüfen, ob eine neuere Version vorhanden ist<\/span><\/b><\/p>\n In einer ersten If…Then<\/b>-Bedingung holt sie mit der Funktion VersiondatumErmitteln <\/b>das Versionsdatum und die Version der Datei aus strClientpfad<\/b>. Liefert der Aufruf den Wert True<\/b>, enthält der Parameter datVersionAlt <\/b>danach das Versionsdatum dieser Datenbankdatei.<\/p>\n Nur in diesem Fall wird die Funktion fortgesetzt, anderenfalls verlassen wir diese mit Exit Function <\/b>und einer entsprechenden Meldung in strErgebnis<\/b>.<\/p>\n Konnten wir das Datum ermitteln, rufen wir VersionsdatumErmitteln <\/b>auch für die auf dem Server liegende Datenbankdatei auf. Auch hier verlassen wir die Funktion, wenn das Datum nicht ermittelt werden konnte.<\/p>\n Nur wenn beide Daten vorliegen, werden diese anschließend verglichen. Ist datVersionNeu <\/b>größer als datVersionAlt<\/b>, liefert die Funktion den Wert True <\/b>zurück. Außerdem stellt sie im Parameter strErgebnis <\/b>einen Text wie den folgenden zusammen:<\/p>\n Die Funktion VersionsdatumErmitteln <\/b>nimmt den Pfad der Datenbank sowie einige Rückgabeparameter entgegen (siehe Listing 3). Diese sollen Datum und Nummer der Version zurückliefern sowie mit strErgebnis <\/b>eine Meldung, falls etwas nicht funktioniert hat.<\/p>\n Listing 3: Ermitteln der Versionsdaten aus der Tabelle tblVersion der jeweiligen Datenbank<\/span><\/b><\/p>\n Sie deaktiviert die Fehlerbehandlung und öffnet mit OpenDatabase <\/b>die mit strDatenbankpfad <\/b>übergebene Datenbank. In dieser öffnet sie ein Recordset auf Basis der Tabelle tblVersion<\/b>. Wenn diese nicht leer ist, liest sie die Werte der Felder Versionsdatum <\/b>und Versionsnummer <\/b>in die Rückgabeparameter datVersion <\/b>und strVersion <\/b>ein. Ist die Tabelle leer, wird die Meldung Kein Versionsdatum gefunden <\/b>zurückgegeben.<\/p>\n Falls ein Fehler auftritt, weil die Datenbank oder die Tabelle nicht gefunden werden kann, wird strErgebnis <\/b>ebenfalls mit einer entsprechenden Meldung gefüllt. Anschließend schließt die Funktion alle geöffneten Elemente wieder und leert die Objektvariablen.<\/p>\n Finden wir auf dem Server eine neuere Version der Datenbankanwendung vor als auf dem Client, soll die Clientversion durch die des Servers ersetzt werden. Das erledigen wir mit der Funktion KopiereServerdateiAufClient<\/b> (siehe Listing 4).<\/p>\n Listing 4: Aktualisieren der älteren Version mit der neuen Version der Datenbankanwendung<\/span><\/b><\/p>\n Hier übergeben wir wieder die Pfade zu den beiden Dateien. Im ersten Schritt definieren wir, wie wir die vorhandene, veraltete Version der Datenbankdatei auf dem Client umbenennen wollen, damit wir die neue Version gleichen Namens vom Server kopieren können.<\/p>\n Dazu ergänzen wir einfach hinten die Zeichenkette _Kopie<\/b> und benennen die Datei mit der Name … As<\/b>-Anweisung um.<\/p>\n Wir prüfen, ob das Umbenennen erfolgreich war, indem wir auf das Vorhandensein einer Datei mit dem neuen Namen und das Fehlen der Datei mit dem alten Namen testen – wieder mithilfe der Len<\/b>– und der Dir<\/b>-Anweisung.<\/p>\n War dies erfolgreich, kopieren wir die neue Version vom Server mit der FileCopy<\/b>-Anweisung unter der Angabe des vorherigen Pfades auf den Clientrechner.<\/p>\n Ist diese Datei anschließend auf dem Client vorhanden, liefert die Funktion den Wert True<\/b> und mit strErgebnis <\/b>eine passende Meldung zurück.<\/p>\n In allen anderen Fällen erfolgt die Rückgabe des Wertes False <\/b>und einer entsprechenden Meldung mit dem Parameter strErgebnis<\/b>.<\/p>\n Weiter oben haben wir bereits die leere Funktion StartDb <\/b>angelegt, die vom AutoExec<\/b>-Makro aufgerufen wird.<\/p>\n Diese erweitern wir nun wie in Listing 5. Hier rufen wir zuerst die Funktion DatenbankAktualisieren <\/b>auf und übergeben dieser die Rückgabeparameter strErgebnis <\/b>und bolFehler<\/b>.<\/p>\nPublic Function <\/span>StartDb()\r\n MsgBox<\/span> \"Start\"\r\nEnd Function<\/span><\/pre>\nErkennen einer neuen Version<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1556_002.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1556_003.png\")
<\/p>\nStandort der Startdatenbank und der Produktivdatenbank<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1556_004.png\")
<\/p>\n\n
Grundstruktur der Aktualisierung<\/h2>\n
Public Function <\/span>DatenbankAktualisieren(ByRef strErgebnis As String<\/span>, ByRef bolFehler As Boolean<\/span>) As Boolean<\/span>\r\n Dim <\/span>strPfadClient As String<\/span>\r\n Dim <\/span>strPfadServer As String<\/span>\r\n strPfadClient = CurrentProject.Path & \"\\\" & DLookup(\"DatenbanknameClient\", \"tblKonfiguration\")\r\n strPfadServer = DLookup(\"DatenbankpfadServer\", \"tblKonfiguration\")\r\n If <\/span>Not<\/span> DateiVorhanden(strPfadClient) Then<\/span>\r\n strErgebnis = \"Client-Datei fehlt: \" & strPfadClient\r\n bolFehler = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> DateiVorhanden(strPfadServer) Then<\/span>\r\n strErgebnis = \"Server-Datei fehlt: \" & strPfadServer\r\n bolFehler = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>IstDatenbankGeoeffnet(strPfadClient) Then<\/span>\r\n strErgebnis = \"Client-Datenbank ist geöffnet.\"\r\n bolFehler = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>IstDatenbankGeoeffnet(strPfadServer) Then<\/span>\r\n strErgebnis = \"Server-Datenbank ist geöffnet.\"\r\n bolFehler = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>NeuereVersionVorhanden(strPfadClient, strPfadServer, strErgebnis) Then<\/span>\r\n If <\/span>KopiereServerdateiAufClient(strPfadClient, strPfadServer, strErgebnis) Then<\/span>\r\n strErgebnis = \"Datenbank erfolgreich aktualisiert.\" & vbCrLf<\/span> & strErgebnis\r\n DatenbankAktualisieren = True<\/span>\r\n Else<\/span>\r\n strErgebnis = \"Fehler beim Aktualisieren: \" & strErgebnis\r\n bolFehler = True<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n strErgebnis = \"Es konnte keine neue Version gefunden werden.\" & vbCrLf<\/span> & strErgebnis\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPrüfen, ob Dateien vorhanden sind<\/h2>\n
Public Function <\/span>DateiVorhanden(strPfad As String<\/span>) _\r\n As Boolean<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strPfad)) = 0 Then<\/span>\r\n DateiVorhanden = True<\/span>\r\n Else<\/span>\r\n DateiVorhanden = False<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPrüfen, ob Dateien nicht geöffnet sind<\/h2>\n
Public Function <\/span>IstDatenbankGeoeffnet(_\r\n ByVal strDatenbankpfad As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>objEngine As <\/span>DAO.PrivDBEngine\r\n Set<\/span> objEngine = New<\/span> DAO.PrivDBEngine\r\n On Error Resume Next<\/span>\r\n objEngine.OpenDatabase strDatenbankpfad, True, True<\/span>\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n IstDatenbankGeoeffnet = True<\/span>\r\n End If<\/span>\r\n Set<\/span> objEngine = Nothing\r\nEnd Function<\/span><\/pre>\nPrüfen, ob eine neuere Version vorhanden ist<\/h2>\n
Public Function <\/span>NeuereVersionVorhanden(strClientpfad As String<\/span>, strServerpfad As String<\/span>, _\r\n Optional<\/span> strErgebnis As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>datVersionAlt As Date<\/span>\r\n Dim <\/span>datVersionNeu As Date<\/span>\r\n Dim <\/span>strVersionAlt As String<\/span>\r\n Dim <\/span>strVersionNeu As String<\/span>\r\n If <\/span>VersionsdatumErmitteln(strClientpfad, datVersionAlt, strVersionAlt, strErgebnis) = False<\/span> Then<\/span>\r\n NeuereVersionVorhanden = False<\/span>\r\n strErgebnis = \"Versionsdatum von ''\" & strClientpfad & \"'' konnte nicht ermittelt werden.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>VersionsdatumErmitteln(strServerpfad, datVersionNeu, strVersionNeu, strErgebnis) = False<\/span> Then<\/span>\r\n NeuereVersionVorhanden = False<\/span>\r\n strErgebnis = \"Versionsdatum von ''\" & strServerpfad & \"'' konnte nicht ermittelt werden.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>datVersionNeu > datVersionAlt Then<\/span>\r\n NeuereVersionVorhanden = True<\/span>\r\n strErgebnis = \"Alte Version: \" & strVersionAlt & \" vom \" & datVersionAlt & vbCrLf<\/span> _\r\n & \"Neue Version: \" & strVersionNeu & \" vom \" & datVersionNeu\r\n Else<\/span>\r\n strErgebnis = \"Keine neuere Version vorhanden.\"\r\n NeuereVersionVorhanden = False<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nAlte Version: 1 vom 28.05.2025\r\nNeue Version: 2 vom 29.05.2025<\/pre>\n
Versionsdatum ermitteln<\/h2>\n
Public Function <\/span>VersionsdatumErmitteln(strDatenbankpfad As String<\/span>, ByRef datVersion As Date<\/span>, _\r\n ByRef strVersion As String<\/span>, Optional<\/span> ByRef strErgebnis As String<\/span>) As Boolean<\/span>\r\n On Error GoTo<\/span> Fehler\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = OpenDatabase(strDatenbankpfad)\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVersion\", dbOpenSnapshot)\r\n \r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n datVersion = Nz(rst!Versionsdatum, 0)\r\n strVersion = Nz(rst!Versionsnummer, 0)\r\n VersionsdatumErmitteln = True<\/span>\r\n Else<\/span>\r\n strErgebnis = \"Kein Versionsdatum gefunden.\"\r\n End If<\/span>\r\nBeenden:\r\n On Error Resume Next<\/span>\r\n If <\/span>Not<\/span> rst Is Nothing Then<\/span> rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\n Exit Function<\/span>\r\nFehler:\r\n strErgebnis = \"Fehler beim Lesen des Versionsdatums: \" & Err.Description\r\n Resume Beenden\r\nEnd Function<\/span><\/pre>\nDatenbank aktualisieren<\/h2>\n
Public Function <\/span>KopiereServerdateiAufClient(strClientpfad As String<\/span>, strServerpfad As String<\/span>, _\r\n Optional<\/span> strErgebnis As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strKopie As String<\/span>\r\n strKopie = Replace<\/span>(strClientpfad, \".accdb\", \"_Kopie.accdb\")\r\n Name strClientpfad As <\/span>strKopie\r\n If <\/span>Len<\/span>(Dir(strClientpfad)) = 0 Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strKopie)) = 0 Then<\/span>\r\n FileCopy strServerpfad, strClientpfad\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strClientpfad)) = 0 Then<\/span>\r\n KopiereServerdateiAufClient = True<\/span>\r\n Else<\/span>\r\n strErgebnis = \"Neue Version konnte nicht kopiert werden.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n strErgebnis = \"Zu aktualisierende Datenbank konnte nicht umbenannt werden\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n strErgebnis = \"Zu aktualisierende Datenbank konnte nicht umbenannt werden.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n \r\n KopiereServerdateiAufClient = True<\/span>\r\n \r\nEnd Function<\/span><\/pre>\nAufruf beim Start der Startdatenbank<\/h2>\n
Public Function <\/span>StartDb()\r\n Dim <\/span>strErgebnis As String<\/span>\r\n Dim <\/span>bolFehler As Boolean<\/span>\r\n Dim <\/span>bolStarten As Boolean<\/span>\r\n Dim <\/span>strDatenbankpfad As String<\/span>\r\n If <\/span>DatenbankAktualisieren(strErgebnis, bolFehler) = True<\/span> Then<\/span>\r\n MsgBox<\/span> strErgebnis\r\n bolStarten = True<\/span>\r\n