{"id":55001589,"date":"2026-02-01T00:00:00","date_gmt":"2026-01-09T11:54:25","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1589"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/","title":{"rendered":"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL"},"content":{"rendered":"<p><img loading=\"lazy\" decoding=\"async\" src=\"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34\" width=\"1\" height=\"1\" alt=\"\"><b>In unseren Audits mit unseren Kunden und Lesern untersuchen wir auch regelm&auml;&szlig;ig den VBA-Code in deren Access-Anwendungen. Dabei fallen uns immer wieder Programmiergewohnheiten auf, die irgendwann einmal eingef&uuml;hrt und seitdem nie wieder ge&auml;ndert wurden. Eine davon ist, SQL-Anweisungen wie INSERT INTO, UPDATE oder DELETE mit der Methode RunSQL der DoCmd-Klasse auszuf&uuml;hren. Das ist grunds&auml;tzlich nicht falsch, solange dies zum Ziel f&uuml;hrt. Es gibt jedoch noch mindestens eine Alternative, insbesondere den Aufruf mit der Execute-Methode der Database-Klasse. Diese f&uuml;hrt zwar auch nur die &uuml;bergebene Aktionsabfrage aus, aber sie bietet dennoch einige Vorteile gegen&uuml;ber DoCmd.RunSQL. Welche das sind und wie wir &uuml;berhaupt die DoCmd.RunSQL-Methode durch die Execute-Methode ersetzen k&ouml;nnen, zeigen wir in diesem Beitrag.<\/b><\/p>\n<h2>RunSQL und Execute einsetzen<\/h2>\n<p>Grunds&auml;tzlich sind die beiden Methoden &auml;hnlich und dienen dem Aufruf von Aktionsabfragen zum L&ouml;schen, Anlegen oder Bearbeiten von Datens&auml;tzen einer Tabelle. Als Beispiel verwenden wir eine Tabelle namens <b>tblKategorien <\/b>mit den beiden Feldern <b>KategorieID <\/b>(Prim&auml;rschl&uuml;sselfeld) und <b>Kategorie <\/b>(Textfeld mit eindeutigem Index).<\/p>\n<p>Wenn wir einen Eintrag zu einer Tabelle hinzuf&uuml;gen wollen, erledigen wir das mit <b>RunSQL <\/b>wie folgt (in einer Zeile im Direktbereich eingeben):<\/p>\n<pre>DoCmd.RunSQL \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 1'')\"<\/pre>\n<p>Bei der <b>Execute<\/b>-Methode k&ouml;nnen wir direkt mit <b>CurrentDb <\/b>arbeiten und &uuml;bergeben die gleiche Abfrage:<\/p>\n<pre>CurrentDb.Execute \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 1'')\"<\/pre>\n<p>Es bietet sich jedoch an, direkt eine Variable f&uuml;r das <b>Database<\/b>-Objekt zu deklarieren. Das ist auch Voraussetzung f&uuml;r das Nutzen der weiteren Vorteile der <b>Execute<\/b>-Methode:<\/p>\n<pre><span style=\"color:blue;\">Public Sub <\/span>Beispiel_Execute()\r\n     <span style=\"color:blue;\">Dim <\/span>db<span style=\"color:blue;\"> As <\/span>DAO.Database\r\n     <span style=\"color:blue;\">Set<\/span> db = CurrentDb\r\n     db.Execute \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 2'')\"\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<h2>Warum wird RunSQL &uuml;berhaupt verwendet?<\/h2>\n<p>Einer der Gr&uuml;nde, warum sich die <b>RunSQL<\/b>-Methode der <b>DoCmd<\/b>-Klasse so gro&szlig;er Beliebtheit erfreut, ist vermutlich in der technischen N&auml;he der <b>DoCmd<\/b>-Methoden zu den Aktionen in den Access-Makros zu finden.<\/p>\n<p>Access-Makros waren einer der Gr&uuml;nde, warum auch Nicht-Programmierer mit Access schnell Ergebnisse erzielen k&ouml;nnen: Man braucht nicht VBA zu beherrschen, sondern kann schnell im Makro-Editor ein paar Befehle zusammenstellen, die beispielsweise durch den Klick auf eine Schaltfl&auml;che ausgef&uuml;hrt werden.<\/p>\n<p>Die Befehle des Makro-Editors finden wir zum gr&ouml;&szlig;ten Teil in den Methoden der <b>DoCmd<\/b>-Klasse.<\/p>\n<p>Wer also in seiner Anfangszeit in Makros die Methode <b>Ausf&uuml;hrenSQL <\/b>genutzt hat, und dann zur Nutzung von VBA &uuml;bergegangen ist, wird logischerweise zu der entsprechenden <b>DoCmd<\/b>-Methode <b>RunSQL <\/b>gegriffen haben, um das gleiche Ergebnis zu erzielen.<\/p>\n<p>Die Makro-Aktion <b>Ausf&uuml;hrenSQL<\/b> ist &uuml;brigens mindestens seit Access 2010 nicht mehr verf&uuml;gbar &#8211; wir mussten ein altes Access 97-Buch heranziehen, um sicherzugehen, dass es diese Makro-Aktion einmal gab.<\/p>\n<p>Und da die <b>RunSQL<\/b>-Methode nach wie vor funktioniert, gab es f&uuml;r viele Entwickler keinen Grund, sich nach einer Alternative umzusehen.<\/p>\n<p>Diese stellen wir in diesem Beitrag mit der <b>Execute<\/b>-Methode der <b>Database<\/b>-Klasse vor und zeigen auch, warum dies die bessere Variante ist. Daf&uuml;r sprechen die folgenden Gr&uuml;nde:<\/p>\n<ul>\n<li>Wir k&ouml;nnen Fehler bei Verwendung von <b>Execute <\/b>&uuml;ber eine benutzerdefinierte Fehlerbehandlung abfangen. Bei <b>DoCmd.RunSQL <\/b>gelingt dies nicht.<\/li>\n<li>Wir k&ouml;nnen nach dem Ausf&uuml;hren der <b>Execute<\/b>-Methode direkt ermitteln, wie viele Datens&auml;tze von der Aktionsabfrage betroffen sind.<\/li>\n<li>Und wir k&ouml;nnen beim Hinzuf&uuml;gen eines Datensatzes mit <b>INSERT INTO <\/b>direkt die ID des Autowertfeldes des hinzugef&uuml;gten Datensatzes ermitteln.<\/li>\n<li>Wenn wir mehrere Aktionsabfragen in einer Transaktion ausf&uuml;hren wollen, ist dies nur mit der <b>Execute<\/b>-Methode m&ouml;glich.<\/li>\n<\/ul>\n<h2>Fehlerbehandlung beim RunSQL vs. Execute<\/h2>\n<p>Wenn wir eine SQL-Anweisung mit <b>RunSQL<\/b> ausf&uuml;hren, k&ouml;nnen wir bestimmte Fehler nicht mit einer benutzerdefinierten Fehlerbehandlung erkennen.<\/p>\n<p>Grunds&auml;tzlich werden bei Verwendung von <b>RunSQL <\/b>ohne weitere Ma&szlig;nahmen alle Fehler &uuml;ber die Benutzeroberfl&auml;che gemeldet, zum Beispiel, wenn wir einen Datensatz anf&uuml;gen wollen und damit einen bereits vorhandenen Wert in einem eindeutigen Feld hinzuf&uuml;gen w&uuml;rden:<\/p>\n<pre><span style=\"color:blue;\">Public Sub <\/span>Beispiel_RunSQL_Fehler()\r\n     DoCmd.RunSQL \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 1'')\"\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<p>Dieser Fehler w&uuml;rde uns nur &uuml;ber die Benutzeroberfl&auml;che gemeldet werden (siehe Bild 1).<\/p>\n<p class=\"image\"><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2026_01\/pic_1589_001.png\" alt=\"Datenfehler beim DoCmd.RunSQL\" width=\"374,5589\" height=\"406,7232\"\/><\/p>\n<p><b><span style=\"color:darkgrey;\">Bild 1: Datenfehler beim DoCmd.RunSQL<\/span><\/b><\/p>\n<p>Wir k&ouml;nnen diesen Fehler nicht &uuml;ber eine Fehlerbehandlung etwa mit <b>On Error Resume Next <\/b>abfangen und auch die Fehlernummer anschlie&szlig;end nicht mit <b>Debug.Print Err.Number <\/b>auswerten.<\/p>\n<p>Wir k&ouml;nnen lediglich die Anzeige der Fehlermeldung unterbinden, indem wir zuvor die Anweisung <b>DoCmd.SetWarnings False <\/b>einstellen und diese anschlie&szlig;end mit <b>DoCmd.SetWarnings True <\/b>wieder aktivieren. In diesem Fall w&uuml;rden wir den Fehler jedoch gar nicht bemerken.<\/p>\n<p>Andere Fehler, wie Tippfehler in Tabellen- oder Feldnamen, k&ouml;nnen wir hingegen mit einer benutzerdefinierten Fehlerbehandlung abfangen:<\/p>\n<pre>On Error Resume <span style=\"color:blue;\">Next<\/span>\r\nDoCmd.RunSQL \"INSERT INTO tblKategorien(Kategoriename) VALUES(''Kategorie 1'')\"\r\n<span style=\"color:blue;\">Debug.Print<\/span> Err.Number, Err.Description<\/pre>\n<p>Bei Verwendung der <b>Execute<\/b>-Methode k&ouml;nnen wir alle Fehler mit einer benutzerdefinierten Fehlerbehandlung abfangen. Hier sind allerdings nicht alle Fehler standardm&auml;&szlig;ig &uuml;berhaupt erkennbar:<\/p>\n<ul>\n<li>Fehler etwa durch Tippfehler in Tabellen- oder Feldnamen l&ouml;sen immer einen Fehler aus, den man behandeln kann.<\/li>\n<li>Fehler durch Verletzung von Restriktionen wie beim Anlegen eines bereits vorhandenen Wertes in einem Feld mit eindeutigem Index werden standardm&auml;&szlig;ig nicht abgefangen!<\/li>\n<\/ul>\n<p>Dies l&ouml;st einen Fehler aus, wenn das Feld <b>Kategoriename<\/b> nicht existiert:<\/p>\n<pre>db.Execute \"INSERT INTO tblKategorien(Kategoriename)  VALUES(''Kategorie 2'')\"<\/pre>\n<p>Diese Anweisung hingegen l&ouml;st keinen Fehler aus, auch wenn <b>Kategorie 1 <\/b>bereits in einem anderen Datensatz vorhanden ist:<\/p>\n<pre>db.Execute \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 1'')\"<\/pre>\n<p>Das kann zu Problemen f&uuml;hren, weil das erwartete Anlegen des Datensatzes ohne die Anzeige einer Meldung fehlschl&auml;gt.<\/p>\n<p>Aber hier bietet die <b>Execute<\/b>-Methode einen zweiten Parameter, den wir auf den Wert <b>dbFailOnError <\/b>einstellen:<\/p>\n<pre>db.Execute \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 1'')\", dbFailOnError<\/pre>\n<p>Damit werden nun alle Fehler gemeldet. Und wir k&ouml;nnen diesen Fehler auch behandeln &#8211; hier mit einer rudiment&auml;ren Ausgabe im Direktbereich:<\/p>\n<pre>On Error Resume <span style=\"color:blue;\">Next<\/span>\r\ndb.Execute \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 1'')\", dbFailOnError\r\n<span style=\"color:blue;\">Debug.Print<\/span> Err.Number, Err.Description<\/pre>\n<p>Fazit: Verwenden Sie statt <b>DoCmd.RunSQL <\/b>immer <b>db.Execute <\/b>mit dem Parameter <b>dbFailOnError<\/b>.<\/p>\n<h2>Auslesen des Autowerts neuer Datens&auml;tze nach INSERT INTO<\/h2>\n<p>Wenn wir mit <b>DoCmd.RunSQL <\/b>einen neuen Datensatz angelegt haben, ben&ouml;tigen wir eventuell die ID des neuen Datensatzes, um weitere Aktionen auszuf&uuml;hren. Diese k&ouml;nnen wir aber nur auf Umwegen und nicht zuverl&auml;ssig ermitteln, zum Beispiel indem wir anschlie&szlig;end die gr&ouml;&szlig;te ID mit DMax f&uuml;r diese Tabelle auslesen.<\/p>\n<p>Das ist unzuverl&auml;ssig, weil es sein kann, dass in der Zwischenzeit durch einen anderen Benutzer ebenfalls ein neuer Datensatz angelegt worden sein kann. Wir w&uuml;rden dann eventuell eine falsche ID erhalten, f&uuml;r die wir etwa weitere verkn&uuml;pfte Datens&auml;tze in weiteren Tabellen anlegen &#8211; dies nachtr&auml;glich zu reproduzieren, kostet unn&ouml;tig Zeit.<\/p>\n<p>Wenn wir die <b>Execute<\/b>-Methode einer <b>Database<\/b>-Variablen namens <b>db <\/b>verwenden, k&ouml;nnen wir gleich im Anschluss die folgende Abfrage nutzen, um den zuletzt hinzugef&uuml;gten Autowert zu ermitteln:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>db<span style=\"color:blue;\"> As <\/span>DAO.Database\r\n<span style=\"color:blue;\">Dim <\/span>lngNeueID<span style=\"color:blue;\"> As Long<\/span>\r\n<span style=\"color:blue;\">Set<\/span> db = CurrentDb\r\ndb.Execute \"INSERT INTO tblKategorien(Kategorie)  VALUES(''Kategorie 3'')\", dbFailOnError\r\nlngNeueID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n<span style=\"color:blue;\">Debug.Print<\/span> \"Neue ID: \" & lngNeueID<\/pre>\n<p>Der Vorteil hier ist: Wenn wir beide Aktionen im Kontext der gleichen <b>Database<\/b>-Variablen <b>db <\/b>ausf&uuml;hren, werden nur solche neuen IDs ber&uuml;cksichtigt, die in der gleichen Session von Access angelegt wurden. Da in der Regel immer nur eine VBA-Prozedur gleichzeitig ausgef&uuml;hrt wird, ermitteln wir hier sicher den richtigen Wert f&uuml;r die neue ID.<\/p>\n<h2>Auslesen der Anzahl betroffener Datens&auml;tze<\/h2>\n<p>Manchmal ben&ouml;tigt man nach Aktionsabfragen, die mehrere Datens&auml;tze betreffen, die Anzahl der betroffenen Datens&auml;tze. Das l&auml;sst sich bei <b>INSERT INTO<\/b>&#8211; oder <b>DELETE<\/b>-Anweisungen mit <b>RunSQL <\/b>noch bewerkstelligen, indem man die Differenz der Anzahl der Datens&auml;tze vor und nach dem Aufruf ermittelt. Aber auch dies ist unzuverl&auml;ssig, weil ein anderer Benutzer parallel auch Datens&auml;tze in der gleichen Tabelle l&ouml;schen k&ouml;nnte.<\/p>\n<p>Bei <b>UPDATE<\/b>-Anweisungen ist das jedoch kaum m&ouml;glich, da wir hier pr&uuml;fen m&uuml;ssten, welche Datens&auml;tze ge&auml;ndert wurden &#8211; das ist nicht mit vertretbarem Aufwand realisierbar.<\/p>\n<p>Bei Verwendung von <b>Execute <\/b>im Kontext einer <b>Database<\/b>-Variablen steht uns jedoch eine zuverl&auml;ssige Methode zur Verf&uuml;gung, bei <b>INSERT INTO<\/b>-, <b>UPDATE<\/b>&#8211; und <b>DELETE<\/b>-Abfragen die genaue Anzahl der betroffenen Datens&auml;tze zu ermitteln.<\/p>\n<p>Hier l&ouml;schen wir alle Datens&auml;tze, deren Wert im Feld <b>Kategorie <\/b>mit der Zeichenkette <b>Kategorie <\/b>beginnt:<\/p>\n<pre><span style=\"color:blue;\">Dim <\/span>db<span style=\"color:blue;\"> As <\/span>DAO.Database\r\n<span style=\"color:blue;\">Dim <\/span>lngGeloescht<span style=\"color:blue;\"> As Long<\/span>\r\n<span style=\"color:blue;\">Set<\/span> db = CurrentDb\r\ndb.Execute \"DELETE * FROM tblKategorien  WHERE Kategorie LIKE ''Kategorie*''\", dbFailOnError\r\nlngGeloescht = db.RecordsAffected\r\n<span style=\"color:blue;\">Debug.Print<\/span> \"Gel&ouml;schte Datens&auml;tze: \" & lngGeloescht<\/pre>\n<p>Direkt nach dem L&ouml;schen k&ouml;nnen wir die Eigenschaft <b>RecordsAffected <\/b>nutzen, um die Anzahl der von der zuletzt in dieser Session ausgef&uuml;hrten Aktionsabfrage zu ermitteln. Diese geben wir anschlie&szlig;end im Direktbereich des VBA-Editors aus.<\/p>\n<p>Dies gelingt auch bei <b>INSERT INTO<\/b>-Abfragen und bei <b>UPDATE<\/b>-Abfragen.<\/p>\n<h2>Transaktionen nur mit Execute<\/h2>\n<p>Wenn mehrere Aktionsabfragen nur ausgef&uuml;hrt werden sollen, wenn alle erfolgreich sind oder ein bestimmtes Ergebnis liefern, m&uuml;ssen wir diese in einer Transaktion einbetten.<\/p>\n<p>Ohne auf die Details einzugehen, hier der Hinweis, dass dies nur mit der <b>Execute<\/b>-Methode m&ouml;glich ist, da die <b>DoCmd.RunSQL<\/b>-Methode gar nicht im Kontext einer Transaktion ausgef&uuml;hrt werden kann.<\/p>\n<h2>Zusammenfassung und Ausblick<\/h2>\n<p>Dieser Beitrag zeigt die Unterschiede zwischen den beiden Methoden <b>DoCmd.RunSQL <\/b>und <b>db.Execute <\/b>zum Ausf&uuml;hren von Aktionsabfragen.<\/p>\n<p>Die Empfehlungen dieses Beitrags noch einmal zusammengefasst:<\/p>\n<ul>\n<li>Verwenden Sie <b>Execute <\/b>mit dem Wert <b>dbFailOnError <\/b>als zweiten Parameter, um alle Fehler beim Ausf&uuml;hren der Abfrage in einer benutzerdefinierten Fehlerbehandlung verarbeiten zu k&ouml;nnen.<\/li>\n<li>Nutzen Sie die Abfrage <b>SELECT @@IDENTITY<\/b>, um den Wert des zuletzt hinzugef&uuml;gten Autowerts zu ermitteln.<\/li>\n<li>Verwenden Sie die <b>RecordsAffected<\/b>-Eigenschaft des <b>Database<\/b>-Objekts, um die Anzahl der von der zuletzt ausgef&uuml;hrten Aktionsabfrage betroffenen Datens&auml;tze zu ermitteln.<\/li>\n<li>Wenn Transaktionen ben&ouml;tigt werden, gelingt dies nur mit der <b>Execute<\/b>-Methode.<\/li>\n<h2>Downloads zu diesem Beitrag<\/h2>\n<p>Enthaltene Beispieldateien:<\/p>\n<p>DoCmdRunSQLVsDatabaseExecute.accdb<\/p>\n<p><a href=\"..\/fileadmin\/beispiele\/D4F60B80-F205-4F53-A963-8A3E21CD9DCF\/aiu_1589.zip\">Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>In unseren Audits mit unseren Kunden und Lesern untersuchen wir auch regelm&auml;&szlig;ig den VBA-Code in deren Access-Anwendungen. Dabei fallen uns immer wieder Programmiergewohnheiten auf, die irgendwann einmal eingef&uuml;hrt und seitdem nie wieder ge&auml;ndert wurden. Eine davon ist, SQL-Anweisungen wie INSERT INTO, UPDATE oder DELETE mit der Methode RunSQL der DoCmd-Klasse auszuf&uuml;hren. Das ist grunds&auml;tzlich nicht falsch, solange dies zum Ziel f&uuml;hrt. Es gibt jedoch noch mindestens eine Alternative, insbesondere den Aufruf mit der Execute-Methode der Database-Klasse. Diese f&uuml;hrt zwar auch nur die &uuml;bergebene Aktionsabfrage aus, aber sie bietet dennoch einige Vorteile gegen&uuml;ber DoCmd.RunSQL. Welche das sind und wie wir &uuml;berhaupt die DoCmd.RunSQL-Methode durch die Execute-Methode ersetzen k&ouml;nnen, zeigen wir in diesem Beitrag.<\/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":[66012026,662026,44000035],"tags":[],"class_list":["post-55001589","post","type-post","status-publish","format-standard","hentry","category-66012026","category-662026","category-Datenzugriff_programmieren"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v20.9 (Yoast SEO v27.4) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL\" \/>\n<meta property=\"og:description\" content=\"In unseren Audits mit unseren Kunden und Lesern untersuchen wir auch regelm&auml;&szlig;ig den VBA-Code in deren Access-Anwendungen. Dabei fallen uns immer wieder Programmiergewohnheiten auf, die irgendwann einmal eingef&uuml;hrt und seitdem nie wieder ge&auml;ndert wurden. Eine davon ist, SQL-Anweisungen wie INSERT INTO, UPDATE oder DELETE mit der Methode RunSQL der DoCmd-Klasse auszuf&uuml;hren. Das ist grunds&auml;tzlich nicht falsch, solange dies zum Ziel f&uuml;hrt. Es gibt jedoch noch mindestens eine Alternative, insbesondere den Aufruf mit der Execute-Methode der Database-Klasse. Diese f&uuml;hrt zwar auch nur die &uuml;bergebene Aktionsabfrage aus, aber sie bietet dennoch einige Vorteile gegen&uuml;ber DoCmd.RunSQL. Welche das sind und wie wir &uuml;berhaupt die DoCmd.RunSQL-Methode durch die Execute-Methode ersetzen k&ouml;nnen, zeigen wir in diesem Beitrag.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2026-01-09T11:54:25+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"9\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL\",\"datePublished\":\"2026-01-09T11:54:25+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/\"},\"wordCount\":1583,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/2807ac8eea064607ace4a9becc81fe34\",\"articleSection\":[\"1\\\/2026\",\"2026\",\"Datenzugriff programmieren\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/\",\"name\":\"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/2807ac8eea064607ace4a9becc81fe34\",\"datePublished\":\"2026-01-09T11:54:25+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/2807ac8eea064607ace4a9becc81fe34\",\"contentUrl\":\"http:\\\/\\\/vg01.met.vgwort.de\\\/na\\\/2807ac8eea064607ace4a9becc81fe34\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/","og_locale":"de_DE","og_type":"article","og_title":"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL","og_description":"In unseren Audits mit unseren Kunden und Lesern untersuchen wir auch regelm&auml;&szlig;ig den VBA-Code in deren Access-Anwendungen. Dabei fallen uns immer wieder Programmiergewohnheiten auf, die irgendwann einmal eingef&uuml;hrt und seitdem nie wieder ge&auml;ndert wurden. Eine davon ist, SQL-Anweisungen wie INSERT INTO, UPDATE oder DELETE mit der Methode RunSQL der DoCmd-Klasse auszuf&uuml;hren. Das ist grunds&auml;tzlich nicht falsch, solange dies zum Ziel f&uuml;hrt. Es gibt jedoch noch mindestens eine Alternative, insbesondere den Aufruf mit der Execute-Methode der Database-Klasse. Diese f&uuml;hrt zwar auch nur die &uuml;bergebene Aktionsabfrage aus, aber sie bietet dennoch einige Vorteile gegen&uuml;ber DoCmd.RunSQL. Welche das sind und wie wir &uuml;berhaupt die DoCmd.RunSQL-Methode durch die Execute-Methode ersetzen k&ouml;nnen, zeigen wir in diesem Beitrag.","og_url":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/","og_site_name":"Access im Unternehmen","article_published_time":"2026-01-09T11:54:25+00:00","og_image":[{"url":"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"9\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL","datePublished":"2026-01-09T11:54:25+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/"},"wordCount":1583,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#primaryimage"},"thumbnailUrl":"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34","articleSection":["1\/2026","2026","Datenzugriff programmieren"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/","url":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/","name":"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#primaryimage"},"thumbnailUrl":"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34","datePublished":"2026-01-09T11:54:25+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#primaryimage","url":"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34","contentUrl":"http:\/\/vg01.met.vgwort.de\/na\/2807ac8eea064607ace4a9becc81fe34"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/SQL_ausfuehren_mit_Execute_statt_DoCmdRunSQL\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"SQL ausf&uuml;hren mit Execute statt DoCmd.RunSQL"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55001589","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55001589"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55001589\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55001589"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55001589"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55001589"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}