<\/p>\n
Wer seine Datenbank in Front- und Backend aufteilt, möchte die im Backend befindlichen Daten möglicherweise hin und wieder komprimieren. Vielleicht sollen die Daten im Backend gar durch ein Kennwort geschützt sein, um unbefugten Zugriff ohne Frontend zu verhindern. Und andere würden gern kennwortgeschützte Backends auch noch automatisch komprimieren. Wie all dies geht, zeigt dieser Beitrag.<\/b><\/p>\n
Eine Datenbank ist schnell in Frontend und Backend aufgeteilt. Am einfachsten geht dies mit dem Assistenten zur Datenbankaufteilung (Access 2003 und älter: Extras|Datenbank-Dienstprogramme|Assistent zur Datenbankaufteilung<\/b>, Access 2007: Daten verschieben|Access-Datenbank<\/b>). Versierte Anwender oder solche mit speziellen Anforderungen an die Aufteilung der Datenbank importieren die Tabellen erst in das zukünftige Backend und löschen diese aus dem Frontend, bevor Sie das Frontend mit den Tabellen im Backend verknüpfen.<\/p>\n
Komprimieren kann man Datenbanken ganz schnell, indem man unter Access 2003 und älter den Menübefehl Extras|Datenbank-Dienstprogramme|Datenbank komprimieren und reparieren <\/b>und unter Access 2007 den Office-Menü-Eintrag Verwalten|Datenbank komprimieren und reparieren <\/b>aufruft (ganz früher waren die Funktionen Komprimieren <\/b>und Reparieren <\/b>noch separat verfügbar). Das Komprimieren sorgt im Wesentlichen dafür, dass erstellte und wieder gelöschte Daten auch endgültig aus der Datenbankdatei entfernt, sowie Indizes intern neu sortiert werden.<\/p>\n
Eine Datenbank schützen Sie mit einem Kennwort, indem Sie unter Extras|Sicherheit|Datenbankkennwort festlegen… <\/b>(Access 2003 und älter) oder Datenbanktools|Datenbanktools|Mit Kennwort verschlüsseln <\/b>(Access 2007) den Dialog zum Eingeben eines Datenbankkennworts verwenden.<\/p>\n
Backend mit Kennwort ausstatten<\/b><\/p>\n
Kombiniert wird das schwieriger, aber nur ein wenig: Wenn Sie das Backend einer Datenbankkombination mit einem Kennwort schützen möchten, um den Inhalt seiner Tabellen vor den Augen Neugieriger zu verbergen, können Sie dies wie gewohnt erledigen.<\/p>\n
Wenn Sie das nächste Mal vom Frontend aus auf die verknüpften Tabellen zugreifen möchten, misslingt dies allerdings. Access meldet dann ganz lapidar: Kein gültiges Kennwort<\/b>. Aha, kein gültiges Kennwort. Eigentlich gab es ja gar keine Gelegenheit, eines einzugeben – zumindest keine offensichtliche. Dies fand implizit im Hintergrund statt: Wenn beim Versuch, auf eine verknüpfte Tabelle eines verschlüsselten Backends zuzugreifen, kein Kennwort übergeben wird, dann wird halt ein leeres Kennwort angenommen.<\/p>\n
Immerhin lässt sich die Verknüpfung löschen und neu anlegen. Dann erscheint auch der Dialog aus Bild 1 und fragt das Kennwort ab. Gibt man hier die richtige Zeichenfolge ein, verknüpft Access die Tabelle ordnungsgemäß – allerdings mit einem kleinen Unterschied gegenüber der Verknüpfung mit einer Tabelle aus einem ungeschützten Backend. Den Unterschied sehen Sie, wenn Sie die Systemtabelle MSysObjects <\/b>öffnen (vorher müssen Sie diese sichtbar machen, das geschieht unter Access 2003 und älter im Optionen<\/b>-Dialog mit der Option Systemobjekte <\/b>im Bereich Ansicht|Anzeigen<\/b>, unter Access 2007 im Dialog Navigationsoptionen<\/b>, den Sie über das Kontextmenü der Titelleiste des Navigationsbereichs erreichen).<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_02\/BackendsKomprimierenUndVerschluesseln-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Dialog beim Verknüpfen mit einer Tabelle einer anderen Datenbank<\/span><\/b><\/p>\n Für eine verknüpfte Tabelle aus einer kennwortgeschützten Datenbank finden Sie in der Spalte Connect<\/b> einen Eintrag vor, der das Kennwort im Klartext preisgibt – keine gute Sicherung, wenn der Benutzer Vollzugriff auf das Frontend hat (siehe Bild 2). Dieser Abwehrmechanismus greift also höchstens, wenn der Benutzer nicht weiß, wo er solche Informationen findet. Davon abgesehen ist es aber auch egal: Wenn Sie ein Backend per Kennwort schützen und mit einem Frontend darauf zugreifen, kann der Benutzer darüber ja auch auf die Daten im Backend zugreifen – außer Sie verhindern den Zugriff auf das Datenbankfenster (was aber nicht Thema dieses Beitrags sein soll).<\/p>\n Bild 2: Das Kennwort des Backends wird in der Systemtabelle MSysObjects unverschlüsselt angezeigt.<\/span><\/b><\/p>\n Tabelle aus kennwortgeschütztem Backend wieder einbinden<\/b><\/p>\n Wenn Sie die Verknüpfung zu einer Tabelle aus einem kennwortgeschützten Backend aktualisieren möchten, verwenden Sie die Routine aus Listing 1. Der Unterschied zur herkömmlichen Vorgehensweise ist, dass die Connect-Zeichenfolge den zusätzlichen Parameter pwd <\/b>mit dem entsprechenden Kennwort enthält.<\/p>\n Listing 1: Verknüpfung kennwortgeschützter Tabellen<\/p>\n <\/p>\n Wenn die Routine ein falsches Kennwort verwendet, löst dies Fehler 3031<\/b>, Kein zulässiges Kennwort, <\/b>aus.<\/p>\n Backend per VBA komprimieren und reparieren<\/b><\/p>\n Wer eine einzige Datenbank verwendet, die Benutzeroberfläche und Tabellen enthält, braucht sich um das Komprimieren keine Sorgen zu machen: Er aktiviert einfach die Option Beim Schließen komprimieren<\/b>, die unter Access 2003 und älter im Bereich Allgemein <\/b>des Optionen-Dialogs und unter Access 2007 in den Access-Optionen unter Aktuelle Datenbank|Anwendungsoptionen <\/b>zu finden ist.<\/p>\n Beim Betrieb einer Frontend-\/Backend-Lösung ist das schon schwieriger: Sie können zwar für beide Teile separat die Option zum automatischen Komprimieren einstellen, helfen wird dies aber nur im Frontend.<\/p>\n Das Backend wird nicht wie eine herkömmliche Datenbank geöffnet, sondern das Frontend greift nur per Jet auf seine Daten zu (wenn dies geschieht, erkennen Sie das an der im gleichen Verzeichnis wie die Datenbank liegenden .ldb<\/b>– beziehungsweise .laccdb<\/b>-Datei – diese Dateien enthalten Informationen über die Rechner und Benutzernamen der aktuell zugreifenden Instanzen).<\/p>\n Wer das Backend hin und wieder komprimieren muss, kann prinzipiell auf drei Arten vorgehen: Entweder per VBA vom Frontend aus, per VBScript, das durch den Taskplaner von Windows aus aufgerufen wird, oder von Hand.<\/p>\n Der Code für den Aufruf aus einer Access-Datenbank sieht aus wie in Listing 2. Die Routine liest zunächst aus der Systemtabelle MSysObjects <\/b>den Pfad einer der verknüpften Tabellen aus und speichert diesen in der Variablen strBackend<\/b>. Nach einer Prüfung, ob die ermittelte Datei überhaupt vorhanden ist, schreibt die Routine den Pfad, die Dateiendung und den Namen für eine temporäre komprimierte Version der Datenbank in entsprechende Variablen. Dann führt die Methode CompactDatabase <\/b>des DBEngine<\/b>-Objekts die Komprimierung aus, indem sie die komprimierte Version der Datenbank unter dem zuvor ermittelten Namen speichert.<\/p>\n Listing 3: Schematische Darstellung des geplanten Shutdown<\/p>\n Die alte Version wird unter einem Dateinamen im Format <AlterDateiname>_Old_<yyyymmdd_hhnnss>.<Dateiendung> <\/b>abgelegt und die temporär erstellte komprimierte Version erhält den alten Namen der komprimierten Datenbankdatei.<\/p>\n Beim Ausführen dieser Prozedur kann es zum Fehler aus Bild 3 kommen, wenn das aktuelle oder ein anderes Frontend auf die Tabellen des Backends zugreift.<\/p>\n Bild 3: Dieser Fehler tritt auf, wenn man versucht, ein Backend während des Zugriffs per VBA-Code zu komprimieren.<\/span><\/b><\/p>\n Sie müssen also etwas unternehmen, um alle aktuell auf das Backend zugreifenden Frontends zu schließen – oder Sie führen eine Komprimierung gleich zu einem Zeitpunkt aus, an dem man sicher sein kann, dass kein Benutzer auf das Backend zugreift, zum Beispiel nachts. Natürlich kann es bei mehreren Mitarbeitern passieren, dass mal einer vergisst, den Rechner herunterzufahren und die Datenbank zu schließen, die auf das betroffene Backend zugreift – aber wenn das tägliche Komprimieren der Daten so wichtig ist, weil etwa sehr eng am Limit von zwei Gigabyte gearbeitet wird, sollte man ohnehin eine Alternative ins Auge fassen.<\/p>\n Frontends automatisch schließen<\/b><\/p>\n Wenn Sie sich entschließen, das Backend zu komprimieren (oder auch zu sichern), während möglicherweise noch Mitarbeiter darauf zugreifen, können Sie zu einer recht eleganten Lösung greifen (Idee aus http:\/\/support.microsoft.com\/kb\/304408\/en-us<\/b>). Diese geht davon aus, dass die Frontends ein offenes Formular verwenden (das zum Beispiel direkt beim Starten der Anwendung geöffnet und unsichtbar geschaltet werden kann), das über das Bei Zeitgeber<\/b>-Ereignis in regelmäßigen Abständen prüft, ob eine bestimmte Datei im Verzeichnis des Backends liegt. Falls nicht, schlägt dieses Formular Alarm und zeigt eine Meldung an, dass in kurzer Zeit eine Komprimierung oder Sicherung des Backends ansteht und die Frontends geschlossen werden sollen. Geschieht dies nicht, werden die Frontends automatisch beendet.<\/p>\n Die Datei, deren Vorhandensein die Timer<\/b>-Prozedur prüft, wird natürlich von der Instanz, welche die Komprimierung oder Sicherung anstößt, entfernt und nach der Komprimierung wieder erzeugt, damit die Datenbanken wieder wie gewohnt arbeiten.<\/p>\n Die Routine zum Prüfen der Datei sieht wie in Listing 3 aus. Damit diese beim Öffnen eines Formulars namens frmShutdown <\/b>alle zehn Sekunden ausgeführt wird, stellen Sie die Eigenschaft Zeitgeberintervall <\/b>auf 10.000 <\/b>ein – die Eigenschaft erwartet ihren Wert in Millisekunden.<\/p>\n Die Routine prüft also nun alle zehn Sekunden, ob die Datei Shutdown.txt <\/b>noch im Verzeichnis des Backends liegt. Ist das nicht der Fall, stellt die Routine das TimerInterval <\/b>auf eine Sekunde um und zeigt jede Sekunde die neue verbleibende Zeit bis zum Shutdown in der Statusleiste der Anwendung an (normalerweise würden Sie ein auffälliges Formular für diesen Zweck verwenden, wie Sie es etwa im Beitrag Transparenz und sonstige Effekte<\/b>, Shortlink 655, vorfinden).<\/p>\n Das Formular frmShutdown <\/b>muss beim Öffnen der Anwendung ebenfalls geöffnet werden (entweder per AutoExec<\/b>-Makro oder als Startformular beziehungsweise im Zuge des Öffnens eines Startformulars). Damit das Formular gar nicht erst sichtbar wird, verwenden Sie dazu den folgenden Aufruf:<\/p>\n Um die Datenbank in der Routine aus Listing 3 tatsächlich zu schließen, verwenden Sie statt des MsgBox<\/b>-Aufruf diese Anweisung:<\/p>\n Backend beim Schließen des letzten Frontends komprimieren<\/b><\/p>\n Wenn man nicht gerade im Schichtdienst an dem zu komprimierenden Backend arbeitet, kann man es vielleicht auch so einrichten, dass das Frontend beim Schließen prüft, ob es das letzte Frontend ist, das auf die Backend-Datenbank zugreift, und dieses schließlich per Code komprimiert.<\/p>\n Dazu müssen Sie ebenfalls ein Formular unsichtbar beim Start des Frontends öffnen, das lediglich ein Ereignis enthält. Dieses heißt Beim Entladen <\/b>und prüft, ob sich das Backend noch im Zugriff befindet. Falls nicht, führt es direkt im Anschluss die Komprimierung durch.<\/p>\n Genaugenommen ist die Geschichte mit dem unsichtbaren Formular und dem Entladen-Ereignis eine Möglichkeit, das Beenden von Access mitzubekommen und notwendige Aktionen durchzuführen – genau richtig für unsere Zwecke.<\/p>\n Es ergibt sich nur ein Problem: Wie erkennen wir, ob das Backend auch tatsächlich nicht mehr in Benutzung ist Nun: Wenn das Backend noch in Beschlag ist, dann gibt es auch eine offene .ldb<\/b>– beziehungsweise .laccdb<\/b>-Datei.<\/p>\n Wenn Sie das aktuelle Datenbankfrontend schließen und in einem speziell dafür vorgesehenen Formular prüfen wollen, ob das Backend frei ist, müssen Sie natürlich auch in der aktuellen Datenbank die notwendigen Voraussetzungen schaffen, indem Sie alle Formulare und sonstige Elemente schließen, die an die Tabellen des Backends gebunden sein könnten.<\/p>\n Danach sollte man gegebenenfalls noch eine Sekunde einplanen, die für das Löschen der .ldb<\/b>-\/.accdb<\/b>-Datei nötig ist und schließlich den geplanten Komprimiervorgang aufrufen.<\/p>\n Die folgende Routine wird beim Endladen des Formulars ausgelöst und schließt erst alle anderen Formulare, bevor es zwei Sekunden wartet und dann, sofern das Backend geschlossen ist, die Komprimierung durchführt (s. Beispieldatenbank Frontend_CheckBeforeShutdown.mdb<\/b>):<\/p>\n Listing 2: Komprimieren verknüpfter und gegebenenfalls kennwortgeschützter Tabellen<\/p>\n Enthaltene Beispieldateien:<\/p>\n Frontend_CheckBeforeShutdown.mdb<\/p>\n Frontend_CheckBeforeShutdown.mdb<\/p>\n Frontend_CheckBeforeShutdown.mdb<\/p>\n Frontend_CheckBeforeShutdown.mdb<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_02\/BackendsKomprimierenUndVerschluesseln-web-images\/pic002_opt.jpeg\")
<\/p>\nPublic Sub VerknuepfteTabellenWiedereinbinden()\r\nDim db As DAO.Database\r\nDim tdf As DAO.TableDef\r\nDim strBackend As String\r\nSet db = CurrentDb\r\nstrBackend = CurrentProject.Path & "\\Backend.accdb"\r\nFor Each tdf In CurrentDb.TableDefs\r\n With tdf\r\n If .Connect <> "" Then\r\n .Connect = ";database=" & strBackend & ";pwd=ami"\r\n .RefreshLink\r\n End If\r\n End With\r\nNext\r\nEnd Sub<\/pre>\n
Dim i As Integer\r\nConst cIntSecondsToShutdown As Integer = 60\r\nPrivate Sub Form_Timer()\r\n Dim strBackend As String\r\n Dim strBackendPfad As String\r\n strBackend = DLookup("Database", "MSysObjects", "Name='tblTest'")\r\n strBackendPfad = Mid(strBackend, 1, InStrRev(strBackend, "\\"))\r\n If Len(Dir(strBackendpfad & "Shutdown.txt")) = 0 Then\r\n Me.TimerInterval = 1000\r\n i = i + 1\r\n SysCmd acSysCmdSetStatus, "Shutdown in " & cIntSecondsToShutdown - i & " Sekunden."\r\n If i = cIntSecondsToShutdown Then\r\n MsgBox "Aus!"\r\n End If\r\n End If\r\n End Sub<\/pre>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_02\/BackendsKomprimierenUndVerschluesseln-web-images\/pic003_opt.jpeg\")
<\/p>\nDoCmd.OpenForm "frmShutdown", WindowMode:=acHidden<\/pre>\n
DoCmd.Quit<\/pre>\n
Private Sub Form_Unload(Cancel As Integer)\r\n Dim strForm As String\r\n Do While Forms.Count > 1\r\n If Forms(0).Name = Me.Name Then\r\n DoCmd.Close acForm, Forms(1)\r\n Else\r\n DoCmd.Close acForm, Forms(0)\r\n End If\r\n Loop\r\n Sleep 2000\r\n If Len(Dir(CurrentProject.Path _\r\n & "\\Backend.laccdb")) = 0 Then\r\n BackendKomprimieren\r\nEnd If\r\nEnd Sub<\/pre>\n
Public Function BackendKomprimieren() As Boolean\r\nDim strBackend As String\r\nDim strBackendPfad As String\r\nDim strBackendTemp As String\r\nDim strBackendEndung As String\r\nstrBackend = DLookup("Database", "MSysObjects", "Name = 'tblTest'")\r\nIf Not Len(Dir(strBackend)) = 0 Then\r\n strBackendPfad = Mid(strBackend, 1, InStrRev(strBackend, "\\"))\r\n strBackendEndung = Mid(strBackend, InStrRev(strBackend, "."))\r\n strBackendTemp = strBackendPfad & "BackendTemp_" & Format(Now, "yyyymmdd_hhnnss") _\r\n & strBackendEndung\r\n 'Ohne Kennwortschutz:\r\n DBEngine.CompactDatabase strBackend, strBackendTemp\r\n 'Mit Kennwortschutz:\r\n 'DBEngine.CompactDatabase strBackend, strBackendTemp , , , ";pwd=ami"\r\n Name strBackend As strBackend & "_Old_" & Format(Now, "yyyymmdd_hhnnss") & strBackendEndung\r\n Name strBackendTemp As strBackend\r\nEnd If\r\nEnd Function<\/pre>\nDownloads zu diesem Beitrag<\/h3>\n