<\/p>\n
In vielen Datenbankanwendungen fallen temporäre Daten an, also Daten, die in Tabellen geschrieben und in der gleichen Session wieder gelöscht werden. Das kann sowohl in nicht aufgeteilten Datenbanken als auch in aufgeteilten Datenbanken mit Frontend und Backend geschehen. Man könnte denken, die Größe der Datenbankdatei würde nach dem Anfügen und Löschen von Daten einigermaßen konstant sein. Das ist jedoch nicht der Fall: Gelöschte Daten sind zwar nicht mehr in den Tabellen zu finden, allerdings benötigt die Datenbank anschließend ungefähr genauso viel Speicherplatz wie vor dem Löschen. Wie das zu erklären ist und wie wir durch die Komprimierung einer Datenbank dennoch dafür sorgen können, dass eine Datenbank sich durch die Verwendung temporärer Daten nicht übermäßig aufbläht, beschreiben wir in diesem Beitrag.<\/b><\/p>\nBeispieldatenbank erzeugen<\/h2>\n
Wenn wir das Verhalten von Access-Datenbanken beim Anlegen und Löschen von Daten und beim Komprimieren der Datenbank untersuchen wollen, brauchen wir die Möglichkeit, schnell Daten hinzuzufügen und zu entfernen – und natürlich eine Tabelle, in der wir die Daten speichern.<\/p>\n
Die Tabelle soll tblTexte<\/b> heißen und neben dem Primärschlüsselfeld ID <\/b>ein Textfeld namens Beispieltext <\/b>mit einer Feldgröße von 255 Zeichen enthalten (siehe Bild 1).<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_04\/pic_1446_001.png\")
<\/p>\n
Bild 1: Tabelle für Beispieldaten<\/span><\/b><\/p>\n Zum Anlegen einer relevanten Menge von Daten verwenden wir die folgende Prozedur:<\/p>\n Diese legt 10.000 Datensätze mit jeweils 255 Zeichen an. Um die Datensätze schnell wieder zu löschen, verwenden wir die folgende Prozedur:<\/p>\n Führen wir die erste Prozedur für eine bis dahin leere Datenbank aus, erhalten wir eine Datenbankgröße von ungefähr 3.264 KB.<\/p>\n Anschließend führen wir die zweite Prozedur aus und löschen damit alle Datensätze der Tabelle tblTexte<\/b>. Schließen wir danach die Datenbank, bleibt die Dateigröße erhalten – obwohl die Tabelle keine Daten mehr enthält.<\/p>\n Der Grund für dieses Verhalten ist, dass der Speicherplatz erst nach dem Komprimieren einer Datenbank freigegeben wird. Also öffnen wir die Datenbank mit der leeren Tabelle erneut und rufen für diese den Befehl Datenbank komprimieren und reparieren <\/b>auf (unter Access 365 beispielsweise unter Datei|Informationen <\/b>zu finden).<\/p>\n Betrachten wir anschließend erneut die Dateigröße, weist diese wieder um die 400 KB aus. Daraus können wir ableiten: Der Speicherplatz für gelöschte Datensätze wird erst nach dem Komprimieren der Datenbank freigegeben.<\/p>\n Für monolithische Access-Anwendungen, also solche, die nur aus einer einzigen Datenbankdatei und nicht aus Frontend und Backend bestehen, können wir in den Access-Optionen die Option Beim Schließen komprimieren <\/b>aktivieren (siehe Bild 2).<\/p>\n Bild 2: Aktivieren der automatischen Komprimierung<\/span><\/b><\/p>\n Füllen wir die Tabelle wieder mit Daten und löschen diese erneut, finden wir gleich nach dem nächsten Schließen wieder die geringe Dateigröße von rund 400 KB vor.<\/p>\n Nun teilen wir die Beispieldatenbank in Frontend und Backend auf, was am schnellsten mit dem Menübefehl Datenbanktools|Daten verschieben|Access-Datenbank <\/b>gelingt. Hier brauchen wir nur den Pfad zur neuen Backenddatenbank anzugeben. Das Ergebnis ist eine neue Backenddatenbank, in welche die einzige Tabelle der bisher verwendeten Datenbank verschoben wurde, sowie eine Verknüpfung zu dieser Tabelle in der aktuellen Datenbankdatei.<\/p>\n Erstere nennen wir nun BackendKomprimieren_FE.accdb<\/b>, letztere BackendKomprimieren_BE.accdb<\/b>.<\/p>\n Die Frontenddatenbank mit der Tabellenverknüpfung und das Backend mit der leeren Tabelle haben wir nun zunächst komprimiert. Die Größen lauteten danach:<\/p>\n Anschließend rufen wir die Prozedur zum Anlegen der 10.000 Datensätze in der Tabelle tblTexte <\/b>auf. Dabei fällt zuerst auf, dass der Vorgang viel länger dauert als in der monolithischen .accdb<\/b>-Datei. Noch viel interessanter ist die Beobachtung des benötigten Speicherplatzes für die beiden Dateien:<\/p>\n Der Teil mit der Tabelle ist also ähnlich gewachsen wie zuvor, aber das Frontend ist massiv größer geworden – es wächst um mehr als den zehnfachen Speicherplatz der eigentlich erzeugten Daten. Obwohl es noch nicht einmal eine von uns angelegte Tabelle mit Daten enthält. Die Größe ändert sich auch nach dem Schließen nicht.<\/p>\n Anschließend haben wir die Prozedur zum Schreiben der Daten erneut aufgerufen, um zu prüfen, ob wir das Frontend so bis zur Grenze von 2 GB aufblähen können. Das ist jedoch nicht der Fall: Beim zweiten Durchlauf wird die Frontenddatenbank nur noch unwesentlich vergrößert, während das Backend seine Größe wie erwartet um ca. 2.800 KB ändert.<\/p>\n Zum Wachstum der Größe des Frontends noch folgende Anmerkung: Dies geschieht nur, wenn wir die Daten per VBA in die Tabelle tblTexte<\/b> des Backends einfügen. Wir haben in einem zweiten Versuch manuell mehrere tausend Datensätze dort eingefügt und in diesem Fall wurde zwar das Backend vergrößert, nicht jedoch das Frontend.<\/p>\n Komprimieren wir nun das Frontend, wird dieses wieder auf die ursprüngliche Größe geschrumpft. An der Größe des Backends ändert sich zunächst nichts, was auch nicht zu erwarten war, da wir die enthaltenen Daten nicht gelöscht haben. Also öffnen wir das Frontend erneut und löschen die Daten im Backend mit der Prozedur TabelleLeeren<\/b>.<\/p>\n Die Größe des Backends bleibt erhalten. Nun rufen wir in der Frontenddatenbank den Befehl Komprimieren und Reparieren <\/b>auf. Obwohl wir die Daten im Backend gelöscht haben, ändert sich dessen Speicherbedarf nicht.<\/p>\n Wenn wir das Frontend einer Kombination aus Frontend und Backend komprimieren, wird also nur der Speicherplatz im Frontend freigegeben, der für das Schreiben von Datensätzen im Backend angefallene Daten verwendet wurde.<\/p>\n Wie also können wir nun dafür sorgen, dass der Speicherplatz für im laufenden Betrieb angelegte und wieder gelöschte Daten im Backend wieder freigegeben wird? Immerhin darf das Backend nicht größer als 2 GB werden, was bei solchen Operationen schnell geschehen kann.<\/p>\n Öffnen wir das Backend ohne das Frontend und komprimieren es nach dem Löschen der Daten mit dem dafür vorgesehen Befehl Komprimieren und Reparieren<\/b>, erhält es wieder seine ursprüngliche Dateigröße.<\/p>\n Die Vermutung liegt nahe, dass wir nur für das Backend die Option Beim Schließen komprimieren <\/b>einstellen müssen, damit dieses beim Schließen des Frontends automatisch komprimiert wird.<\/p>\n Dies führt allerdings nicht zum Erfolg. Nach dem Einstellen dieser Option und dem Schreiben und Löschen der Daten über das Frontend erhält das Backend nicht wieder die Größe der Datenbank mit der geleerten Tabelle.<\/p>\n Woran liegt das? Offensichtlich findet beim Zugriff auf das Backend über die Tabellenverknüpfungen kein Öffnen und Schließen der Backenddatenbank in dem Sinne statt, dass dabei die für das Schließen aktivierte Komprimierung ausgelöst wird. <\/p>\n Wir müssen also einen anderen Weg finden, um das Backend zu komprimieren.<\/p>\n VBA bietet eine Methode zum Komprimieren einer Datenbank. Diese heißt CompactDatabase<\/b> und erwartet unter anderem die folgenden beiden Parameter:<\/p>\n Wir können also nicht einfach die Datenbank komprimieren, sondern erstellen eine neue Datenbank, welche der komprimierten Version der Datenbank entspricht. Um diese Datenbank später wieder unter dem ursprünglichen Namen nutzen zu können, benötigen wir also noch ein paar weitere Anweisungen.<\/p>\n Wir haben diese in einer Funktion namens BackendKomprimieren <\/b>zusammengefasst (siehe Listing 1).<\/p>\n Listing 1: Funktion zum Komprimieren einer Backenddatenbank<\/span><\/b><\/p>\n Diese Funktion erwartet den Namen einer der Tabellenverknüpfungen als Parameter. In unserem Beispiel lautet der Aufruf also beispielsweise:<\/p>\n Dieser Aufruf gibt gleich das Ergebnis der Funktion im Direktbereich aus.<\/p>\n Die Funktion deklariert einige Variablen und ermittelt dann den Pfad zu der zu komprimierenden Backenddatenbank. Dazu nutzt sie die Tatsache, dass der Pfad einer per Verknüpfung eingebundenen Access-Tabelle im Feld Database<\/b> der Systemtabelle MSysObjects <\/b>gespeichert wird. Der Pfad landet anschließend in der Variablen strBackend<\/b>.<\/p>\n Nach einer Prüfung, ob die Backenddatenbank vorhanden ist, ermittelt sie das Verzeichnis, in dem sich die Backenddatenbank befindet, sowie die Dateiendung (in der Regel .accdb<\/b>), und schreibt beide in die Variablen strBackendverzeichnis <\/b>und strBackendendung<\/b>.<\/p>\n In der Variablen strBackendTemp <\/b>erstellt sie einen neuen Pfad, der aus dem Verzeichnis und einem Dateinamen inklusive der aktuellen Zeit wie in folgendem Beispiel erstellt:<\/p>\n Dann erfolgt das eigentliche Komprimieren mit der Methode CompactDatabase <\/b>der DBEngine<\/b>-Klasse. Diese komprimiert die Datei aus strBackend <\/b>in die neue Datei strBackendTemp<\/b>. Falls das Backend durch ein Kennwort geschützt ist, kann man dieses wie in der auskommentierten nachfolgenden Version des Aufrufs angeben.<\/p>\n Beim Aufruf der Methode CompactDatabase <\/b>können Fehler auftreten, zum Beispiel der Fehler 3704 (Sie haben versucht, eine Datenbank zu öffnen, die bereits von Benutzer “[Benutzername]“ auf Computer “[Computername]“ geöffnet ist. Versuchen Sie es erneut, wenn die Datenbank verfügbar ist.<\/b>).<\/p>\n Dieser tritt auf, wenn noch eine der Tabellen des Backends im Frontend geöffnet ist.<\/p>\n In diesem Fall gibt die Funktion eine Meldung aus und bricht die Funktion ab.<\/p>\n War die Komprimierung jedoch erfolgreich, wird zunächst die Originalversion des Backends aus strBackend <\/b>temporär umbenannt. Der Dateiname lautet dann beispielsweise:<\/p>\n Anschließend prüft die Funktion, ob unter dem ursprünglichen Namen aus strBackend <\/b>eine Datenbankdatei vorliegt. In diesem Fall wird das vorherige Backend gelöscht und die Funktion gibt den Wert True <\/b>als Ergebnis zurück.<\/p>\n Damit erhalten wir also eine Möglichkeit, die Backenddatenbank zu komprimieren, wenn alle Tabellenverknüpfungen auf dieses Backend geschlossen sind.<\/p>\n Nun benötigen wir noch eine Möglichkeit, diese Funktion ähnlich wie bei der Option Beim Schließen komprimieren <\/b>erst beim Schließen der Datenbank aufzurufen.<\/p>\n Dazu können wir eine Methode nutzen, die wir bereits im Beitrag Code beim Schließen der Anwendung ausführen <\/b>(www.access-im-unternehmen.de\/1370<\/b>) vorgestellt haben. Hier setzen wir ein Formular ein, dass wir beim Öffnen der Datenbank automatisch öffnen und das dann direkt unsichtbar gemacht wird. Dadurch sieht der Benutzer dieses Formular nicht. Es wird jedoch, wenn der Benutzer die Datenbankanwendung beendet, automatisch geschlossen. Hier sorgen wir mit einer Ereignisprozedur für das Ereignis Beim Entladen <\/b>dafür, dass wir beim Schließen der Datenbank die Funktion BackendKomprimieren<\/b> aufrufen können.<\/p>\n Das Autoexec<\/b>-Makro, mit dem wir das noch zu erstellende Formular frmStart <\/b>öffnen, sieht wie in Bild 3 aus.<\/p>\n Bild 3: Autoexec-Makro zum Öffnen eines Formulars<\/span><\/b><\/p>\n Das Formular frmStart <\/b>enthält keine Elemente, aber eine Ereignisprozedur (siehe Bild 4). Dieses wird beim Entladen ausgelöst und führt die folgende Prozedur aus:<\/p>\n Bild 4: Entwurf des Formulars frmStart<\/span><\/b><\/p>\n Sie soll also lediglich die Funktion BackendKomprimieren <\/b>für die einzige verknüpfte Tabelle dieser Datenbank aufrufen. Damit sorgt sie dafür, dass beim Schließen der Anwendung die Komprimierung des Backends erfolgt.<\/p>\n Wenn mehrere Benutzer die Datenbank verwenden und einer der Benutzer sein Frontend schließt, wird das Backend nicht komprimiert, wenn noch eine seiner Tabellen in einer anderen Datenbank geöffnet ist.<\/p>\n In diesem Fall kommt es auf das übliche Nutzerverhalten an, wie man für eine Komprimierung der Datenbank sorgt. Wenn alle Frontends zu bestimmten Zeitpunkten geschlossen sind, beispielsweise weil nachts niemand mit der Datenbank arbeitet, wird das Backend beim Schließen des letzten geöffneten Frontends komprimiert.<\/p>\n Hier gibt es aber auch noch Fallstricke, denn es kann passieren, dass das Formular frmStart <\/b>nicht als letztes Formular geschlossen wird. In diesem Fall ist vielleicht noch ein weiteres Formular geöffnet, das an eine der verknüpften Tabellen gebunden ist und somit das Komprimieren des Backends verhindert.<\/p>\n Wenn nicht ausgeschlossen werden kann, dass Benutzer die Anwendung durchgängig geöffnet lassen und dabei auch verknüpfte Tabellen anzeigen, müsste man noch einen Schritt weitergehen und zu bestimmten Zeitpunkten dafür sorgen, dass die Verbindungen zum Backend getrennt werden. Dies würde jedoch den Rahmen des vorliegenden Beitrags sprengen.<\/p>\n Dieser Beitrag zeigt, wie sich das Komprimieren in verschiedenen Szenarien auswirkt und dass ein automatisches Komprimieren des Backends einer Datenbank nicht ohne VBA erfolgen kann.<\/p>\n Dazu muss die Bedingung erfüllt sein, dass aktuell keine Verbindungen zu den Tabellen bestehen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n BackendKomprimieren.accdb<\/p>\n BackendKomprimieren_BE.accdb<\/p>\n BackendKomprimieren_FE.accdb<\/p>\nPublic Sub <\/span>TabelleFuellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>i As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n For i = 1 To 10000\r\n db.Execute \"INSERT INTO tblTexte(Beispieltext) VALUES(''1234567890...12345'')\", dbFailOnError\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>TabelleLeeren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblTexte\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\nUntersuchen der Datenbankgröße nach dem Löschen der Daten<\/h2>\n
Platz für gelöschte Daten wird erst beim Komprimieren freigegeben<\/h2>\n
Automatische Komprimierung aktivieren<\/h2>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2023_04\/pic_1446_002.png\")
<\/p>\nKomprimierung bei aufgeteilten Datenbanken<\/h2>\n
Anlegen und Löschen in Frontend und Backend<\/h2>\n
\n
\n
Wachstum des Frontends<\/h2>\n
Komprimieren des Frontends<\/h2>\n
Backend komprimieren<\/h2>\n
Backend beim Schließen komprimieren<\/h2>\n
Backend per VBA komprimieren<\/h2>\n
\n
Public Function <\/span>BackendKomprimieren(strBackendtabelle As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strBackend As String<\/span>\r\n Dim <\/span>strBackendverzeichnis As String<\/span>\r\n Dim <\/span>strBackendTemp As String<\/span>\r\n Dim <\/span>strBackendOld As String<\/span>\r\n Dim <\/span>strBackendendung As String<\/span>\r\n strBackend = DLookup(\"Database\", \"MSysObjects\", \"Name = ''\" & strBackendtabelle & \"''\")\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strBackend)) = 0 Then<\/span>\r\n strBackendverzeichnis = Mid<\/span>(strBackend, 1, InStrRev<\/span>(strBackend, \"\\\"))\r\n strBackendendung = Mid<\/span>(strBackend, InStrRev<\/span>(strBackend, \".\"))\r\n strBackendTemp = strBackendverzeichnis & \"BackendTemp_\" & Format(Now, \"yyyymmdd_hhnnss\") & strBackendendung\r\n ''Ohne Kennwortschutz:\r\n On Error Resume Next<\/span>\r\n DBEngine.CompactDatabase strBackend, strBackendTemp\r\n ''Mit Kennwortschutz:\r\n ''DBEngine.CompactDatabase strBackend, strBackendTemp , , , \";pwd=ami\"\r\n If <\/span>Err.Number = 3704 Then<\/span>\r\n MsgBox<\/span> \"Das Backend kann nicht komprimiert werden, da noch Tabellen im Frontend geöffnet sind.\", _\r\n vbOKOnly + vbExclamation, \"Fehler beim Komprimieren\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n strBackendOld = strBackend & \"_Old_\" & Format(Now, \"yyyymmdd_hhnnss\") & strBackendendung\r\n Name strBackend As <\/span>strBackendOld\r\n Name strBackendTemp As <\/span>strBackend\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strBackend)) = 0 Then<\/span>\r\n Kill strBackendOld\r\n BackendKomprimieren = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> BackendKomprimieren(\"tblTexte\")<\/pre>\nC:\\...\\BackendTemp_20230529_120406.accdb<\/pre>\n
BackendKomprimieren_BE.accdb_Old_20230529_120936.accdb<\/pre>\n
Komprimieren per VBA beim Schließen<\/h2>\n
![\"Autoexec-Makro](\"..\/fileadmin\/_temp_\/2023_04\/pic_1446_003.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2023_04\/pic_1446_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n BackendKomprimieren \"tblTexte\"\r\nEnd Sub<\/span><\/pre>\nIm Mehrbenutzerbetrieb<\/h2>\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n