Wer in Access per VBA auf Datenbanken zugreift, nutzt meist die DAO-Bibliothek – oft ohne zu wissen, dass am Anfang der gesamten Objekthierarchie die „DBEngine“ steht. Sie repräsentiert die Datenbank-Engine selbst und bietet Zugriff auf Arbeitsbereiche, Verbindungen und globale Einstellungen. Dieser Beitrag stellt die wichtigsten Eigenschaften und Methoden der DBEngine-Klasse vor und zeigt anhand praktischer Beispiele, wie Sie diese gewinnbringend einsetzen.<\/b><\/p>\n
Die DAO-Objekthierarchie<\/h2>\n
Die DAO-Bibliothek (Data Access Objects<\/b>) organisiert ihre Objekte in einer festen Hierarchie. An der Wurzel steht die DBEngine<\/b>-Klasse. Sie ist kein Objekt, das Sie explizit instanziieren müssen – VBA stellt es Ihnen über die DAO-Bibliothek automatisch als globale Instanz bereit. Die Hierarchie lautet vereinfacht: DBEngine<\/b> – Workspace<\/b> – Database<\/b> – TableDef<\/b>\/QueryDef<\/b>\/Recordset<\/b>.<\/p>\n
Sie können DBEngine<\/b> direkt ansprechen, ohne vorher ein Objekt zu deklarieren:<\/p>\n Alternativ können Sie auch eine explizit typisierte Variable verwenden. Das verbessert die IntelliSense-Unterstützung:<\/p>\n Die DBEngine<\/b>-Klasse stellt eine Reihe von Eigenschaften zur Verfügung, über die Sie globale Einstellungen der Jet- bzw. ACE-Engine steuern können.<\/p>\n Die Eigenschaft Version<\/b> gibt die Versionsnummer der aktuell verwendeten DAO-Bibliothek als Zeichenkette zurück. Das ist nützlich, um zur Laufzeit zu ermitteln, mit welcher Engine die Anwendung arbeitet:<\/p>\n Der zurückgegebene Wert bezieht sich auf die DAO-Version, nicht auf die Access-Version. Für die Bibliothek Microsoft DAO 3.6 Object Library <\/b>liefert sie beispielsweise den Wert 3.6<\/b>, für die heute verwendete Microsoft Office 16.0 Access database engine Object Library <\/b>den Wert 16.0<\/b>. Damit lässt sich also einfach ermitteln, ob die alte oder die neue DAO-Bibliothek verwendet wird.<\/p>\n Mit DefaultUser<\/b> und DefaultPassword<\/b> legen Sie fest, welche Anmeldedaten beim Öffnen von Datenbanken ohne explizite Angabe von Benutzername und Kennwort verwendet werden.<\/p>\n Diese Eigenschaften stammen noch aus der älteren Workgroup-Sicherheit von Access und sind in modernen Umgebungen kaum noch relevant, können aber beim Zugriff auf ältere gesicherte Datenbanken nützlich sein:<\/p>\n Dies funktioniert nur mit der alten Workgroup-Security, die in .mdb<\/b>-Dateien bis Access 2003 zum Einsatz kam, in .accdb<\/b>-Dateien ist dies wirkungslos.<\/p>\n Die Eigenschaft LoginTimeout<\/b> legt fest, wie viele Sekunden die Engine wartet, bevor ein Anmeldeversuch an einem ODBC-Server als fehlgeschlagen gilt. Der Standardwert beträgt 20 Sekunden.<\/p>\n In der Praxis ist die Wirkung dieser Eigenschaft jedoch begrenzt: Moderne ODBC-Treiber wie der ODBC Driver 17 for SQL Server haben eigene interne Verbindungs- und Retry-Timeouts, die Vorrang vor dem hier gesetzten Wert haben. So kann es vorkommen, dass trotz eines gesetzten Werts von 2 Sekunden erst nach 10 oder mehr Sekunden eine Fehlermeldung erscheint, weil der Treiber seinen eigenen Zyklus durchläuft.<\/p>\n Die Einstellung funktioniert auch nur für ODBC und andere externe Treiber, nicht für den direkten Zugriff über die ACE-Engine.<\/p>\n Es gibt zwar in ADODB ebenfalls eine Eigenschaft, deren Name verheißen lässt, dass man damit den Zeitpunkt eines Verbindungsabbruchs steuern könnte, jedoch funktioniert auch die dortige ConnectionTimeout<\/b>-Eigenschaft nur bei einer sehr beschränkten Menge von Konstellationen zuverlässig. Das ist beispielsweise bei bestimmten falschen Angaben des Servernamens der Fall. In anderen Situationen schalten sich andere Automatismen dazwischen, die sich nicht durch die Einstellung der Zeit bis zum Verbindungsabbruch steuern lassen.<\/p>\n Mit IniPath<\/b> können Sie einen Registry-Pfad angeben, unter dem die Jet\/ACE-Engine ihre Konfiguration liest. Normalerweise liest die Engine ihre Einstellungen aus dem Standardpfad in der Windows-Registry.<\/p>\n Über diese Eigenschaft können Sie einen alternativen Schlüssel angeben, um Engine-Parameter wie Cache-Größen oder Sperrmodi individuell zu konfigurieren. Dies ist ein fortgeschrittenes Thema, das hauptsächlich für Mehrbenutzerumgebungen mit speziellen Anforderungen interessant ist.<\/p>\n Die Eigenschaft SystemDB<\/b> gibt den Pfad zur aktuell verwendeten Arbeitsgruppeninformationsdatei (.mdw<\/b>) an. Diese Eigenschaft ist ein Relikt der älteren Access-Sicherheitsarchitektur. In modernen Anwendungen ohne Workgroup-Sicherheit hat sie keine praktische Bedeutung mehr. Sie können sie lesen, um zu prüfen, welche .mdw<\/b>-Datei aktuell verwendet wird:<\/p>\n Die Workspaces<\/b>-Auflistung enthält alle aktuell geöffneten Workspace<\/b>-Objekte.<\/p>\n Standardmäßig enthält sie genau einen Eintrag: den Standardarbeitsbereich Workspaces(0)<\/b>. Über diesen gelangen Sie zur aktuellen Datenbank:<\/p>\n Neben den Eigenschaften bietet die DBEngine<\/b>-Klasse mehrere Methoden, die direkt auf der Ebene der Engine operieren. Diese stellen wir in den folgenden Abschnitten vor.<\/p>\n Mit OpenDatabase<\/b> öffnen Sie eine Datenbankdatei und erhalten ein Database<\/b>-Objekt zurück. Die Methode hat folgende Signatur:<\/p>\n Der Parameter Name<\/b> gibt den Pfad zur Datenbankdatei an. Exclusive<\/b> legt fest, ob die Datenbank exklusiv geöffnet werden soll, ReadOnly<\/b> schränkt den Zugriff auf Lesen ein.<\/p>\n Der optionale Parameter Connect<\/b> ermöglicht die Übergabe einer Verbindungszeichenfolge für ODBC-Quellen.<\/p>\n Ein typisches Beispiel: Sie möchten aus VBA heraus eine externe Access-Datenbank öffnen, um dort Daten zu lesen, ohne diese als verknüpfte Tabelle einbinden zu müssen (siehe Listing 1).<\/p>\n Listing 1: Die Prozedur DatenAusExternerDB<\/span><\/b><\/p>\n Beachten Sie: Die so geöffnete Datenbank ist von der aktuellen Access-Sitzung unabhängig und muss am Ende explizit mit Close<\/b> geschlossen und das Objekt auf Nothing<\/b> gesetzt werden.<\/p>\n Mit CreateWorkspace<\/b> können Sie einen neuen Arbeitsbereich anlegen. In der Praxis spielt diese Methode heute vor allem noch für Jet-\/ACE-Arbeitsbereiche eine Rolle. Die Methode hat folgende Signatur:<\/p>\n Der Parameter UseType <\/b>legt den Typ des Arbeitsbereichs fest. Der Wert dbUseJet <\/b>erstellt einen Jet-\/ACE-Arbeitsbereich. Der frühere Wert dbUseODBC <\/b>war für ODBCDirect <\/b>vorgesehen, das in modernen DAO-Versionen nicht mehr unterstützt wird – die Verwendung führt sogar zu einem Fehler (siehe Bild 1).<\/p>\n Bild 1: Die Verwendung von dbUseODBC führt zu einem Fehler<\/span><\/b><\/p>\n Unabhängig davon steht über DBEngine.Workspaces(0) <\/b>immer der Standardarbeitsbereich zur Verfügung, über den sich auch Transaktionen steuern lassen.<\/p>\n Über DBEngine.Workspaces(0) <\/b>können Sie auf den aktuellen Workspace zugreifen und darüber Transaktionen steuern. Transaktionen über dieses Workspace<\/b>-Objekt sind besonders dann nützlich, wenn Sie sicherstellen möchten, dass mehrere Schreiboperationen entweder vollständig oder gar nicht ausgeführt werden. Im Fehlerfall sorgt Rollback<\/b> dafür, dass keine halbfertigen Änderungen in der Datenbank verbleiben. Ein Beispiel sehen wir in Listing 2.<\/p>\n Listing 2: Die Prozedur TransaktionMitWorkspace<\/span><\/b><\/p>\n Die Methode CompactDatabase<\/b> komprimiert eine Datenbankdatei und erstellt dabei eine neue, optimierte Kopie.<\/p>\n Da die Methode auf einer geschlossenen Datenbank operiert, kann sie nicht auf die aktuell geöffnete Datenbankdatei angewendet werden. Die Signatur lautet:<\/p>\n Ein praktisches Einsatzszenario ist das Komprimieren einer externen Archivdatenbank, die nicht in der laufenden Access-Sitzung geöffnet ist:<\/p>\n Die Prozedur erstellt zunächst eine komprimierte Kopie unter einem temporären Namen, löscht dann das Original mit Kill<\/b> und benennt die Kopie mit Name<\/b> um.<\/p>\n Dieser Ablauf ist nötig, weil Quelle und Ziel bei CompactDatabase <\/b>nicht identisch sein dürfen.<\/p>\n Die Methode RepairDatabase<\/b> versucht, eine beschädigte Datenbankdatei zu reparieren. Ihre Signatur ist denkbar einfach:<\/p>\n Die Methode existiert noch aus älteren DAO-Versionen. In modernen ACE-Datenbanken (.accdb<\/b>-Format) ist ihre Wirkung begrenzt, da das neuere Format robuster gegenüber Beschädigungen ist als das ältere MDB-Format. Für .accdb<\/b>-Dateien ist CompactDatabase <\/b>in der Regel das wirksamere Mittel. Das zeigt sich auch in der Benutzeroberfläche von Access: Der entsprechende Befehl heißt Datenbank komprimieren und reparieren<\/b>. Die Reparatur ist dabei also bereits in den Komprimierungsvorgang eingebunden.<\/p>\n Dennoch kann ein direkter Aufruf von RepairDatabase<\/b> insbesondere bei älteren .mdb<\/b>-Datenbanken sinnvoll sein:<\/p>\n Die Methode Idle<\/b> gibt der Datenbank-Engine Gelegenheit, ausstehende interne Aufgaben abzuschließen. Dazu gehören unter anderem das Aktualisieren von Seiten-Sperren und das Schreiben von Daten aus dem internen Schreibpuffer auf den Datenträger. Die Methode wird mit einem optionalen Parameter aufgerufen:<\/p>\n Der Wert dbFreeLocks<\/b> veranlasst die Engine, gehaltene Seitensperren freizugeben. Dies ist in Mehrbenutzerumgebungen hilfreich, wenn Sie nach einer Reihe von Lesevorgängen sicherstellen möchten, dass Sperren so früh wie möglich freigegeben werden.<\/p>\n Ein typisches Muster findet sich in Schleifen, die viele Datensätze lesen:<\/p>\n In der modernen ACE-Engine ist Idle <\/b>allerdings kaum noch nötig, da viele interne Vorgänge automatisch optimiert werden.<\/p>\n Mit SetOption<\/b> können Sie zur Laufzeit Registry-Einstellungen der Jet\/ACE-Engine temporär überschreiben, ohne die Registry selbst zu verändern.<\/p>\n Die Änderungen gelten nur für die aktuelle Sitzung und werden beim nächsten Start der Engine verworfen.<\/p>\n Ein Gegenstück zum Auslesen dieser Werte stellt die DBEngine<\/b>-Klasse nicht bereit.<\/p>\n Wichtig: Die Änderungen gelten für die gesamte Engine-Instanz und damit für alle geöffneten Datenbanken innerhalb dieser Access-Sitzung.<\/p>\n dbMaxBufferSize<\/b> steuert die maximale Größe des internen Schreibpuffers der Engine in Kilobyte. Der Standardwert beträgt 512 KB.<\/p>\n Bei Anwendungen, die viele Schreiboperationen auf größeren Datenmengen durchführen, kann ein höherer Wert die Performance verbessern, weil die Engine weniger oft auf Datenträger schreiben muss:<\/p>\n dbMaxLocksPerFile<\/b> legt fest, wie viele Datensatz-Sperren die Engine gleichzeitig verwalten kann. Der Standardwert beträgt 9500. Bei umfangreichen Transaktionen, die viele Datensätze gleichzeitig sperren, kann dieser Wert zu niedrig sein und zu dem Laufzeitfehler 3052 führen (zu viele Sperren).<\/p>\n Die Erhöhung sollte vor der Transaktion erfolgen:<\/p>\n dbLockRetry<\/b> bestimmt, wie oft die Engine versucht, eine gesperrte Seite zu lesen, bevor sie einen Fehler ausgibt.<\/p>\n Der Standardwert beträgt 20. dbLockDelay<\/b> legt die Wartezeit in Millisekunden zwischen diesen Wiederholungsversuchen fest, der Standardwert beträgt 100 ms.<\/p>\n Zusammen steuern diese beiden Konstanten, wie aggressiv die Engine bei Sperrkonflikten wiederholt. In einer Mehrbenutzerumgebung mit häufigen Schreibkonflikten kann eine Kombination aus mehr Versuchen und längerer Wartezeit die Anzahl der dem Benutzer angezeigten Fehlermeldungen deutlich reduzieren:<\/p>\n dbPageTimeout<\/b> gibt an, wie viele Millisekunden eine Seite im internen Cache verbleiben darf, bevor die Engine sie als veraltet betrachtet und neu von der Festplatte liest. Der Standardwert beträgt 5000 ms (5 Sekunden).<\/p>\n Ein niedrigerer Wert sorgt dafür, dass Datensätze, die andere Benutzer geändert haben, schneller sichtbar werden – auf Kosten häufigerer Lesezugriffe auf die Datenbankdatei. In Einzelbenutzerumgebungen ist eine Erhöhung möglich, um unnötige Lesezugriffe zu vermeiden:<\/p>\n dbSharedAsyncDelay<\/b> und dbExclusiveAsyncDelay<\/b> steuern, wie lange die Engine im gemeinsamen bzw. exklusiven Modus wartet, bevor sie geänderte Seiten asynchron auf den Datenträger schreibt (in Millisekunden). Standardwerte sind 0 ms im gemeinsamen und 50 ms im exklusiven Modus.<\/p>\n Ein höherer Wert bei dbSharedAsyncDelay<\/b> kann den Schreibdurchsatz in Mehrbenutzerumgebungen verbessern, erhöht aber das Risiko von Datenverlust bei einem Absturz. dbFlushTransactionTimeout<\/b> bestimmt, wie lange nach einer Transaktion gewartet wird, bevor die Engine die Daten endgültig auf den Datenträger schreibt.<\/p>\n dbUserCommitSync<\/b> und dbImplicitCommitSync<\/b> steuern, ob explizite bzw. implizite Commits synchron (sofort auf Datenträger) oder asynchron (verzögert) ausgeführt werden. Der Standardwert ist bei beiden True<\/b> (synchron).<\/p>\n Eine Änderung auf False<\/b> kann die Performance bei vielen kleinen Transaktionen verbessern, birgt aber das gleiche Absturzrisiko wie die Async-Delay-Einstellungen.<\/p>\n Das folgende Beispiel zeigt, wie Sie die wichtigsten Parameter gezielt setzen:<\/p>\n Diese Änderungen werden jedoch nicht dauerhaft in der Registry gespeichert. Es gibt zwar kein Gegenstück zu SetOption <\/b>zum Lesen der entsprechenden Einstellungen in der DBEngine<\/b>-Klasse. Die Standardwerte der Engine lassen sich gegebenenfalls über die Registry ermitteln. Diese Werte entsprechen jedoch nicht zwingend den zur Laufzeit mit SetOption<\/b> gesetzten Werten, da diese nur temporär für die aktuelle Sitzung gelten. Die Funktion zum Auslesen von Registry-Einträgen sieht so aus:<\/p>\n Die vier in der vorherigen Prozedur gesetzten Werte können wir wie folgt auslesen:<\/p>\n Der genaue Registry-Pfad kann je nach Office-Version, Installationsart (zum Beispiel Click-to-Run) und Bitness abweichen.<\/p>\n Hier stellen wir jedoch schnell fest, dass dies nicht die Werte liefert, die wir zuvor eingestellt haben. SetOption<\/b> ändert nicht die dauerhaft in der Registry gespeicherten Initialwerte. Die Methode wirkt nur auf die laufende Engine-Sitzung.<\/p>\n Das Databases(0)<\/b>-Objekt im Standardarbeitsbereich repräsentiert die aktuell geöffnete Datenbank – also dieselbe Datenbank, die auch über CurrentDb()<\/b> zugänglich ist. Der Unterschied: CurrentDb()<\/b> erstellt bei jedem Aufruf ein neues Objekt, während Workspaces(0).Databases(0)<\/b> direkt auf das interne Objekt verweist. Dieses kann jedoch veraltete Informationen enthalten.<\/p>\n Das können wir leicht an einem Beispiel demonstrieren. Wir führen einmal die folgende Prozedur aus:<\/p>\n Dies liefert direkt nach dem Öffnen der Datenbank die gleichen Werte. Wenn wir nun jedoch eine neue Tabelle anlegen und die Prozedur erneut ausführen, erhalten wir für DBEngine.Workspaces(0).Databases(0).TableDefs.Count <\/b>den gleichen Wert wie zuvor, CurrentDb.TableDefs.Count <\/b>zeigt aber einen Wert an, der die neu angelegte Tabelle mitzählt.<\/p>\n Das Gleiche gilt übrigens, wenn wir CurrentDb <\/b>in einer globalen Variablen etwa namens db <\/b>speichern. Geben wir dann zunächst db.TableDefs.Count<\/b> aus, legen anschließend eine neue Tabelle an und fragen den Wert erneut ab, bleibt er unverändert, obwohl sich die Anzahl der Tabellen tatsächlich geändert hat. Hier müssen wir db<\/b> entweder erneut mit CurrentDb <\/b>füllen, um den aktuellen Wert zu erhalten, oder wir fragen direkt CurrentDb.TableDefs.Count <\/b>ab.<\/p>\n Zum Abschluss ein kompaktes Beispiel, das wichtige Informationen aus der DBEngine<\/b> und dem Standardarbeitsbereich in einem Dialog zusammenstellt – nützlich etwa für ein Informations-Dialogfeld einer Anwendung (siehe Listing 3).<\/p>\n Listing 3: Die Prozedur DBEngineInfo<\/span><\/b><\/p>\n Die DBEngine<\/b>-Klasse ist die Wurzel der DAO-Objekthierarchie und bietet mehr als nur einen Einstiegspunkt zu Datenbanken.<\/p>\n Mit ihren Methoden können Sie externe Datenbanken öffnen, Transaktionen über eigene Arbeitsbereiche kapseln, Datenbanken komprimieren und reparieren sowie Engine-Parameter für die aktuelle Sitzung feinjustieren. <\/p>\n","protected":false},"excerpt":{"rendered":" Wer in Access per VBA auf Datenbanken zugreift, nutzt meist die DAO-Bibliothek – oft ohne zu wissen, dass am Anfang der gesamten Objekthierarchie die „DBEngine“ steht. Sie repräsentiert die Datenbank-Engine selbst und bietet Zugriff auf Arbeitsbereiche, Verbindungen und globale Einstellungen. Dieser Beitrag stellt die wichtigsten Eigenschaften und Methoden der DBEngine-Klasse vor und zeigt anhand praktischer Beispiele, wie Sie diese gewinnbringend einsetzen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662026,66032026,44000035],"tags":[],"class_list":["post-55001600","post","type-post","status-publish","format-standard","hentry","category-662026","category-66032026","category-Datenzugriff_programmieren"],"yoast_head":"\nDebug.Print<\/span> DBEngine.Version<\/pre>\nDim <\/span>dbe As <\/span>DAO.DBEngine\r\nSet<\/span> dbe = DBEngine\r\nDebug.Print<\/span> dbe.Version<\/pre>\nWichtige Eigenschaften der DBEngine<\/h2>\n
Version<\/h2>\n
Debug.Print<\/span> DBEngine.Version 'z.B. \"16.0\"<\/pre>\nDefaultUser und DefaultPassword<\/h2>\n
DBEngine.DefaultUser = \"Admin\"\r\nDBEngine.DefaultPassword = \"\"<\/pre>\n
LoginTimeout<\/h2>\n
IniPath<\/h2>\n
SystemDB<\/h2>\n
Debug.Print<\/span> DBEngine.SystemDB<\/pre>\nWorkspaces-Auflistung<\/h2>\n
Dim <\/span>ws As <\/span>DAO.Workspace\r\nSet<\/span> ws = DBEngine.Workspaces(0)\r\nDebug.Print<\/span> ws.Name 'Ausgabe: #Default Workspace#<\/pre>\nWichtige Methoden der DBEngine<\/h2>\n
OpenDatabase<\/h2>\n
DBEngine.OpenDatabase(Name, [Exclusive], [ReadOnly], [Connect])<\/pre>\n
Sub <\/span>DatenAusExternerDB()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strPfad As String<\/span>\r\n strPfad = \"C:\\Daten\\Archiv.accdb\"\r\n Set<\/span> db = DBEngine.OpenDatabase(strPfad, False, True<\/span>)\r\n Set<\/span> rst = db.OpenRecordset( _\r\n \"SELECT * FROM tblBestellungen\", dbOpenSnapshot)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst!BestellNr\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n db.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nCreateWorkspace<\/h2>\n
DBEngine.CreateWorkspace(Name, UserName, Password, [UseType])<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_03\/pic_1600_001.png\")
<\/p>\nTransaktionen über Workspace steuern<\/h2>\n
Sub <\/span>TransaktionMitWorkspace()\r\n Dim <\/span>ws As <\/span>DAO.Workspace\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> ws = DBEngine.CreateWorkspace(\"MeinWS\", \"Admin\", \"\", dbUseJet)\r\n Set<\/span> db = ws.OpenDatabase(CurrentDb().Name)\r\n ws.BeginTrans\r\n On Error GoTo<\/span> Fehler\r\n db.Execute \"UPDATE tblArtikel SET Preis = Preis * 1.05 WHERE Kategorie = 'A'\", dbFailOnError\r\n db.Execute \"INSERT INTO tblPreishistorie (Datum, Faktor) VALUES (Date(), 1.05)\", dbFailOnError\r\n ws.CommitTrans\r\n GoTo Ende\r\nFehler:\r\n ws.Rollback\r\n MsgBox<\/span> \"Fehler: Transaktion zurückgerollt.\"\r\nEnde:\r\n db.Close\r\n ws.Close\r\n Set<\/span> db = Nothing\r\n Set<\/span> ws = Nothing\r\nEnd Sub<\/span><\/pre>\nCompactDatabase<\/h2>\n
DBEngine.CompactDatabase(SrcName, DstName, [DstLocale], [Options], [SrcLocale])<\/pre>\n
Sub <\/span>ArchivKomprimieren()\r\n Dim <\/span>strQuelle As String<\/span>\r\n Dim <\/span>strZiel As String<\/span>\r\n strQuelle = \"C:\\Daten\\Archiv.accdb\"\r\n strZiel = \"C:\\Daten\\Archiv_kompakt.accdb\"\r\n On Error GoTo<\/span> Fehler\r\n DBEngine.CompactDatabase strQuelle, strZiel\r\n Kill strQuelle\r\n Name strZiel As <\/span>strQuelle\r\n MsgBox<\/span> \"Archivdatenbank erfolgreich komprimiert.\"\r\n Exit Sub<\/span>\r\nFehler:\r\n MsgBox<\/span> \"Fehler beim Komprimieren: \" & Err.Description\r\nEnd Sub<\/span><\/pre>\nRepairDatabase<\/h2>\n
DBEngine.RepairDatabase(Name)<\/pre>\n
Sub <\/span>DatenbankReparieren(strPfad As String<\/span>)\r\n On Error GoTo<\/span> Fehler\r\n DBEngine.RepairDatabase strPfad\r\n MsgBox<\/span> \"Reparatur abgeschlossen: \" & strPfad\r\n Exit Sub<\/span>\r\nFehler:\r\n MsgBox<\/span> \"Reparatur fehlgeschlagen: \" & Err.Description\r\nEnd Sub<\/span><\/pre>\nIdle<\/h2>\n
DBEngine.Idle dbFreeLocks<\/pre>\n
Dim <\/span>rst As <\/span>DAO.Recordset\r\nDim <\/span>lngZähler As Long<\/span>\r\nSet<\/span> rst = CurrentDb().OpenRecordset(\"tblBestellungen\", _\r\n dbOpenSnapshot)\r\nlngZähler = 0\r\nDo While<\/span> Not<\/span> rst.EOF\r\n 'Verarbeitung...\r\n lngZähler = lngZähler + 1\r\n If <\/span>lngZähler Mod<\/span> 100 = 0 Then<\/span>\r\n DBEngine.Idle dbFreeLocks\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\nLoop<\/span>\r\nrst.Close\r\nSet<\/span> rst = Nothing<\/pre>\nSetOption<\/h2>\n
DBEngine.SetOption dbMaxBufferSize, 4096 '4 MB Puffer<\/pre>\n
Sub <\/span>GrosseMassenaktualisierung()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n 'Sperrlimit erhöhen, bevor die Transaktion beginnt\r\n DBEngine.SetOption dbMaxLocksPerFile, 50000\r\n Set<\/span> db = CurrentDb()\r\n db.Execute \"UPDATE tblArtikel SET Lagerbestand = 0\", _\r\n dbFailOnError\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n'20 Versuche, je 200 ms Pause = max. 4 Sekunden warten\r\nDBEngine.SetOption dbLockRetry, 20\r\nDBEngine.SetOption dbLockDelay, 200<\/pre>\n
DBEngine.SetOption dbPageTimeout, 1000 '1 Sekunde in Mehrbenutzerumgebung<\/pre>\n
Sub <\/span>EngineOptimieren()\r\n DBEngine.SetOption dbMaxBufferSize, 2048\r\n DBEngine.SetOption dbMaxLocksPerFile, 25000\r\n DBEngine.SetOption dbLockRetry, 30\r\n DBEngine.SetOption dbLockDelay, 150\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>RegistryWertLesen(strKey As String<\/span>, _\r\n strValueName As String<\/span>) As Variant<\/span>\r\n Dim <\/span>objShell As Object<\/span>\r\n Dim <\/span>strFullPath As String<\/span>\r\n Set<\/span> objShell = CreateObject(\"WScript.Shell\")\r\n If <\/span>Right$(strKey, 1) <> \"\\\" Then<\/span>\r\n strFullPath = strKey & \"\\\" & strValueName\r\n Else<\/span>\r\n strFullPath = strKey & strValueName\r\n End If<\/span>\r\n On Error GoTo<\/span> Fehler\r\n RegistryWertLesen = objShell.RegRead(strFullPath)\r\n Exit Function<\/span>\r\nFehler:\r\n Debug.Print<\/span> \"Fehler bei RegRead: \" & strFullPath\r\n Debug.Print<\/span> \"Err.Number: \" & Err.Number & \" - \" _\r\n & Err.Description\r\n RegistryWertLesen = Null\r\nEnd Function<\/span><\/pre>\nSub <\/span>EngineOptionenAusRegistryLesen()\r\n Dim <\/span>strRegistrypath As String<\/span>\r\n strRegistrypath = \"HKEY_LOCAL_MACHINE\\SOFTWARE\\\" _\r\n & \"Microsoft\\Office\\16.0\\\" _\r\n & \"Access Connectivity Engine\\Engines\\ACE\"\r\n Debug.Print<\/span> RegistryWertLesen(strRegistrypath, _\r\n \"MaxBufferSize\")\r\n Debug.Print<\/span> RegistryWertLesen(strRegistrypath, _\r\n \"MaxLocksPerFile\")\r\n Debug.Print<\/span> RegistryWertLesen(strRegistrypath, _\r\n \"LockRetry\")\r\n Debug.Print<\/span> RegistryWertLesen(strRegistrypath, _\r\n \"LockDelay\")\r\nEnd Sub<\/span><\/pre>\nCurrentDb() und Workspaces(0).Databases(0) richtig einordnen<\/h2>\n
Public Sub <\/span>Test_CurrentDb_Vs_Workspace_0()\r\n Debug.Print<\/span> CurrentDb.TableDefs.Count\r\n Debug.Print<\/span> DBEngine.Workspaces(0).Databases(0). _\r\n TableDefs.Count\r\nEnd Sub<\/span><\/pre>\nBeispiel zur Nutzung verschiedener Informationen<\/h2>\n
Sub <\/span>DBEngineInfo()\r\n Dim <\/span>ws As <\/span>DAO.Workspace\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strInfo As String<\/span>\r\n Set<\/span> ws = DBEngine.Workspaces(0)\r\n Set<\/span> db = ws.Databases(0)\r\n strInfo = \"DAO-Version: \" & DBEngine.Version & vbCrLf<\/span>\r\n strInfo = strInfo & \"Arbeitsbereich: \" & ws.Name & vbCrLf<\/span>\r\n strInfo = strInfo & \"Datenbankpfad: \" & db.Name & vbCrLf<\/span>\r\n strInfo = strInfo & \"Verbindung: \" & db.Connect & vbCrLf<\/span>\r\n strInfo = strInfo & \"Login-Timeout: \" & DBEngine.LoginTimeout & \" Sek.\"\r\n MsgBox<\/span> strInfo, vbInformation, \"Datenbankinfo\"\r\n Set<\/span> db = Nothing\r\n Set<\/span> ws = Nothing\r\nEnd Sub<\/span><\/pre>\nFazit<\/h2>\n