Es kommt regelmäßig vor, dass wir Daten in den Tabellen unserer Datenbank bearbeiten müssen. Normalerweise geschieht das über die Benutzeroberfläche. Aber es gibt auch Konstellationen, in denen wir automatisiert Daten zu einer Tabelle hinzufügen oder diese ändern wollen. Manchmal legen wir vollständige Hierarchien an inklusive Daten in verknüpften Tabellen, oder wir ändern auch nur den Wert eines einzelnen Feldes in einem Datensatz. Dazu können wir verschiedene Techniken nutzen, die wir in diesem Beitrag einmal vorstellen und vergleichen wollen. Dabei konzentrieren wir uns auf das Hinzufügen oder Bearbeiten von einzelnen Datensätzen und schauen uns zwei verschiedene Ansätze an: Das Anlegen oder Aktualisieren von Daten mit INSERT INTO oder UPDATE-Abfragen, die wir per VBA zusammenstellen und dann mit der Execute-Methode ausführen oder das Anlegen mit der Recordset-Methode AddNew\/Update und das Bearbeiten mit der Edit-Methode.<\/b><\/p>\n
DAO oder ADODB?<\/h2>\n
Mit den eingangs erwähnten beiden Möglichkeiten der Anlage und Änderung von Daten mit Execute <\/b>beziehungsweise AddNew<\/b>\/Edit <\/b>und Update <\/b>decken wir die Optionen ab, die uns die DAO-Bibliothek bietet. Wir können dies auch noch mit den Methoden der ADODB-Bibliothek erledigen.<\/p>\n
Wie wir diese Aufgaben mit ADODB erledigen, beschreiben wir in einem weiteren Beitrag namens Daten bearbeiten: Execute vs. Recordset in ADODB <\/b>(www.access-im-unternehmen.de\/****<\/b>).<\/p>\nUnterschied Execute vs. AddNew\/Update<\/h2>\n
Mit der Execute<\/b>-Anweisung, der wir eine INSERT INTO<\/b>-SQL-Abfrage übergeben und der Kombination aus AddNew <\/b>und Update <\/b>eines Recordset<\/b>-Objekts erreichen wir grundsätzlich das Gleiche: Wir fügen einer Tabelle einen Datensatz hinzu, der die gewünschten Werte enthält.<\/p>\n
Das gilt auch für das Ändern von Datensätzen, Wir können dies mit einer UPDATE<\/b>-SQL-Abfrage erledigen, die wir über die Execute<\/b>-Methode absetzen, oder wir verwenden die Edit<\/b>-Methode, führen dann die Änderungen an den gewünschten Feldern durch und speichern diese mit der Update<\/b>-Methode in der Tabelle.<\/p>\n
Mit beiden Methoden können wir bei der Neuanlage eines Datensatzes anschließend die ID des Primärschlüsselwertes auslesen, sofern für dieses Feld die Autowert-Funktion aktiviert ist.<\/p>\n
Die weiteren Unterschiede, die wir in den folgenden Abschnitten besprechen werden, beziehen sich im Komfort, der sich beim Zusammenstellen der jeweiligen Codezeilen ergibt.<\/p>\n
Wenn wir die Execute<\/b>-Methode verwenden wollen, müssen wir uns grundlegend mit der Schreibweise von SQL-Anweisungen auskennen, zumindest für die SQL-Abfragen INSERT INTO <\/b>und UPDATE<\/b>.<\/p>\n
Außerdem sind hier im Gegensatz zur Verwendung von AddNew<\/b>\/Edit <\/b>und Update <\/b>noch einige Besonderheiten bei der Angabe der einzufügenden oder zu ändernden Feldwerte relevant: Wenn wir beispielsweise Textfelder füllen wollen, müssen wir diese in Hochkommata einfassen, bei Datumsfeldern müssen wir ein SQL-kompatibles Datumsformat verwenden und bei Zahlen mit Dezimaltrennzeichen müssen wir sicherstellen, dass das vom SQL Server verwendete Dezimaltrennzeichen verwendet wird.<\/p>\n
Außerdem müssen wir auch die Werte für Ja\/Nein<\/b>-Felder entsprechend formatieren.<\/p>\n
Die Methoden AddNew<\/b>\/Edit <\/b>plus Update <\/b>sind hier wesentlich einfacher in der Handhabung. Wir können alle Werte einfach übergeben, so wie wir auch in VBA damit arbeiten.<\/p>\nBeispieltabelle<\/h2>\n
Als Beispiel verwenden wir die Tabelle tblKunden<\/b> aus Bild 1.<\/p>\n
![\"Beispieltabelle](\"..\/fileadmin\/_temp_\/2025_06\/pic_1580_001.png\")
<\/p>\n
Bild 1: Beispieltabelle tblKunden<\/span><\/b><\/p>\n Diese enthält alle relevanten Datentypen, die wir für die unterschiedlichen Schreibweisen in INSERT INTO<\/b>– und UPDATE<\/b>-Abfragen benötigen: Kurzer Text<\/b>, Datum<\/b>, Ja\/Nein <\/b>und Währung <\/b>(stellvertretend für alle Felddatentypen mit Nachkommastellen).<\/p>\n Wir schauen uns zuerst das Einfügen eines Datensatzes mit der AddNew<\/b>– und der Update<\/b>-Methode eines Recordsets an.<\/p>\n Hier deklarieren wir als Erstes zwei Variablen. Mit db <\/b>referenzieren wir das mit der CurrentDb<\/b>-Funktion ermittelte Database<\/b>-Objekt der aktuellen Datenbank. Mit rst <\/b>holen wir uns ein Recordset<\/b>-Objekt auf Basis der Tabelle tblKunden<\/b>.<\/p>\n Dazu nutzen wir die OpenRecordset<\/b>-Methode des Database<\/b>-Objekts:<\/p>\n Danach können wir direkt mit dem Einfügen eines Datensatzes beginnen. Dazu versetzen wir das Recordset mit der AddNew<\/b>-Methode in den Einfügemodus für einen neuen Datensatz:<\/p>\n Dann weisen wir den einzelnen Feldern der Tabelle, die wir über das Ausrufezeichen angeben, die gewünschten Werte zu:<\/p>\n Danach schließen wir das Anlegen des neuen Datensatzes ab, indem wir die Update<\/b>-Methode aufrufen und damit den Datensatz in der dem Recordset zugrunde liegenden Tabelle speichern:<\/p>\n Damit legen wir den Datensatz aus Bild 2 in der Tabelle an.<\/p>\n Bild 2: Neuer Datensatz in der Tabelle tblKunden<\/span><\/b><\/p>\n Das Feld KundeID <\/b>haben wir in der Tabelle als Autowert<\/b>-Feld definiert. Das heißt, dass wir es nicht nur nicht zu füllen brauchen – es wird automatisch mit dem durch die Autowert-Funktion ermittelten Wert gefüllt.<\/p>\n Diese entspricht immer dem zuletzt hinzugefügten Wert für dieses Feld plus 1<\/b>.<\/p>\n Wir können aber auch das Feld KundeID <\/b>übergeben, wenn wir einmal einen anderen Wert als den durch die Autowert-Funktion vorgegebenen Wert angeben wollen:<\/p>\n Dabei sind folgende Dinge zu beachten:<\/p>\n Die manuelle Vorgabe eines Wertes für ein Autowert-Feld sollte also mit Bedacht durchgeführt werden.<\/p>\n Wir haben hier das Datum einfach als Zeichenkette übergeben („23.01.1971“<\/b>). Damit haben wir Potenzial für einen Laufzeitfehler geschaffen, denn das Datum muss unbedingt ein gültiges Datum sein. Wir könnten auch die folgende Schreibweise verwenden:<\/p>\n Diese wird auf Systemen mit deutschen Lokaleinstellungen jedoch direkt in die folgende Zeile umgewandelt:<\/p>\n Wie können aber auch die Zeichenkette „23.01.1971“ <\/b>vorsichtshalber mit der CDate<\/b>-Funktion in ein gültiges Datum umwandeln oder vorab mit IsDate <\/b>prüfen, ob es sich um ein gültiges Datum handelt.<\/p>\n Dies können wir auch erledigen, indem wir die Werte für die einzelnen Felder zuvor in Variablen speichern und diese dann den Feldern zuweisen. Wir starten wie zuvor:<\/p>\n Dann deklarieren wir die Variablen, die wir mit den einzufügenden Werten füllen wollen, und versehen diese gleich mit den entsprechenden Datentypen:<\/p>\n Das Database<\/b>-Objekt und das Recordset<\/b>-Objekt füllen wir wie zuvor:<\/p>\n Dann weisen wir die Werte den Variablen zu, die wir gleich zum Einfügen nutzen wollen:<\/p>\n Schließlich rufen wir AddNew <\/b>auf, weisen die Werte aus den Variablen den einzelnen Feldern zu und speichern den Datensatz mit der Update<\/b>-Methode:<\/p>\n Dies ist erst einmal wesentlich mehr Schreibarbeit, aber wir bereiten damit etwas vor, was in der Praxis wesentlich häufiger vorkommen wird als das Eintragen von fest im Code angegebenen Werten, nämlich das Übergeben der anzulegenden Informationen per Parameter. Damit können wir mit einem einzigen Aufruf unter Angabe der für den neuen Datensatz einzufügenden Werte einen neuen Datensatz in der gewünschten Tabelle anlegen.<\/p>\n Dazu holen wir die Variablen einfach in die Parameterliste der Prozedur:<\/p>\n Die folgenden Schritte sind identisch mit denen der vorherigen Prozedur:<\/p>\n Diese Funktion können wir nun von beliebiger Stelle innerhalb des VBA-Projekts wie folgt aufrufen und haben damit eine Wrapper-Funktion zum Anlegen eines neuen Datensatzes in die Tabelle tblKunden <\/b>geschaffen:<\/p>\n Wenn wir wie zuvor beschrieben erst einen Kunden anlegen und dann eine Bestellung für diesen hinzufügen wollen, benötigen wir den Wert des Feldes KundeID <\/b>für den neu hinzugefügten Kunden, um die neue Bestellung mit diesem verknüpfen zu können. Bei Verwendung von AddNew<\/b>\/Update <\/b>ist das Ermitteln allerdings recht einfach.<\/p>\n Wir müssen lediglich den Wert des Feldes KundeID <\/b>abfragen, bevor wir den Datensatz mit der Update<\/b>-Methode speichern.<\/p>\n Warum vorher? Weil durch die Update<\/b>-Methode der Datensatzzeiger nicht mehr auf dem angelegten Datensatz steht. Den Wert des Feldes KundeID <\/b>lesen wir also wie folgt aus: <\/p>\n Es gibt jedoch noch eine weitere Möglichkeit, die gerade bei Verwendung von SQL Server als Backend notwendig ist. Dabei setzen wir mit LastModified <\/b>ein Bookmark auf den Datensatz, der zuletzt geändert wurde – in diesem Fall den zuletzt angelegten Datensatz.<\/p>\n Anschließend können wir damit wieder den Wert des Feldes KundeID <\/b>für den neuen Datensatz auslesen:<\/p>\n Wenn wir die Execute<\/b>-Methode des Database<\/b>-Objekts nutzen wollen, um beispielsweise einen neuen Datensatz mit INSERT INTO <\/b>einzufügen, benötigen wir im Unterschied zu AddNew<\/b>\/Update <\/b>kein Recordset<\/b>-Objekt.<\/p>\n Dafür müssen wir die auszuführende Abfrage aber direkt vollständig zusammenstellen, statt bequem die einzelnen Werte den Feldern zuzuweisen. Das sieht auf den ersten Blick unübersichtlicher aus, aber letztlich sind die gleichen Elemente enthalten.<\/p>\n Wie beginnen mit dem Definieren von Variablen für das Database<\/b>-Objekt und für die zu verwendenden SQL-Anweisung:<\/p>\n Die Variable strSQL <\/b>benötigt man nicht zwangsläufig, aber es kann hilfreich sein, wenn man zu Testzwecken die verwendete SQL-Anweisung im Direktbereich ausgeben möchte. Außerdem wird die Lesbarkeit so verbessert.<\/p>\n Wir füllen wieder die Variable db<\/b> mit dem Wert aus CurrentDb<\/b>:<\/p>\n Dann stellen die SQL-Anweisung in strSQL <\/b>zusammen (in einer Zeile eingeben):<\/p>\n INSERT INTO <\/b>erwartet zunächst den Namen der Zieltabelle und dahinter in Klammern die Liste der Felder, die wir füllen möchten.<\/p>\n Dann folgt das VALUES<\/b>-Schlüsselwort mit den in Klammern eingefassten Werten.<\/p>\n Hier sehen wir direkt die Unterschiede, die das Verwenden von Execute<\/b>\/INSERT INTO <\/b>ein wenig komplizierter machen:<\/p>\n Schließlich führen wir die Abfrage mit der Execute<\/b>-Methode aus.<\/p>\n Dabei übergeben wir als ersten Parameter die SQL-Anweisung aus der Variablen strSQL <\/b>und als zweiten den Wert dbFailOnError<\/b>:<\/p>\n Alternativ zur Execute<\/b>-Methode des Database<\/b>-Objekts können wir auch DoCmd.RunSQL <\/b>verwenden. Auch dieser übergeben wir einfach die SQL-Anweisung als Parameter. Wir empfehlen allerdings, immer Execute <\/b>zu verwenden.<\/p>\n Einer der wichtigsten Gründe ist, dass wir über die Variable db, in deren Kontext wir die Anweisung ausführen, später noch weitere Informationen erhalten können – beispielsweise die ID des neu hinzugefügten Datensatzes oder auch die Anzahl der durch die Abfrage betroffenen Datensätze. Mehr dazu lesen Sie weiter unten.<\/p>\n Außerdem kann es bei DoCmd.RunSQL <\/b>vorkommen, dass bei der Ausführung auftretende Fehler nicht gemeldet werden, wenn zuvor mit DoCmd.SetWarnings False <\/b>die Warnmeldungen deaktiviert wurden.<\/p>\n Und selbst wenn die Warnmeldungen aktiviert sind, erscheint so nur eine Systemmeldung wie die aus Bild 3.<\/p>\n Bild 3: Meldung beim Problem mit einer DoCmd.RunSQL-Anweisung<\/span><\/b><\/p>\n Angenommen, wir rufen DoCmd.RunSQL <\/b>wie folgt auf und deaktivieren die Warnmeldungen. Dann wird trotz Fehlerbehandlung am Ende der Prozedur kein Fehler ausgegeben:<\/p>\n Bei Verwendung von db.Execute <\/b>können wir den Fehler anschließend problemlos auswerten.<\/p>\n Nun schauen wir uns an, wie wir der INSERT INTO<\/b>-Anweisung einer Execute<\/b>-Methode die Werte aus Variablen übergeben. Der grundlegende Code dazu deklariert die benötigten Variablen und füllt diese mit den gewünschten Werten – so wie im obigen Beispiel für AddNew<\/b>\/Update<\/b>:<\/p>\n Dann stellen wir die SQL-Anweisung zusammen, zunächst indem wir einfach die Variablen in den SQL-Ausdruck einbinden. Bereits das ist aufwendig, weil wir überall die Zeichenkette unterbrechen und die Variablen durch Und-Zeichen (&<\/b>) integrieren müssen (in einer Zeile eintippen):<\/p>\n Beim Ausführen erhalten wir direkt den ersten Fehler (siehe Bild 4). Hier nutzen wir nun vor dem Ausführen eine zusätzliche Anweisung, mit der wir den resultierenden SQL-Ausdruck im Direktbereich ausgeben:<\/p>\n Bild 4: Fehler in der Execute-Anweisung<\/span><\/b><\/p>\n Der Fehler ist offensichtlich: Der Betrag für das Feld Jahresumsatz wurde nicht mit einem Punkt als Dezimaltrennzeichen, sondern mit einem Komma angegeben. Dies interpretiert Access-SQL als Trennzeichen zwischen zwei Feldern. Also fügen wir die erste Optimierung für das Feld Jahresumsatz <\/b>ein, indem wir das Komma mit der Replace<\/b>-Funktion durch einen Punkt ersetzen:<\/p>\n Beim nächsten Aufruf folgt die nächste Fehlermeldung (siehe Bild 5). Hier kann Access-SQL das Datum nicht korrekt interpretieren. Also nutzen wir eine Funktion, die das Datum in einen SQL-tauglichen Datumswert umwandelt:<\/p>\n Bild 5: Nächster Fehler in der Execute-Anweisung<\/span><\/b><\/p>\n Für das Datum 1.1.2000 <\/b>kommt nun beispielsweise #2000\/01\/01# <\/b>heraus, das auch gelesen werden kann, auch wenn wir die Ländereinstellungen etwa auf Englisch <\/b>wechseln. Die Funktion betten wir wie folgt ein:<\/p>\n Beim nächsten Versuch erhalten wir die Meldung aus Bild 6. Es wurden drei erwartete Parameter nicht angegeben. Die ersten beiden Fälle sind schnell ermittelt: Wir haben die Werte für die Felder Vorname <\/b>und Nachname <\/b>ohne Anführungszeichen übergeben, daher wurden diese als Parameter erkannt:<\/p>\n Bild 6: Ein weiterer Fehler in der Execute-Anweisung<\/span><\/b><\/p>\n Der dritte fälschlicherweise als Parameter erkannte Wert ist der Wert Falsch <\/b>für das Ja\/Nein<\/b>-Feld. Warum steht hier überhaupt Falsch <\/b>und nicht False<\/b>? Weil wir deutsche Ländereinstellungen verwenden und die Ausgabe einer Boolean<\/b>-Variablen als Wahr <\/b>oder Falsch <\/b>erfolgt und nicht etwa als True <\/b>oder False <\/b>beziehungsweise -1 <\/b>oder 0<\/b>.<\/p>\n Die Werte für die Textfelder fassen wir nun in Hochkommata ein:<\/p>\n Den Boolean<\/b>-Wert behandeln wir ebenfalls mit einer eigenen Funktion. Diese nimmt den Wert über einen Parameter des Typs Boolean <\/b>entgegen und prüft, ob dieser den Wert True <\/b>oder False <\/b>enthält. Im Falle von True <\/b>liefert sie die Zeichenkette True <\/b>zurück, anderenfalls die Zeichenkette False<\/b>:<\/p>\n Diese Funktion betten wir wie folgt in den SQL-Ausdruck ein:<\/p>\n Damit erhalten wir schließlich die folgende funktionierende SQL-Anweisung:<\/p>\n Die Text-Variablen sind in Hochkommata eingebettet, das Datum liegt im korrekten Format vor, der Boolean<\/b>-Wert wird als True <\/b>oder False <\/b>angegeben und das Komma im Dezimalausdruck wird durch einen Punkt ersetzt.<\/p>\n Nun können wir die Prozedur zum Anlegen eines Datensatzes noch mit Parametern ausstatten:<\/p>\n Mit dem folgenden Aufruf können wir komfortabel einen neuen Datensatz anlegen:<\/p>\n Wenn wir die Einfügen von Datensätzen per AddNew\/Update<\/h2>\n
Public Sub <\/span>Einfuegen_AddNew()\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(\"tblKunden\", dbOpenDynaset)<\/pre>\n rst.AddNew<\/span><\/pre>\n rst!Vorname = \"André\"\r\n rst!Nachname = \"Minhorst\"\r\n rst!Geburtsdatum = \"23.01.1971\"\r\n rst!Aktiv = True<\/span>\r\n rst!Jahresumsatz = 9999.99<\/pre>\n rst.Update\r\nEnd Sub<\/span><\/pre>\n![\"Neuer](\"..\/fileadmin\/_temp_\/2025_06\/pic_1580_002.png\")
<\/p>\nWo ist das Feld KundeID?<\/h2>\n
rst!KundeID = 111<\/pre>\n
\n
Schreibweisen für das Datum<\/h2>\n
rst!Geburtsdatum = #1971-01-23#<\/pre>\n
rst!Geburtsdatum = #1\/23\/1971#<\/pre>\n
AddNew mit Variablen<\/h2>\n
Public Sub <\/span>Einfuegen_AddNew_Variablen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset<\/pre>\n Dim <\/span>strVorname As String<\/span>\r\n Dim <\/span>strNachname As String<\/span>\r\n Dim <\/span>datGeburtsdatum As Date<\/span>\r\n Dim <\/span>bolAktiv As Boolean<\/span>\r\n Dim <\/span>curJahresumsatz As Currency<\/span><\/pre>\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"tblKunden\", dbOpenDynaset)<\/pre>\n strVorname = \"Klaus\"\r\n strNachname = \"Müller\"\r\n datGeburtsdatum = \"01.01.2000\"\r\n bolAktiv = False<\/span>\r\n curJahresumsatz = 8888.88<\/pre>\n rst.AddNew<\/span>\r\n rst!Vorname = strVorname\r\n rst!Nachname = strNachname\r\n rst!Geburtsdatum = datGeburtsdatum\r\n rst!Aktiv = bolAktiv\r\n rst!Jahresumsatz = curJahresumsatz\r\n rst.Update\r\nEnd Sub<\/span><\/pre>\nAddNew mit Parametern<\/h2>\n
Public Sub <\/span>Einfuegen_AddNew_Parameter( _\r\n strVorname As String<\/span>, _\r\n strNachname As String<\/span>, _\r\n datGeburtsdatum As Date<\/span>, _\r\n bolAktiv As Boolean<\/span>, _\r\n curJahresumsatz As Currency<\/span>)<\/pre>\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"tblKunden\", dbOpenDynaset)\r\n \r\n rst.AddNew<\/span>\r\n rst!Vorname = strVorname\r\n rst!Nachname = strNachname\r\n rst!Geburtsdatum = datGeburtsdatum\r\n rst!Aktiv = bolAktiv\r\n rst!Jahresumsatz = curJahresumsatz\r\n rst.Update\r\nEnd Sub<\/span><\/pre>\nCall<\/span> Einfuegen_AddNew_Parameter(\"Theo\", \"Meier\", \"31.12.1999\", True, 7777.77)<\/pre>\nID des neuen Datensatzes bei AddNew auslesen<\/h2>\n
...\r\n rst!Jahresumsatz = 9999.99\r\n Debug.Print<\/span> \"Neuer Kunde: \" & rst!KundeID\r\n rst.Update\r\n ...<\/pre>\n ...\r\n rst.Update\r\n rst.Bookmark = rst.LastModified\r\n Debug.Print<\/span> \"Neuer Kunde: \" & rst!KundeID\r\n ...<\/pre>\nEinfügen von Datensätzen mit Execute\/INSERT INTO<\/h2>\n
Public Sub <\/span>Einfuegen_INSERTINTO()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strSQL As String<\/span><\/pre>\n Set<\/span> db = CurrentDb<\/pre>\n strSQL = \"INSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(''André'', ''Minhorst'', #1971\/01\/23#, -1, 9999.99)\"<\/pre>\n\n
db.Execute strSQL, dbFailOnError\r\nEnd Sub<\/span><\/pre>\nWarum Execute und nicht DoCmd.RunSQL?<\/h2>\n
![\"Meldung](\"..\/fileadmin\/_temp_\/2025_06\/pic_1580_003.png\")
<\/p>\nPublic Sub <\/span>Einfuegen_RunSQL()\r\n Dim <\/span>strSQL As String<\/span>\r\n DoCmd.SetWarnings False<\/span>\r\n On Error Resume Next<\/span>\r\n strSQL = \"INSERT INTO tblKunden(KundeID, \" _\r\n & \"Vorname, Nachname, Geburtsdatum, Aktiv, \" _\r\n & \"Jahresumsatz) VALUES(1, ''André'', ''Minhorst'', \" _\r\n & \"''23.1.1971'', -1, 9999.99)\"\r\n \r\n DoCmd.RunSQL strSQL\r\n \r\n Debug.Print<\/span> Err.Number, Err.Description\r\nEnd Sub<\/span><\/pre>\nExecute\/INSERT INTO mit Variablen<\/h2>\n
Public Sub <\/span>Einfuegen_INSERTINTO_Variablen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n Dim <\/span>strVorname As String<\/span>\r\n Dim <\/span>strNachname As String<\/span>\r\n Dim <\/span>datGeburtsdatum As Date<\/span>\r\n Dim <\/span>bolAktiv As Boolean<\/span>\r\n Dim <\/span>curJahresumsatz As Currency<\/span>\r\n \r\n strVorname = \"Klaus\"\r\n strNachname = \"Müller\"\r\n datGeburtsdatum = \"01.01.2000\"\r\n bolAktiv = False<\/span>\r\n curJahresumsatz = 8888.88\r\n \r\n Set<\/span> db = CurrentDb<\/pre>\n strSQL = \"INSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(\" & strVorname & \", \" & strNachname & \", \" & datGeburtsdatum & \", \" & bolAktiv & \", \" & curJahresumsatz & \")\"\r\n \r\n db.Execute strSQL\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2025_06\/pic_1580_004.png\")
<\/p>\nINSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(Klaus, Müller, 01.01.2000, Falsch, 8888,88)<\/pre>\n
strSQL = \"INSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(\" & strVorname & \", \" & strNachname & \", \" & datGeburtsdatum & \", \" & bolAktiv & \", \" & Replace<\/span>(curJahresumsatz, \",\", \".\") & \")\"<\/pre>\n![\"Nächster](\"..\/fileadmin\/_temp_\/2025_06\/pic_1580_005.png\")
<\/p>\nPublic Function <\/span>ISODatum(varDate As Variant<\/span>)\r\n ISODatum = Format(varDate, _\r\n \"\\#yyyy\\\/mm\\\/dd hh\\:nn\\:ss\\#\")\r\nEnd Function<\/span><\/pre>\nstrSQL = \"INSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(\" & strVorname & \", \" & strNachname & \", \" & ISODatum(datGeburtsdatum) & \", \" & bolAktiv & \", \" & Replace<\/span>(curJahresumsatz, \",\", \".\") & \")\"<\/pre>\n![\"Ein](\"..\/fileadmin\/_temp_\/2025_06\/pic_1580_006.png\")
<\/p>\nINSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(Klaus, Müller, 01.01.2000, Falsch, 8888.88)<\/pre>\n
VALUES(''\" & strVorname & \"'', ''\" & strNachname & \"'',...<\/pre>\nBoolean-Werte für SQL-Anweisungen vorbereiten<\/h2>\n
Public Function <\/span>BooleanSQL(bol As Boolean<\/span>) As String<\/span>\r\n If <\/span>bol = True<\/span> Then<\/span>\r\n BooleanSQL = \"True\"\r\n Else<\/span>\r\n BooleanSQL = \"False\"\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n..., \" & BooleanSQL(bolAktiv) & \", ...<\/pre>\n
INSERT INTO tblKunden(Vorname, Nachname, Geburtsdatum, Aktiv, Jahresumsatz) VALUES(''Klaus'', ''Müller'', #2000\/01\/01 00:00:00#, False, 8888.88)<\/pre>\nExecute\/INSERT INTO mit Parametern<\/h2>\n
Public Sub <\/span>Einfuegen_INSERTINTO_Parameter( _\r\n strVorname As String<\/span>, _\r\n strNachname As String<\/span>, _\r\n datGeburtsdatum As Date<\/span>, _\r\n bolAktiv As Boolean<\/span>, _\r\n curJahresumsatz As Currency<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n Set<\/span> db = CurrentDb\r\n \r\n strSQL = \"INSERT INTO tblKunden(Vorname, Nachname, \" _\r\n & \"Geburtsdatum, Aktiv, Jahresumsatz) VALUES(''\" _\r\n & strVorname & \"'', ''\" & strNachname & \"'', \" _\r\n & ISODatum(datGeburtsdatum) & \", \" _\r\n & BooleanSQL(bolAktiv) & \", \" _\r\n & Replace<\/span>(curJahresumsatz, \",\", \".\") & \")\"\r\n db.Execute strSQL\r\nEnd Sub<\/span><\/pre>\nCall<\/span> Einfuegen_INSERTINTO_Parameter(\"Theo\", \"Meier\", \"31.12.1999\", True, 7777.77)<\/pre>\nID des neuen Datensatzes bei Execute auslesen<\/h2>\n