{"id":55001111,"date":"2017-12-01T00:00:00","date_gmt":"2020-05-13T21:27:57","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1111"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Die_CurrentDbFunktion_und_das_DatabaseObjekt","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Die_CurrentDbFunktion_und_das_DatabaseObjekt\/","title":{"rendered":"Die CurrentDb-Funktion und das Database-Objekt"},"content":{"rendered":"

\"\"<\/p>\n

Der Zugriff auf die Objekte der aktuellen Datenbank erfolgt in vielen Fällen über eine Objektvariable mit dem Datentyp Database. Diese wird dann mit der CurrentDb-Funktion gefüllt. Der Zugriff auf die aktuelle Datenbank kann dabei auch direkt über CurrentDb erfolgen. Dieser Beitrag liefert Informationen über die Eigenschaften und Methoden des Database-Objekts.<\/b><\/p>\n

Die folgenden beiden Zeilen kommen wohl in jeder Datenbank vor, die in irgendeiner Form mit VBA-Code ausgestattet ist:<\/p>\n

Dim <\/span>db As <\/span>DAO.Database\r\nSet<\/span> db = CurrentDb<\/pre>\n
Die erste deklariert eine Objektvariable namens db <\/b>auf Basis des Datentyps Database<\/b>, die zweite weist dieser Objektvariablen mit der CurrentDB<\/b>-Funktion einen Verweis auf das Database<\/b>-Objekt der aktuellen Access-Instanz zu.<\/p>\n
Aktuelles Abbild<\/h2>\n
In der Praxis können Sie das Database<\/b>-Objekt mit der CurrentDb<\/b>-Funktion füllen oder auch direkt über die CurrentDb<\/b>-Funktion die Eigenschaften und Methoden des Database<\/b>-Objekts der aktuellen Datenbank nutzen.<\/p>\n
Es gibt allerdings einen entscheidenden Unterschied: Wenn Sie das aktuelle Database<\/b>-Objekt einmal mit CurrentDb <\/b>ermittelt und in einer Variablen wie db <\/b>gespeichert haben, dann bekommen Sie änderungen, die direkt über die Methoden von CurrentDb <\/b>oder einer anderen Objektvariablen des Typs Database <\/b>vorgenommen wurden, nicht mehr mit. Das folgende Beispiel zeigt, wie das gemeint ist:<\/p>\n
Dim <\/span>db As <\/span>DAO.Database\r\nDim <\/span>tdf As <\/span>DAO.TableDef\r\nDim <\/span>fld As <\/span>DAO.Field\r\nSet<\/span> db = CurrentDb\r\nOn Error Resume Next<\/span>\r\nCurrentDb.TableDefs.Delete (\"tblTest\")\r\nOn Error GoTo<\/span> 0\r\nDebug.Print<\/span> \"Tabellen vorher: \" & db.TableDefs.Count\r\nSet<\/span> tdf = CurrentDb.CreateTableDef(\"tblTest\")\r\nSet<\/span> fld = tdf.CreateField(\"ID\", dbLong)\r\ntdf.Fields.Append fld\r\nSet<\/span> fld = tdf.CreateField(\"Test\", dbText)\r\ntdf.Fields.Append fld\r\nCurrentDb.TableDefs.Append tdf\r\nDebug.Print<\/span> \"Tabellen nachher CurrentDb: \"  & CurrentDb.TableDefs.Count\r\nDebug.Print<\/span> \"Tabellen nachher db: \"  & db.TableDefs.Count<\/pre>\n
Hier füllen wir die Variable db <\/b>über CurrentDb <\/b>mit dem aktuellen Database<\/b>-Objekt. Dann geben wir die Anzahl der Tabellendefinitionen des Database<\/b>-Objekts aus db <\/b>über db.Table.Count <\/b>im Direktfenster aus – bei einer frischen .accdb<\/b>-Datenbank im Format von Access 2016 sind das beispielsweise 11.<\/p>\n
Anschließend erstellen wir über die CreateTableDef<\/b>-Methode direkt auf Basis der von CurrentDb <\/b>gelieferten Database ein neues TableDef<\/b>-Objekt, also eine neue Tabelle, und fügen dieser zwei Felder hinzu, bevor wir sie mit der Append<\/b>-Methode der TableDefs<\/b>-Auflistung hinzufügen. Schließlich geben wir erneut die Anzahl der TableDef<\/b>-Objekte der in db <\/b>gespeicherten Database und der mit CurrentDb <\/b>ermittelten aktuellen Version im Direktfenster aus. Es zeigt sich, dass die in db <\/b>gespeicherte Version der Datenbank die neue Tabellendefinition nicht enthält und somit tatsächlich nur einen Snapshot der Objekte liefert.<\/p>\n
Sie sollten also beim Zugriff auf die Datenbank über das Database<\/b>-Objekt berücksichtigen, dass eine per CurrentDb <\/b>referenzierte Instanz möglicherweise einen veralteten Zustand liefert.<\/p>\n
Aktualität bei Recordsets<\/h2>\n
Aber wie sieht das bei Recordsets aus – liefern diese auch in Abhängigkeit von CurrentDb<\/b>\/db <\/b>unterschiedliche Ergebnismengen Das haben wir uns in der Prozedur aus Listing 1 angeschaut. Hier haben wir die Tabelle tblTest <\/b>zunächst vollständig geleert. Dann haben wir ein Recordset<\/b>-Objekt auf Basis des in der in der Variablen db <\/b>gespeicherten Database<\/b>-Objekts geöffnet und über die Execute<\/b>-Methode des Database<\/b>-Objekts aus db <\/b>einen neuen Datensatz erstellt.<\/p>\n
Public Sub <\/span>TestDatenAktuell()\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Set<\/span> db = CurrentDb\r\n     db.Execute \"DELETE FROM tblTest\", dbFailOnError\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblTest\", dbOpenDynaset)\r\n     Debug.Print<\/span> \"Anzahl vorher: \" & rst.RecordCount\r\n     db.Execute \"INSERT INTO tblTest(Test) VALUES(''''Test'''')\", dbFailOnError\r\n     Debug.Print<\/span> \"Anzahl nachher: \" & rst.RecordCount\r\n     Debug.Print<\/span> \"Anzahl CurrentDb: \" & CurrentDb.OpenRecordset(\"tblTest\").RecordCount\r\n     Debug.Print<\/span> \"Anzahl db\/rst neu: \" & db.OpenRecordset(\"tblTest\").RecordCount\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Test, wo neue Datensätze erfasst werden<\/span><\/b><\/p>\n
Das Recordset rst <\/b>enthält dann keine aktualisierten Daten und liefert den Wert 0<\/b> als Anzahl. Wenn wir die Anzahl über ein neues Recordset auf Basis von CurrentDb <\/b>ermittelt, ist diese aktuell – genauso, wenn wir ein neues Recordset auf Basis von db <\/b>erstellen. Sie können das Recordset also neu füllen und erhalten dann auch die aktuellen Daten, auch wenn db <\/b>mit CurrentDb <\/b>in einem älteren Zustand des Database<\/b>-Objekts gefüllt wurde.<\/p>\n
Eigenschaften und Methoden des Database-Objekts<\/h2>\n
Das mit CurrentDb <\/b>gefüllte Database<\/b>-Objekt und der Direktzugriff mit CurrentDb <\/b>liefert die gleichen Eigenschaften und Methoden, die wir im Anschluss betrachten:<\/p>\n