- \n
- DELETE<\/b>: Löschen von Datensätzen<\/li>\n
- UPDATE<\/b>: Aktualisieren von Datensätzen<\/li>\n
- INSERT INTO<\/b>: Einfügen von Datensätzen<\/li>\n<\/ul>\n
Wir können durch das Ausführen der Execute<\/b>-Methode auch solche SQL-Anweisungen ausführen, mit denen wir den Entwurf des Datenmodells selbst ändern – zum Anlegen, Ändern oder Löschen von Tabellen, Feldern, Indizes und vielem mehr.<\/p>\n
Erstellen einer Tabelle mit Execute<\/h2>\n
Im ersten Beispiel erstellen wir erst einmal eine Tabelle, mit der wir danach weitere Aktionen durchführen. Dieses Beispiel finden wir in Listing 1. Hier deklarieren wir zunächst ein Connection<\/b>-Objekt sowie eine Zeichenkette zum Speichern der SQL-Anweisung.<\/p>\n
Public Sub <\/span>TabelleErstellen()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.ConnectionString = \"Provider=MSOLEDBSQL;Data Source=amvDesktop2023;Initial Catalog=Anlagen;\" _\r\n & \"Integrated Security=SSPI;\"\r\n cnn.Open\r\n \r\n strSQL = \"CREATE TABLE tblKategorien (\" & vbCrLf<\/span>\r\n strSQL = strSQL & \" KategorieID INT IDENTITY(1,1) PRIMARY KEY,\" & vbCrLf<\/span>\r\n strSQL = strSQL & \" Kategoriebezeichnung VARCHAR(255) NOT NULL\" & vbCrLf<\/span>\r\n strSQL = strSQL & \");\"\r\n cnn.Execute strSQL\r\n cnn.Close\r\n Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nListing 1: Prozedur zum Erstellen einer Tabelle<\/span><\/b><\/p>\n
Danach erstellen wir das Connection<\/b>-Objekt und speichern es in der Variablen cnn<\/b>. Wir weisen die Verbindungszeichenfolge zu und öffnen die Verbindung mit der Open<\/b>-Anweisung.<\/p>\n
Danach stellen wir in der Variablen strSQL <\/b>die SQL-Anweisung zusammen, die wie folgt aussieht:<\/p>\n
CREATE TABLE tblKategorien (\r\n KategorieID INT IDENTITY(1,1) PRIMARY KEY,\r\n Kategoriebezeichnung VARCHAR(255) NOT NULL\r\n);<\/pre>\n
Diese brauchen wir nun nur noch mit der Execute<\/b>-Methode des Connection<\/b>-Objekts auszuführen. Damit haben wir bereits eine Tabelle zum Experimentieren angelegt.<\/p>\n
Woher wissen wir in diesem Fall, dass das Anlegen erfolgreich war? Ganz einfach dadurch, dass wir keinen Fehler ausgelöst haben.<\/p>\n
Wir können die Gegenprobe machen, indem wir die Prozedur einfach erneut aufrufen. Damit versuchen wir, eine Tabelle anzulegen, die bereits vorhanden ist. Dies löst einen Fehler aus, der in Access mit der Meldung aus Bild 1 angezeigt wird.<\/p>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2024_06\/pic_447_001.png\")
<\/p>\nBild 1: Fehler beim Versuch, eine Tabelle erneut anzulegen<\/span><\/b><\/p>\n
Datensatz anlegen mit Execute<\/h2>\n
Im zweiten Beispiel wollen wir dieser Tabelle einen Datensatz hinzufügen (siehe Listing 2). Dieser soll im Feld Kategoriebezeichnung <\/b>den Wert Beispielkategorie <\/b>erhalten. Das Feld KategorieID <\/b>wird automatisch gefüllt, da wir dieses mit dem Schlüsselwort IDENTITY(1,1) <\/b>als Autowertfeld definiert haben.<\/p>\n
Public Sub <\/span>DatensatzHinzufuegen()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.ConnectionString = \"Provider=MSOLEDBSQL;Data Source=amvDesktop2023;Initial Catalog=Anlagen;\" _\r\n & \"Integrated Security=SSPI;\"\r\n cnn.Open\r\n \r\n strSQL = \"INSERT INTO tblKategorien(Kategoriebezeichnung) VALUES(''Beispielkategorie'')\"\r\n cnn.Execute strSQL\r\n cnn.Close\r\n Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nListing 2: Prozedur zum Hinzufügen eines Datensatzes<\/span><\/b><\/p>\n
Auch diese Anweisung führen wir mit der Execute<\/b>-Methode aus. Das Ergebnis ist ein neuer Datensatz in der Tabelle tblKategorien<\/b>.<\/p>\n
Anzahl angelegter Datensätze ermitteln<\/h2>\n
Wie können wir hier ermitteln, ob das Anlegen erfolgreich war? Dazu ermitteln wir die Anzahl der von der Abfrage betroffenen Datensätze (siehe Listing 3).<\/p>\n
Public Sub <\/span>DatensatzHinzufuegenMitErgebnis()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>lngRecordsAffected As Long<\/span>\r\n \r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.ConnectionString = \"Provider=MSOLEDBSQL;Data Source=amvDesktop2023;Initial Catalog=Anlagen;\" _\r\n & \"Integrated Security=SSPI;\"\r\n cnn.Open\r\n \r\n strSQL = \"INSERT INTO tblKategorien(Kategoriebezeichnung) VALUES(''Beispielkategorie'')\"\r\n cnn.Execute strSQL, lngRecordsAffected\r\n MsgBox<\/span> \"Anzahl angelegter Datensätze: \" & lngRecordsAffected\r\n cnn.Close\r\n Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nListing 3: Prozedur zum Hinzufügen eines Datensatzes mit Ergebnis<\/span><\/b><\/p>\n
Diese Information können wir aus dem zweiten Parameter der Execute<\/b>-Anweisung entnehmen. Dieser müssen wir dazu eine zuvor deklarierte Variable übergeben. Sie wird dann beim Ausführen der Abfrage mit der Anzahl der betroffenen Datensätze gefüllt.<\/p>\n
Das Ergebnis der Abfrage geben wir dann in einer Meldung aus.<\/p>\n
Aber kann es beim Anlegen von Datensätzen überhaupt ein anderes Ergebnis als 1 <\/b>geben? Nein, das ist nicht der Fall. Es kann lediglich passieren, dass die Abfrage einen Fehler auslöst.<\/p>\n
Wir können hier sogar zwei Datensätze in aufeinanderfolgenden INSERT INTO<\/b>-Anweisungen einfügen. Dazu ersetzen wir die entsprechende Anweisung wie folgt:<\/p>\n
strSQL = \"INSERT INTO tblKategorien(Kategoriebezeichnung) VALUES(''Beispielkategorie'');INSERT INTO tblKategorien(Kategoriebezeichnung) VALUES(''Beispielkategorie1'')\"<\/pre>\nDies liefert jedoch immer noch den Wert 1 <\/b>zurück. Der Grund ist, dass hier immer nur das Ergebnis der zuletzt verwendeten Anweisung genutzt wird.<\/p>\n
In T-SQL gibt es jedoch im Gegensatz zu Access-SQL die Möglichkeit, hinter dem VALUES<\/b>-Schlüsselwort mehrere Klammernpaare mit den hinzuzufügenden Feldwerten anzugeben.<\/p>\n
In unserem einfachen Fall mit dem einen Feld sieht das wie folgt aus:<\/p>\n
strSQL = \"INSERT INTO tblKategorien(Kategoriebezeichnung) VALUES(''Beispielkategorie1''), (''Beispielkategorie2'');\"<\/pre>\nDer Aufruf dieser Anweisung liefert tatsächlich den Wert 2<\/b> für die Anzahl der betroffenen Datensätze zurück.<\/p>\n
Datensätze per INSERT INTO…SELECT einfügen<\/h2>\n
Unkomplizierter ist es, wenn wir die einzufügenden Daten aus einer SELECT<\/b>-Abfrage beziehen. In diesem Beispiel fügen wir einfach alle bereits vorhandenen Datensätze nochmals zur Tabelle hinzu:<\/p>\n
strSQL = \"INSERT INTO tblKategorien(Kategoriebezeichnung) SELECT Kategoriebezeichnung FROM tblKategorien;\"<\/pre>\n
In diesem Fall erhalten wir direkt die korrekte Anzahl der betroffenen Datensätze.<\/p>\n
Datensätze per UPDATE aktualisieren<\/h2>\n
Wenn wir einen oder mehrere Datensätze einer Tabelle aktualisieren wollen, nutzen wir die UPDATE<\/b>-Anweisung. Diese rufen wir beispielsweise wie folgt aus (den Rest der Prozedur übernehmen wir aus den vorherigen Beispielen):<\/p>\n
strSQL = \"UPDATE tblKategorien SET Kategoriebezeichnung = ''Kategorie'' WHERE KategorieID = 1;\"<\/pre>\n
Hier wird die Kategoriebezeichnung aller Datensätze angepasst, deren Feld KategorieID <\/b>den Wert 1 <\/b>aufweist. Dies betrifft in unserem Beispiel genau einen Datensatz.<\/p>\n
strSQL = \"UPDATE tblKategorien SET Kategoriebezeichnung = Kategoriebezeichnung + '' (geändert)'' WHERE Kategoriebezeichnung LIKE ''%Kategorie%'';\"<\/pre>\n
Hier wollen wir dem Wert des Feldes Kategoriebezeichnung <\/b>die Zeichenkette (geändert) <\/b>anhängen, wenn die Kategoriebezeichnung die Zeichenkette Kategorie <\/b>enthält.<\/p>\n
Auch hier wird die Anzahl der betroffenen Datensätze korrekt zurückgeliefert.<\/p>\n
Datensätze per DELETE löschen<\/h2>\n
Zum Löschen eines Datensatzes verwenden wir die folgende Anweisung für die Variable strSQL<\/b>:<\/p>\n
strSQL = \"DELETE FROM tblKategorien WHERE KategorieID = 11;\"<\/pre>\n
Führen wir diese mit der Execute<\/b>-Methode aus, erhalten wir wiederum die Menge der betroffenen Datensätze als Ergebnis.<\/p>\n
Hier kann es genauso wie bei der UPDATE<\/b>-Anweisung vorkommen, dass 0 Datensätze betroffen sind, wenn die WHERE<\/b>-Bedingung keine zu ändernden Datensätze liefert.<\/p>\n
Der dritte Parameter “Options”<\/h2>\n
In den bisherigen Beispielen haben wir den dritten Parameternamens Options <\/b>bisher vernachlässigt. Dieser kann die folgenden Werte annehmen:<\/p>\n
- \n
- adCmdUnknown <\/b>(8<\/b>): Standardwert. Die Art der auszuführenden Anweisung wird automatisch erkannt.<\/li>\n
- adCmdText <\/b>(1<\/b>): Behandlung des ersten Parameters als Text. Funktioniert für SELECT<\/b>, INSERT<\/b>, UPDATE <\/b>und DELETE<\/b>-Anweisungen.<\/li>\n
- adCmdTable <\/b>(2<\/b>): Kann verwendet werden, wenn als erster Parameter der Name einer Tabelle angegeben wird. Nur für SELECT<\/b>-Abfragen.<\/li>\n
- acCmdStoredProc <\/b>(4<\/b>): Kann für gespeicherte Prozeduren verwendet werden. Diese kann dann ohne das Schlüsselwort EXEC <\/b>als erster Parameter angegeben werden.<\/li>\n
- adAsyncExecute <\/b>(16<\/b>): Die Anweisung wird asynchron ausgeführt, also im Hintergrund, und die aufrufende Prozedur wird weiter ausgeführt, während die Abfrage ausgeführt wird.<\/li>\n<\/ul>\n
Wir können verschiedene Werte für den dritten Parameter kombinieren, indem wir diese addieren.<\/p>\n
Sinnvoll ist das jedoch nur, wenn man einen der Werte adCmdUnknown<\/b>, adCmdText<\/b>, adCmdTable <\/b>oder adCmdStoredProc <\/b>mit adAsyncExecute <\/b>kombiniert.<\/p>\n
SELECT-Anweisungen per Execute<\/h2>\n
Wir können der Execute<\/b>-Methode sogar SELECT<\/b>-Anweisungen übergeben. Aber was wollen wir damit machen – wie wollen wir das Ergebnis erhalten oder weiterverarbeiten?<\/p>\n
Die Antwort ist einfach: Wir weisen das Ergebnis eines solchen Execute<\/b>-Aufrufs einfach einem ADODB-Recordset zu.<\/p>\n
Als Erstes deklarieren wir dazu ein ADODB.Recordset<\/b>-Objekt namens rst<\/b>. Als Abfrage definieren wir eine SELECT<\/b>-Abfrage.<\/p>\n
Das Ergebnis der Execute<\/b>-Methode weisen wir dem Recordset zu und zeigen anschließend, dass es gefüllt wurde, indem wir dieses durchlaufen (siehe Listing 4).<\/p>\n
Public Sub <\/span>ExecuteRecordset()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.ConnectionString = \"Provider=MSOLEDBSQL;Data Source=amvDesktop2023;Initial Catalog=Anlagen;\" _\r\n & \"Integrated Security=SSPI;\"\r\n cnn.Open\r\n \r\n strSQL = \"SELECT * FROM tblKategorien;\"\r\n \r\n Set<\/span> rst = cnn.Execute(strSQL)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst!KategorieID, rst!Kategoriebezeichnung\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n cnn.Close\r\n Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nListing 4: Prozedur zum Erstellen eines Recordsets<\/span><\/b><\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Mit der Execute<\/b>-Methode der Connection-Klasse können wir schnell SQL-Anweisungen ausführen. Es gibt noch eine Execute<\/b>-Methode für die Command-Klasse, mit der wir ähnliches erledigen können. Diese bietet jedoch noch mehr Möglichkeiten, die wir uns im Artikel ansehen.<\/p>\n","protected":false},"excerpt":{"rendered":"
ADODB bietet verschiedene Techniken, um SQL-Befehle zum Abfragen oder Ändern von Daten auszuführen. Die bekannteste zum Abfragen von Daten dürfte die OpenRecordset-Methode sein. Für das Ausführen von Anweisungen kann man für vollen Komfort am besten die Command-Klasse mit der Execute-Methode verwenden. Aber auch die Connection-Klasse bietet bereite eine Execute-Methode an. Mit dieser lässt sich schnell und flexibel Einiges erledigen. Welche Möglichkeiten sie bietet und wie wir diese für den Datenzugriff nutzen können, zeigen wir in diesem Artikel.<\/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":[662024,66062024,44000008],"tags":[],"yst_prominent_words":[],"class_list":["post-55000447","post","type-post","status-publish","format-standard","hentry","category-662024","category-66062024","category-Datenzugriffstechnik"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000447","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000447"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000447\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000447"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000447"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000447"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000447"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- adCmdText <\/b>(1<\/b>): Behandlung des ersten Parameters als Text. Funktioniert für SELECT<\/b>, INSERT<\/b>, UPDATE <\/b>und DELETE<\/b>-Anweisungen.<\/li>\n
- UPDATE<\/b>: Aktualisieren von Datensätzen<\/li>\n