<\/p>\n
Erfahren Sie, wie Sie in Datensatzgruppen navigieren und die Inhalte manipulieren.<\/p>\n
VBA, DAO<\/p>\n
Access 97 und höher<\/p>\n
DAO2.mdb<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Hat man einmal ein Recordset-Objekt erzeugt und mit den benötigten Daten gefüllt, möchte man auch damit arbeiten. Die Bibliothek DAO (Data Access Objects) greift einem dabei tüchtig unter die Arme – doch das Navigieren in Datensatzgruppen und das Anlegen, Bearbeiten oder Löschen von Datensätzen gerät damit zur Fleißarbeit.<\/b><\/p>\n
Navigieren bedeutet in Zusammenhang mit Datensatzgruppen, dass man den Datensatzzeiger auf einen der Datensätze verschiebt. Nach dem öffnen befindet sich dieser Zeiger auf dem ersten Datensatz der Datensatzgruppe – sofern diese überhaupt einen Datensatz enthält.<\/p>\n
Leere Datensatzgruppen führen manchmal zu Problemen, also erfahren Sie zunächst, wie Sie solche zuverlässig identifizieren. Der Datensatzzeiger kann im Falle einer leeren Datensatzgruppe ja theoretisch auch auf keinen Datensatz zeigen – was sich auch bemerkbar macht, wenn man nach dem öffnen eines leeren Recordsets versucht, den Inhalt des aktuellen Datensatzes zu lesen: Dann gibt es nämlich eine Fehlermeldung.<\/p>\n
EOF und BOF<\/b><\/p>\n
Das Recordset-Objekt hat keine spezielle Eigenschaft, mit der Sie den „leeren“ Zustand testen können. Stattdessen benötigen Sie für diese Prüfung zwei Eigenschaften, die auf den ersten Blick gar nicht danach aussehen, also ob sie das Fehlen jeglicher Datensätze bestätigen könnten. Die beiden Eigenschaften heißen EOF und BOF und liefern einen Booleschen Wert. Im Falle der Eigenschaft EOF lautet dieser Wert True, wenn sich der Datensatzzeiger hinter dem letzten Datensatz befindet, und BOF liefert True, wenn der Datensatzzeiger vor dem ersten Datensatz ins Leere zeigt.<\/p>\n
Das ganze kann man sich wie in Bild 1 vorstellen: Im ersten Kasten zeigt der Datensatzzeiger auf den ersten Datensatz, dementsprechend haben die beiden Eigenschaften EOF und BOF den Wert False. Verschiebt man den Datensatzzeiger von dort aus eine Position nach oben (oder nach vorne, je nach Sichtweise), befindet sich dieser vor dem ersten Datensatz – die Eigenschaft BOF liefert den Wert True zurück. Befindet sich der Datensatzzeiger hinter dem letzten Datensatz, hat wiederum EOF den Wert True.<\/p>\n
Fehlt schließlich noch die Variante mit einer leeren Datensatzgruppe: Zugegebenermaßen fällt es hier schwer, eine Datensatzposition zu beschreiben. Laut Access nimmt der Datensatzzeiger direkt beide Positionen ein, die nicht auf einem Datensatz zeigen, denn BOF und EOF haben beide den Wert True.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{B7313808-0CF0-492E-A7DD-0446C97BAA8B}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Der Datensatzzeiger an verschiedenen Positionen im gefüllten und im leeren Recordset<\/span><\/b><\/p>\n Eine leere Datensatzgruppe weist man dementsprechend mit den fettgedruckten Anweisungen aus Quellcode 1 nach.<\/p>\n Quellcode 1: Diese Routine meldet eine leere Datensatzgruppe.<\/b><\/p>\n In den folgenden Codebeispielen lassen wir häufig wiederkehrende Zeilen wie die Deklaration der Objektvariablen oder deren Freigabe aus Platzgründen weg. Die vollständigen Routinen finden Sie im Modul mdlDAO2 der Beispieldatenbank. <\/p>\n Move!<\/b><\/p>\n Wenn Sie sichergestellt haben, dass Sie es nicht mit einer leeren Datensatzgruppe zu tun haben, können Sie je nach der Art des Recordsets darin navigieren. Dabei kommt es darauf an, mit welchem Parameter für den Typ des Recordsets Sie beim öffnen angeben – mehr dazu im ersten Teil dieser Beitragsreihe (Shortlink 354). In der Regel setzt man die Option dbOpenDynaset ein – Sie können den Datensatzzeiger vorwärts und rückwärts durch solche Recordsets bewegen und in den meisten Fällen die enthaltenen Daten ändern.<\/p>\n Verantwortlich für die passenden Schritte sind die vier Methoden MoveNext, MovePrevious, MoveLast und MoveFirst.<\/p>\n Dabei ist die MoveNext-Methode die populärste. Das liegt daran, dass man meist ein komplettes Recordset Datensatz für Datensatz durchläuft – und zwar von vorne nach hinten (s. Quellcode 2).<\/p>\n Das Durchlaufen der Datensätze erfolgt meist innerhalb einer Do While-Schleife. Deren Abbruchbedingung lautet Not rst.EOF – sprich: solange der Datensatzzeiger sich nicht hinter dem letzten Datensatz befindet. Bekanntermaßen befindet sich dieser Zeiger nach dem öffnen des Recordsets auf dem ersten Datensatz (abhängig von der gewählten Sortierung). Innerhalb der Schleife sollte man also zunächst die Anweisungen einfügen, die die gewünschten Aktionen mit dem Datensatz durchführen, und vor dem Ende der Schleife den Datensatzzeiger weiterschieben (rst.MoveNext).<\/p>\n Quellcode 2: Alle Datensätze eines Recordsets durchlaufen<\/b><\/p>\n Wozu benötigt man die übrigen Move…-Methoden, wenn man doch mit MoveNext schon die komplette Datensatzgruppe durchlaufen kann Zum datensatzweisen Vor- und Zurückspringen jedenfalls sehr selten. Die MoveFirst-Methode kommt hin und wieder zum Einsatz, wenn man die gleiche Datensatzgruppe gleich mehrere Male hintereinander durchlaufen möchte. Dann springt man zwischen den Durchläufen mit dieser Methode wieder an die erste Stelle (s. Quellcode 3).<\/p>\n Quellcode 3: Eine Datensatzgruppe zwei Mal durchlaufen<\/b><\/p>\n Eine weitere Einsatzmöglichkeit für die MoveLast- und die MoveFirst-Methode ist das Zählen von Datensätzen. Prinzipiell gibt es dazu zwar die RecordCount-Eigenschaft von Datensätzen, allerdings arbeitet diese anders als erwartet. Die Routine aus Quellcode 4 gibt beispielsweise nicht wie erwartet den Wert 9 als Anzahl der Personal-Datensätze aus, sondern den Wert 1.<\/p>\n Quellcode 4: Falsches Zählen von Datensätzen<\/b><\/p>\n Der Grund ist, dass die RecordCount-Eigenschaft nur die Datensätze zählt, auf die die Routine bereits zugegriffen hat. Im vorliegenden Fall hat die Routine auf Anhieb nur den ersten Datensatz geladen – daher das Ergebnis 1. Wenn Sie vor dem Zählen per MoveNext auf den zweiten Datensatz springen, gibt die RecordCount-Eigenschaft den Wert 2 zurück. Sie müssen also zum letzten Datensatz springen, um mit RecordCount die korrekte Anzahl Datensätze zu ermitteln – das erledigt die MoveLast-Methode. Nach dem Zählen müssen Sie wieder zum ersten Datensatz springen, um wie gewohnt mit der Datensatzgruppe arbeiten zu können (s. Quellcode 5).<\/p>\n Quellcode 5: Korrektes Zählen der Datensätze eines Recordsets<\/b><\/p>\n <\/p>\n Wenn das Recordset nur eine einzige Tabelle als Datenherkunft hat, können Sie die RecordCount-Eigenschaft in Verbindung mit dem Parameter acOpenTable beim öffnen der Datensatzgruppe verwenden (s. Quellcode 6).<\/p>\n Quellcode 6: Datensätze zählen im Table-Recordset<\/b><\/p>\n Neben den bereits vorgestellten Methoden via MoveFirst und MoveLast gibt es noch eine weitere Variante, um den Datensatzzeiger zu bewegen: Die Methode Move hat zwei Parameter, die genau festlegen, auf welchen Datensatz der Zeiger positioniert werden soll. <\/p>\n Dabei legt der erste Parameter fest, um wieviel Datensätze der Datensatzzeiger vor- oder zurückspringen soll – hier sind nur positive oder negative Ganzzahlen zulässig. Der zweite Parameter legt den Startpunkt fest – dazu später mehr.<\/p>\n Die Routine aus Quellcode 6 lässt den zweiten Parameter der Move-Methode leer. Daher startet sie mit dem aktuellen (also dem ersten) Datensatz und springt dann solange um je fünf Datensätze weiter, bis sie das Ende des Recordsets erreicht.<\/p>\n Das bedeutet, dass der jeweils aktuelle Datensatz Ausgangspunkt für die nächste Bewegung ist.<\/p>\n Quellcode 6: Jeden fünften Datensatz eines Recordsets anspringen<\/b><\/p>\n Möchte man einen bestimmten Datensatz als Ausgangspunkt für die Move-Methode verwenden, muss man den Datensatz mit einem Lesezeichen (Bookmark) versehen und dieses als zweiten Parameter der Move-Methode angeben.<\/p>\n Um die Bookmark-Eigenschaft eines bestimmten Datensatzes zu speichern, muss man den Datensatzzeiger aber ohnehin auf diesen Datensatz setzen – und dann kann man den Datensatzzeiger auch direkt von dort per Move weiterbewegen.<\/p>\n Lesezeichen<\/b><\/p>\n Lesezeichen machen generell nur Sinn, wenn Sie sich einen Datensatz „merken“ möchten, um später, wenn der Datensatzzeiger sich längst auf einer anderen Position befindet, zu dem gemerkten Datensatz zurückzukehren.<\/p>\n Die Bookmark-Eigenschaft eines Recordsets liefert einen Wert zurück, den Sie etwa in einer Variant-Variablen speichern können. Um später zu dem so „gemerkten“ Datensatz zurückzukehren, weisen Sie der Bookmark-Eigenschaft diesen Variant-Wert erneut zu.<\/p>\n Die Routine aus Quellcode 7 zeigt, wie das funktioniert. Beachten Sie:<\/p>\n Quellcode 7: Datensatz per Bookmark merken<\/b><\/p>\n Position des Datensatzzeigers verfolgen<\/b><\/p>\n Für manche Anwendungsfälle ist die aktuelle Position des Datensatzzeigers interessant. Diese lässt sich sowohl absolut als auch prozentual ermitteln. Ein Einsatzgebiet sind etwa umfangreiche änderungen am Datenbestand, die eine Anzeige des Fortschritts erfordern.<\/p>\n Quellcode 8 zeigt die einfachste denkbare Fortschrittsanzeige: Sie verwendet die Eigenschaft PercentPosition des Recordsets, um die aktuelle Position des Datensatzzeigers festzustellen und gibt diese passend formatiert in der Statusleiste des Access-Fensters aus. Dabei durchläuft die Routine eine Datensatzgruppe, die auf der Tabelle Bestellungen basiert.<\/p>\n Damit dies nicht zu schnell geht, ist eine kleine Bremse eingebaut: ein Aufruf der API-Funktion Sleep, die eine dem per Parameter übergebenen Zahlenwert in der Einheit Millisekunden entsprechende Pause macht. Wichtig ist hier wie auch beim Zählen von Datensätzen: Die Eigenschaft PercentPosition bezieht sich auf die beim Aufruf bekannte Anzahl von Datensätzen.<\/p>\n Um garantiert die richtigen Prozentzahlen zu erhalten, sollte man den Datensatzzeiger daher zuvor auf den letzten und zurück auf den ersten Datensatz bewegen.<\/p>\n Quellcode 8: Einfache Fortschrittsanzeige mit PercentPosition<\/b><\/p>\n Die Eigenschaft AbsolutPosition arbeitet ähnlich, gibt jedoch eine Zahl zurück, die der Datensatznummer in der Datenblattansicht entspricht.<\/p>\n Nachdem Sie sich nun blind vorwärts und rückwärts durch die Datensätze eines Recordsets bewegen können, sollen Sie auch etwas mit den enthaltenen Daten anstellen: nämlich Daten lesen, neue Daten anlegen und vorhandene Daten bearbeiten oder löschen.<\/p>\n Daten lesen<\/b><\/p>\n Jedes Recordset enthält eine Auflistung mit den Feldern der zugrunde liegenden Tabelle(n). über diese greifen Sie auf die darin enthaltenen Daten zu.<\/p>\n Quellcode 9 zeigt eine einfache Methode, auf die Felder eines Recordsets zuzugreifen. Da der Zugriff direkt nach dem öffnen des Recordsets erfolgt und der Datensatzzeiger nicht zu einem anderen Datensatz bewegt wurde, geben die nachfolgenden Anweisungen die Daten der Felder aus dem ersten Datensatz aus.<\/p>\n Der Zugriff erfolgt in diesem Beispiel mit der Aufrufezeichen-Syntax über eine sehr einfache Form: rst!Vorname gibt so beispielsweise den Inhalt des Feldes Vorname des aktuellen Datensatzes des Recordsets rst zurück.<\/p>\n Quellcode 9: Ausgeben des ersten Datensatzes des Recordsets<\/b><\/p>\n In der Routine aus Quellcode 9 erfolgt der Bezug auf das Feld Personal-Nr in eckigen Klammern: [Personal-Nr]. Dies ist immer dann erforderlich, wenn der Feldname nicht-alphanumerische Zeichen wie einen Bindestrich oder ein Leerzeichen enthält. <\/p>\n Die ausführlichste Schreibweise, auf ein Feld eines Recordsets zuzugreifen, ist die folgende:<\/p>\n Vorname ist nämlich eigentlich ein Element der Fields-Auflistung. Da Fields die Standardauflistung des Recordset-Objekts ist, kann man dies folgendermaßen abkürzen:<\/p>\n Value ist wiederum die Standardeigenschaft des Field-Objekts und kann daher weggelassen werden:<\/p>\n Und den Rest können Sie mit der Ausrufezeichen-Schreibweise noch weiter eindampfen:<\/p>\n Und wenn Sie auf diese Weise auf mehrere Elemente des Recordsets zugreifen, spart die With-Schreibweise noch mehr Schreibarbeit – wie folgendes Beispiel zeigt:<\/p>\n Eine weitere Möglichkeit ist das Referenzieren eines Feldes über seine Ordinalzahl:<\/p>\n Die Lesbarkeit bleibt hier allerdings auf der Strecke.<\/p>\n Wenn Sie einmal alle Felder eines Datensatzes anzeigen möchten und Ihnen die Schreibarbeit zu viel ist, können Sie die Felder in einer For-Each-Schleife durchlaufen. Das sieht dann wie in Quellcode 10 aus; das Ergebnis liefert Abb. 2.<\/p>\n Quellcode 10: Ausgeben aller Felder eines Datensatzes und ihrer Werte<\/b><\/p>\n Die Techniken für den Zugriff auf die Felder eines Datensatzes lassen sich natürlich in alle weiter oben vorgestellten Routinen einsetzen, die die Navigation in Datensatzgruppen veranschaulichen – beispielsweise überall dort, wo Sie den Kommentar „etwas mit dem Datensatz tun“ finden. <\/p>\n Datensatz anlegen<\/b><\/p>\n Zum Anlegen eines neuen Datensatzes müssen Sie zugegebenermaßen gar nicht groß navigieren: Sie fügen ihn einfach mit einigen Anweisungen hinzu. Die Routine aus Quellcode 11 enthält die wichtigsten Schritte:<\/p>\n Quellcode 11: Anlegen eines neuen Datensatzes<\/b><\/p>\n Datensätze bearbeiten<\/b><\/p>\n Das Bearbeiten ähnelt dem Hinzufügen eines Datensatzes. Es gibt allerdings zwei wichtige Unterschiede: Sie müssen vorher den zu bearbeitenden Datensatz auswählen (sofern es sich nicht um den ersten Datensatz des Recordsets handelt), und Sie verwenden nicht die Anweisung AddNew zum Anlegen eines Datensatzes, sondern Edit. Mit diesem Kommando ändern Sie den Status des Datensatzes zum Bearbeiten.<\/p>\n Die Routine aus Quellcode 12 verwendet die FindFirst-Methode (mehr dazu im nächsten Teil dieser Beitragsreihe), um zu einem bestimmten Datensatz zu navigieren und ändert ein Feld in diesem Datensatz.<\/p>\n <\/b><\/p>\n Bild 2: Ausgabe aller Felder eines Datensatzes und ihrer Inhalte<\/span><\/b><\/p>\n Wichtig ist dabei die Abfolge aus dem vorbereitenden Edit, der eigentlichen änderung durch Zuweisung der neuen Daten an die passenden Felder und schließlich das übernehmen der änderungen mit der Update-Anweisung.<\/p>\n Quellcode 12: ändern eines vorhandenen Datensatzes<\/b><\/p>\n Quellcode 12: Massenweise Datensatzänderungen<\/b><\/p>\n Quellcode 13: Aktualisieren mehrere Datensätze auf einen Rutsch<\/b><\/p>\n Quellcode 14: Löschen eines Datensatzes<\/b><\/p>\n Natürlich können Sie mit DAO auch mehrere Datensätze durchlaufen und ändern. Quellcode 12 zeigt ein Beispiel dafür: Die enthaltene Routine erhöht die Einzelpreis aller Artikel um 5 %. Hier sehen Sie außerdem, dass man durchaus in einer Zeile lesend auf einen Feldwert zugreifen und diesen kurz darauf ändern kann.<\/p>\n Bevor Sie massenhaft änderungen von Daten per DAO durchführen, sollten Sie vorher genau prüfen, ob dies nicht auch mit einer SQL-Aktionsabfrage möglich ist. Diese funktioniert nämlich in der Regel sehr viel schneller. Im vorliegenden Fall geht das, wie Quellcode 13 zeigt.<\/p>\n Löschen von Datensätzen<\/b><\/p>\n Das Löschen von Datensätzen erfolgt ganz einfach mit der Delete-Methode. Wiederum sollte man natürlich vorher zu dem Datensatz navigieren, der gelöscht werden soll, wie die Routine aus Quellcode 14 zeigt.<\/p>\n Bearbeiten unmöglich<\/b><\/p>\n Unter Umständen können Sie dem Recordset gar keine Daten hinzufügen oder dessen Daten ändern. Das hängt auch davon ab, wie Sie die Datensatzgruppe geöffnet haben und – wenn mehrere Tabellen beteiligt sind – wie diese miteinander verknüpft sind. Ohne hier ins Detail zu gehen: Es gibt zwei Möglichkeiten, zu prüfen, ob ein Recordset bearbeitbar ist. Die erste Lösung verwendet dazu VBA: Dabei hilft die Recordset-Eigenschaft Updateable. Wenn Sie die Datensätze bearbeiten können, liefert diese Eigenschaft den Wert True zurück. Wenn dies nicht der Fall ist und Sie nicht wissen, woran es liegt, greifen Sie zum zweiten Lösungsansatz: Legen Sie eine Abfrage an, die der Datenherkunft des Recordsets entspricht. Enthält die Datenherkunft mehrere Tabellen, können Sie so unter Umständen erkennen, ob eine unglückliche Zusammenstellung von Tabellen und Verknüpfungen das Aktualisieren verhindert.<\/p>\n Die nächste Folge dieser Beitragsreihe beschäftigt sich mit dem Filtern und Sortieren von Datensätzen. Außerdem lernen Sie Möglichkeiten kennen, effektiv in Datensatzgruppen zu suchen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n DAO00.mdb<\/p>\n DAO97.mdb<\/p>\nPublic Sub Datensatzzeiger()\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset( _ \"Artikel_Leer\", dbOpenDynaset)\r\n If rst.EOF And rst.BOF Then\r\n MsgBox \"Die Datensatzgruppe ist leer.\"\r\n End If\r\n rst.Close\r\n Set rst = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
Public Sub DatensaetzeDurchlaufen()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n Do While Not rst.EOF\r\n ''etwas mit dem Datensatz tun\r\n rst.MoveNext\r\n Loop\r\n ''...<\/pre>\n
Vor und zurück<\/h3>\n
Public Sub DatensaetzeZweiMalDurchlaufen()\r\n ''...\r\n Do While Not rst.EOF\r\n ''etwas mit dem Datensatz tun\r\n rst.MoveNext\r\n Loop\r\n rst.MoveFirst\r\n Do While Not rst.EOF\r\n ''etwas mit dem Datensatz tun\r\n rst.MoveNext\r\n Loop\r\n ''...<\/pre>\n
Datensätze zählen<\/h3>\n
Public Sub DatensaetzeZaehlenFalsch()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n Debug.Print \"Anzahl Datensätze: \" _ & rst.RecordCount\r\n ''...<\/pre>\n
Public Sub DatensaetzeZaehlen()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n rst.MoveLast\r\n Debug.Print \"Anzahl Datensätze: \" _ & rst.RecordCount\r\n rst.MoveFirst\r\n ''etwas mit dem Datensatz tun\r\n ''...<\/pre>\n
Public Sub DatensaetzeZaehlenTable()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenTable)\r\n Debug.Print \"Anzahl Datensätze: \" _ & rst.RecordCount\r\n ''...<\/pre>\n
Move individuell<\/h3>\n
Public Sub MoveInFuenferSchritten()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Artikel\", _ dbOpenDynaset)\r\n Do While Not rst.EOF\r\n ''etwas mit dem Datensatz tun\r\n rst.Move 5\r\n Loop\r\n ''...<\/pre>\n
Public Sub BookmarkBeispiel()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Artikel\", _ dbOpenDynaset)\r\n ''zu einem beliebigen Datensatz navigieren\r\n ''...\r\n ''Datensatz mit Lesezeichen merken\r\n varBookmark = rst.Bookmark\r\n ''zu einem anderen Datensatz navigieren\r\n ''...\r\n ''zum gemerkten Datensatz zurück\r\n rst.Bookmark = varBookmark\r\n ''...<\/pre>\n
Declare Sub Sleep Lib \"kernel32\" _ (ByVal dwMilliseconds As Long)\r\nPublic Sub Fortschritt()\r\n ''...\r\n Set rst = db.OpenRecordset( _ \"Bestellungen\", dbOpenDynaset)\r\n rst.MoveLast\r\n rst.MoveFirst\r\n Do While Not rst.EOF\r\n Sleep 20\r\n SysCmd acSysCmdSetStatus, _ \"Fortschritt: \" _ & Format(rst.PercentPosition, _ \"0\") & \"%\"\r\n rst.MoveNext\r\n Loop\r\n ''...<\/pre>\n
Public Sub DatensatzAusgeben()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n Debug.Print \"P.-Nr: \" & rst![Personal-Nr]\r\n Debug.Print \"Vorname: \" & rst!Vorname\r\n Debug.Print \"Nachname: \" & rst!Nachname\r\n ''...<\/pre>\n
Hinweis<\/h3>\n
Schreibweisen zum Referenzieren von Feldern<\/h3>\n
rst.Fields(\"Vorname\").Value<\/pre>\n
rst(\"Vorname\").Value<\/pre>\n
rst(\"Vorname\")<\/pre>\n
rst!Vorname<\/pre>\n
With rst\r\n Debug.Print \"Personal-Nr: \" _ & ![Personal-Nr]\r\n Debug.Print \"Vorname: \" & !Vorname\r\n Debug.Print \"Nachname: \" & !Nachname\r\nEnd With<\/pre>\n
rst(1)<\/pre>\n
Alle Felder anzeigen<\/h3>\n
Public Sub AlleFelderAusgeben()\r\n Dim fld As DAO.Field\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n For Each fld In rst.Fields\r\n Debug.Print fld.Name & \": \" _ & fld.Value\r\n Next fld\r\n ''...<\/pre>\n
Hinweis<\/h3>\n
Public Sub NeuerDatensatz()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n With rst\r\n .AddNew\r\n !Nachname = \"Minhorst\"\r\n !Vorname = \"André\"\r\n !Position = \"Chef\"\r\n !Anrede = \"Herr Doktor\"\r\n .Update\r\n End With\r\n ''...<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{B7313808-0CF0-492E-A7DD-0446C97BAA8B}\/pic002.png\")
<\/p>\nPublic Sub DatensatzBearbeiten()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", _ dbOpenDynaset)\r\n rst.FindFirst \"Nachname = ''Minhorst''\"\r\n If Not rst.NoMatch Then\r\n With rst\r\n .Edit\r\n !Position = \"Oberster Chef\"\r\n .Update\r\n End With\r\n End If\r\n ''...<\/pre>\n
Public Sub MehrereDatensaetzeBearbeiten()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Artikel\", _ dbOpenDynaset)\r\n Do While Not rst.EOF\r\n With rst\r\n .Edit\r\n !Einzelpreis = !Einzelpreis * 1.05\r\n .Update\r\n End With\r\n rst.MoveNext\r\n Loop\r\n ''...<\/pre>\n
Public Sub MehrereDatensaetzeBearbeitenSQL()\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n db.Execute \"UPDATE Artikel SET \" _ & \"Einzelpreis = Einzelpreis * 1.05\"\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n
Public Sub DatensatzLoeschen()\r\n ''...\r\n Set rst = db.OpenRecordset(\"Personal\", dbOpenDynaset)\r\n rst.FindFirst \"Nachname = ''Minhorst''\"\r\n If Not rst.NoMatch Then\r\n rst.Delete\r\n End If\r\n ''...<\/pre>\n
Massenweise änderungen …<\/h3>\n
… lieber per SQL-Aktionsabfrage<\/h3>\n
Downloads zu diesem Beitrag<\/h3>\n