{"id":55000728,"date":"2026-10-01T00:00:00","date_gmt":"2026-10-01T00:00:00","guid":{"rendered":"http:\/\/access-basics.de\/728"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBA_basics_Datenzugriff_mit_Recordsets","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/VBA_basics_Datenzugriff_mit_Recordsets.html","title":{"rendered":"VBA [basics]: Datenzugriff mit Recordsets"},"content":{"rendered":"

Eine Prozedur, die Daten einer Tabelle verarbeiten soll, muss diese Daten zuerst lesen können. Danach soll sie vielleicht einzelne Datensätze ändern, neue anlegen oder vorhandene löschen, ohne dass dafür ein Formular geöffnet ist. Dafür verwenden wir in VBA ein Recordset. Das ist die Menge der Datensätze einer Tabelle, einer Abfrage oder einer SQL-Anweisung, die wir über ein Objekt ansprechen. Wie Du ein Recordset öffnest, seine Datensätze durchläufst, einen Datensatz suchst und Datensätze anlegst, änderst und löschst, liest Du in diesem Artikel.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels findest Du in der Datenbank VBABasics_DatenzugriffMitRecordsets.accdb<\/b>. Sie enthält die Tabelle tblPersonen<\/b> mit den Feldern PersonID<\/b> (Autowert), Vorname<\/b>, Nachname<\/b>, Ort<\/b>, Geburtsdatum<\/b> und Aktiv<\/b> sowie zehn Datensätze (siehe Bild 4). Das Modul mdlRecordsetBeispiele<\/b> enthält alle Prozeduren dieses Artikels.<\/p>\n

\"Die<\/a><\/p>\n

Bild 1: Die Beispieltabelle tblPersonen<\/p>\n

Datenbank und Recordset<\/h2>\n

Wenn eine VBA-Prozedur auf die Daten einer Tabelle zugreift, benötigen wir zwei Objekte. Das erste ist ein Database<\/b>-Objekt, das die Datenbank darstellt. Das zweite ist ein Recordset<\/b>-Objekt. Es hält die Datensätze bereit, und über seine Eigenschaften und Methoden lesen und bearbeiten wir sie.<\/p>\n

Beide Objekte gehören zur Bibliothek DAO (Data Access Objects). Der Verweis auf diese Bibliothek ist in einer neu angelegten Access-Datenbank bereits gesetzt. Aktuelle Access-Versionen verwenden dafür standardmäßig die Bibliothek Microsoft Office 16.0 Access database engine Object Library<\/b>. Wie Du die Verweise Deines VBA-Projekts ansehen kannst, liest Du im Artikel VBA [basics]: Mit Verweisen arbeiten (www.access-basics.de\/686)<\/b>.<\/p>\n

Daneben gibt es die Bibliothek ADO (ActiveX Data Objects), die ebenfalls ein Recordset<\/b>-Objekt enthält. Auf diese Bibliothek gehen wir in diesem Artikel nicht ein. Sind beide Bibliotheken eingebunden, entscheidet die Reihenfolge der Verweise, welcher Typ gemeint ist. Mit dem Präfix DAO.<\/b> in der Deklaration ist der Typ eindeutig, etwa bei Dim rst As DAO.Recordset<\/b>.<\/p>\n

Die Funktion CurrentDb<\/b> liefert das Objekt der aktuell geöffneten Datenbank. Wir speichern es in einer Variablen vom Typ DAO.Database<\/b>.<\/p>\n

Ein Recordset öffnen und durchlaufen<\/h2>\n

Die Prozedur PersonenAusgeben<\/b> öffnet die Tabelle tblPersonen<\/b> als Recordset und gibt von jedem Datensatz die PersonID<\/b> und den Namen im Direktbereich aus (siehe Listing 10).<\/p>\n

Public Sub <\/span>PersonenAusgeben()\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     Set<\/span> rst = db.OpenRecordset(\"tblPersonen\")\r\n     Do While<\/span> Not<\/span> rst.EOF\r\n         Debug.Print<\/span> rst!PersonID & \": \" & rst!Vorname & \" \" & rst!Nachname\r\n         rst.MoveNext<\/span>\r\n     Loop<\/span>\r\n     rst.Close\r\n     Set<\/span> rst = Nothing\r\n     Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Alle Personen im Direktbereich ausgeben<\/p>\n
Die Variable db<\/b> nimmt mit Set db = CurrentDb<\/b> den Verweis auf die Datenbank auf. Die Methode OpenRecordset<\/b> öffnet die Tabelle tblPersonen<\/b> und liefert das Recordset. Der Datensatzzeiger markiert den aktuellen Datensatz. Er steht nach dem Öffnen auf dem ersten Datensatz, sofern das Recordset Datensätze enthält.<\/p>\n
Die Schleife kennen wir aus dem Artikel VBA [basics]: Schleifen mit For, Do und While (www.access-basics.de\/709)<\/b>. Die Eigenschaft EOF<\/b> (End Of File) hat den Wert True<\/b>, sobald der Datensatzzeiger hinter dem letzten Datensatz steht. Die Methode MoveNext<\/b> bewegt den Zeiger auf den nächsten Datensatz. Ohne diesen Aufruf bliebe die Schleife auf dem ersten Datensatz stehen.<\/p>\n
Achte unbedingt darauf, diesen Befehl innerhalb von Schleifen immer zu setzen, da die Schleife sonst zu einer Endlos-Schleife wird.<\/p>\n
Auf die Felder des aktuellen Datensatzes greifen wir mit dem Ausrufezeichen (!<\/b>) und dem Feldnamen zu, etwa mit rst!Nachname<\/b>. Gleichwertig ist rst.Fields(„Nachname“).Value<\/b>. Diese Schreibweise nutzen wir, wenn der Feldname in einer Variablen steht.<\/p>\n
Zum Schluss schließen wir das Recordset mit rst.Close<\/b>. Mit Set rst = Nothing<\/b> und Set db = Nothing<\/b> geben wir die Objektvariablen frei.<\/p>\n
Beim Verlassen der Prozedur gibt VBA lokale Objektvariablen ebenfalls frei. Wir schließen das Recordset trotzdem selbst, denn so steht im Code, wann die Datensätze nicht mehr benötigt werden.<\/p>\n
Im Direktbereich geben wir den Namen der Prozedur ein und bestätigen mit der Eingabetaste. Den Direktbereich öffnen wir im VBA-Editor mit der Tastenkombination Strg + G<\/b>. Die Prozedur gibt zehn Zeilen aus (siehe Bild 5).<\/p>\n
\"Die<\/a><\/p>\n
Bild 2: Die Ausgabe von PersonenAusgeben im Direktbereich<\/p>\n
Hinweis: Prozeduren ohne Parameter kannst Du auch einfach aufrufen, indem Du die Einfügemarke an einer beliebigen Stelle innerhalt der Prozedur im VBA-Editor platzierst und die Taste F5 <\/b>betätigst. Für Prozeduren mit Parametern gelingt dies jedoch nicht.<\/p>\n
Tabelle, Abfrage oder SQL-Anweisung als Datenquelle<\/h2>\n
Das erste Argument von OpenRecordset<\/b> nimmt den Namen einer Tabelle, den Namen einer Abfrage oder eine SQL-Anweisung entgegen.<\/p>\n
Mit einer SQL-Anweisung laden wir nur die Felder und Datensätze, die wir benötigen. Die Prozedur PersonenAusOrt<\/b> gibt die Personen eines Orts nach dem Nachnamen sortiert aus (siehe Listing 9).<\/p>\n
Public Sub <\/span>PersonenAusOrt(strOrt As String<\/span>)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>strSQL As String<\/span>\r\n     strSQL = \"SELECT Vorname, Nachname FROM tblPersonen WHERE Ort = '\" & Replace<\/span>(strOrt, \"'\", \"''\") \"' ORDER BY Nachname\"\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> rst = db.OpenRecordset(strSQL, dbOpenSnapshot)\r\n     If <\/span>rst.EOF Then<\/span>\r\n         Debug.Print<\/span> \"Keine Personen in \" & strOrt\r\n     Else<\/span>\r\n         Do While<\/span> Not<\/span> rst.EOF\r\n             Debug.Print<\/span> rst!Nachname & \", \" & rst!Vorname\r\n             rst.MoveNext<\/span>\r\n         Loop<\/span>\r\n     End If<\/span>\r\n     rst.Close\r\n     Set<\/span> rst = Nothing\r\n     Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Die Personen eines Orts mit einer SQL-Anweisung ausgeben<\/p>\n
Die Variable strSQL<\/b> nimmt die SQL-Anweisung auf. Die Bedingung WHERE Ort = ‚…‘<\/b> verwendet den Wert des Parameters strOrt<\/b>. Weil Ort<\/b> ein Textfeld ist, fassen wir den Wert in Apostrophe (‚<\/b>) ein. Die Funktion Replace<\/b> verdoppelt Apostrophe im Wert. Damit endet der Text bei einem Ort wie Sant’Agata<\/b> nicht vorzeitig am Apostroph. Das zweite Argument dbOpenSnapshot<\/b> legt den Typ des Recordsets fest. Es gibt vier Typen:<\/p>\n