Wer auf die Inhalte von Datenbanken wie Access, SQL Server und anderen zugreifen möchte, benötigt eine spezielle Datenzugriffstechnologie. Unter VB6, VBA und twinBASIC verwendet man dazu in der Regel die DAO-Bibliothek, in Office “Microsoft Office 16.0 Access database engine Object Library” genannt, oder die ADODB-Bibliothek (“Microsoft ActiveX Data Objects 6.1 Library”). Geschichtlich wurde mal die eine, mal die andere von Microsoft als die zu bevorzugende Datenzugriffstechnik bezeichnet. Derzeit verwendet man meist DAO, vor allem in Verbindung mit Access-Datenbanken, aber beim Zugriff auf SQL Server-Datenbanken bietet ADODB einige Features, die wir mit DAO nicht nutzen können. In diesem Artikel steigen wir in die Programmierung von Datenbankzugriffen mit ADODB ein. Dabei schauen wir uns als Erstes die Connection-Klasse an, mit der erst einmal eine Verbindung zur Datenbank aufgebaut werden kann.<\/b><\/p>\n
ADODB wurde mit der Version Access 2000 erstmalig eingeführt. Zuvor war DAO die meistverwendete Datenzugriffstechnik (Bibliothek Microsoft DAO 3.6 Object Library<\/b>) in Zusammenhang mit dem Zugriff über die JET-Datenbank-Engine. Im Laufe der Jahre hat Microsoft jedoch entschieden, dass DAO wieder die wichtigste Technik für den Zugriff auf Datenbanken sein soll. Damit einher ging mit Access 2007 die Einführung einer neuen Variante der JET<\/b>-Engine namens ACE <\/b>(Access Database Engine) und damit eine neue Bibliothek mit dem Titel Microsoft Office 16.0 Access database engine Object Library<\/b>.<\/p>\n
Wie bereits erwähnt, gibt es jedoch einige Einsatzzwecke, bei denen ADODB Vorteile gegenüber DAO hat, weil es verschiedene Funktionen zur Verfügung stellt, die es in DAO nicht gibt. Dazu gehören die folgenden:<\/p>\n
Wir können die Elemente der ADODB-Bibliothek auf verschiedene Arten nutzen – durch vorheriges Einbinden der Bibliothek (Early Binding) oder durch Deklarieren der Objektvariablen mit dem Datentyp Object und Einbinden zur Laufzeit (Late Binding).<\/p>\n
Wir wollen wegen der damit verbundenen Vorteile zum Beispiel durch den Einsatz von IntelliSense hier mit Early Binding arbeiten.<\/p>\n
Dazu benötigen wir einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects 6.1 Library<\/b>.<\/p>\n
Diesen fügen wir wie in Bild 1 über den Verweise<\/b>-Dialog hinzu.<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2024_06\/pic_446_001.png\")
<\/p>\n
Bild 1: Verweis auf die ADODB-Bibliothek<\/span><\/b><\/p>\n Die Connection<\/b>-Klasse liefert die folgenden Eigenschaften, von denen wir uns die wichtigsten in den folgenden Abschnitten ansehen:<\/p>\n Außerdem bietet die Connection<\/b>-Klasse die folgenden Methoden:<\/p>\n Innerhalb von Access-Datenbanken liefert die ADODB-Bibliothek über die Eigenschaft Connection <\/b>der Klasse CurrentProject <\/b>ein Connection<\/b>-Objekt für den Zugriff auf die aktuelle Datenbank.<\/p>\n Um diese zu nutzen, können wir direkt auf ihre Eigenschaften zugreifen – beispielsweise, indem wir die Verbindungszeichenfolge im Direktbereich ausgeben:<\/p>\n Hier finden wir eine ganze Reihe Eigenschaften, die jedoch nicht alle immer benötigt werden.<\/p>\n Wir können die Verbindung auch direkt in Form einer Connection<\/b>-Variablen speichern und darüber auf die enthaltenen Eigenschaften zugreifen:<\/p>\n Zu diesem Zeitpunkt haben wir übrigens noch keine Verbindung zur Datenbank hergestellt. Das Connection<\/b>-Objekt kennt erst einmal nur die Verbindungszeichenfolge. Wie wir die Verbindung herstellen, schauen wir uns weiter unten an.<\/p>\n Dies war der stark vereinfachte Fall für den Zugriff auf die aktuelle Access-Datenbank. ADODB nutzt man jedoch in der Regel eher dazu, auf Datenquellen außerhalb der aktuellen Anwendung zuzugreifen. Wir schauen uns verschiedene Beispiele an, die oft verwendet werden.<\/p>\n Die Seite https:\/\/www.connectionstrings.com\/<\/b> stellt immer aktuelle Informationen rund um die Verbindungszeichenfolgen für den Zugriff von System A auf Datenbank B bereitstellt.<\/p>\n Solltest Du einmal eine andere Datenquelle benötigen als die hier vorgestellten, findest Du dort alle denkbaren Konstellationen.<\/p>\n Hier siehst Du auch, dass Verbindungszeichenfolgen nicht immer so umfangreich sein müssen wie die soeben für CurrentProject.Connection <\/b>ermittelte.<\/p>\n Wenn wir beispielsweise auf eine SQL Server-Datenbank zugreifen wollen, können wir grob Verbindungszeichenfolgen für die beiden Authentifizierungsarten Windows-Authentifizierung und SQL ServerAuthentifizierung zusammenstellen.<\/p>\n Die Verbindungszeichenfolge für die Windows-Authentifizierung sieht beispielsweise wie folgt aus – wobei wir als Servername amvDesktop2023 <\/b>und als Datenbankname Mitarbeiterverwaltung <\/b>verwendet haben:<\/p>\n Die Verbindungszeichenfolge für die SQL Server-Authentifizierung sieht so aus. Hier verwenden wir statt dem Parameter Trusted_Connection=yes <\/b>die beiden Parameter UID <\/b>und PWD <\/b>mit den jeweiligen Werten:<\/p>\n Wir können die beiden zuvor beschriebenen Verbindungszeichenfolgen auch ohne die Angabe einer Datenbank verwenden. Hier wird dann standardmäßig die master<\/b>-Datenbank als Datenbank genutzt. Wir wir herausfinden können, welche Datenbank verwendet wird, zeigen wir weiter unten mit der Eigenschaft DefaultDatabase<\/b>.<\/p>\n Und wenn wir die Verbindungszeichenfolge für den Zugriff auf eine andere Access-Datenbank benötigen, stellen wir diese wie folgt zusammen – hier für eine Datenbank namens ADODB_Test.accdb<\/b>:<\/p>\n Egal, ob wir eine reine Access-Connection erstellen oder eine für den SQL Server: Die angegebenen, teilweise nur aus vier Parametern bestehenden Verbindungszeichenfolgen werden nach dem Zuweisen automatisch um weitere Parameter ergänzt, die mit Standardwerten gefüllt werden.<\/p>\n Ob die Datenbankverbindung für die angegebene Verbindungszeichenfolge funktioniert, erfahren wir nur durch das Öffnen der Verbindung. Dazu nutzen wir die Open<\/b>-Methode der Connection<\/b>-Klasse.<\/p>\n Wenn wir dies in unser erstes Beispiel einbauen, in dem wir auf das Connection<\/b>-Objekt der aktuellen Access-Datenbank zugreifen, sieht das wie folgt aus:<\/p>\n Wenn wir dies ausführen, erhalten wir allerdings die Fehlermeldung aus Bild 2. Warum ist das Objekt bereits geöffnet? Weil dieses direkt bei Start der Anwendung geöffnet und bereitgestellt wird. Wir können also direkt auf das Objekt zugreifen.<\/p>\n Bild 2: Fehler beim Versuch, eine geöffnete Verbindung erneut zu öffnen<\/span><\/b><\/p>\n Wie können wir dann auf möglichst einfache Weise herausfinden, ob eine solche Verbindung bereits geöffnet ist oder nicht?<\/p>\n Dazu können wir die Eigenschaft State <\/b>des Connection<\/b>-Objekts nutzen.<\/p>\n Diese liefert einen der Werte der Enumeration ObjectStateEnum<\/b>, die wie folgt lauten:<\/p>\n Wir haben für die Enumeration ObjectStateEnum <\/b>eine Funktion geschrieben, die uns für den Zahlenwert die jeweilige Konstante zurückgibt (siehe Listing 1).<\/p>\n Listing 1: Funktion zur lesbaren Ausgabe der Werte der Enumeration ObjectStateEnum<\/span><\/b><\/p>\n Diese erwartet den Zahlenwert der Eigenschaft State <\/b>und liefert den Namen der jeweiligen Konstanten zurück. Damit können wir uns den Namen der Konstanten wie folgt ausgeben lassen:<\/p>\n Bei Datenbankzugriffen ist es, wie auch bei allen anderen Objekten, die man im Laufe einer Session öffnet, wichtig, diese auch wieder zu schließen und den Speicherplatz freizugeben.<\/p>\n In den meisten Fällen machen sich Nachlässigkeiten hier zwar nicht bemerkbar, aber früher oder später treten dadurch vielleicht Probleme auf. Deshalb schließen wir eine von uns geöffnete Verbindung zunächst wie folgt:<\/p>\n Anschließend leeren wir die Objektvariable:<\/p>\n Die CursorLocation<\/b>-Eigenschaft im ADODB.Connection<\/b>-Objekt legt fest, ob der Cursor auf dem Client oder auf dem Server verarbeitet wird.<\/p>\n Standardmäßig wird adUseServer <\/b>(1<\/b>) verwendet, wodurch Abfragen direkt auf dem SQL-Server ausgeführt werden. Dies reduziert die Last auf dem Client und ist effizient bei großen Datenmengen. Allerdings kann die Navigation durch Datensätze eingeschränkt sein, und eine stabile Netzwerkverbindung ist erforderlich.Alternativ kann adUseClient <\/b>(2<\/b>) gesetzt werden, wodurch die Abfrageergebnisse auf den Client-PC geladen werden. Dies ermöglicht eine vollständige Navigation durch die Daten (MoveFirst<\/b>, MoveLast<\/b>, MovePrevious<\/b>), ist jedoch speicherintensiver.<\/p>\n Ein clientseitiger Cursor eignet sich besonders für Anwendungen mit vielen gleichzeitigen Benutzern oder wenn Daten offline bearbeitet werden sollen.<\/p>\n Diese Einstellung gilt generell für alle Zugriffe, die über diese Connection durchgeführt werden. Es gibt Recordset<\/b>– und Command<\/b>-Objekte für den Zugriff. Bei Recordsets können wir diese Eigenschaft allerdings noch individuell anpassen, Command<\/b>-Objekte übernehmen diese Eigenschaft von der angegebenen Connection.<\/p>\n Wir können in der Verbindungszeichenfolge auf die Angabe einer Datenbank verzichten. Dann wird zum Beispiel bei Zugriff auf den SQL Server die master<\/b>-Datenbank verwendet.<\/p>\n Dass dies der Fall ist, können wir mit der Eigenschaft DefaultDatabase<\/b> herausfinden. Diese nutzen wir nach dem Verbinden wie folgt:<\/p>\n Mit der DefaultDatabase<\/b>-Eigenschaft können wir aber auch zur Laufzeit bei geöffneter Verbindung die Datenbank wechseln. Dazu weisen wir dieser einfach den Namen der gewünschten Datenbank zu:<\/p>\n Den Provider geben wir normalerweise direkt mit der Verbindungszeichenfolge an.<\/p>\n Wir können diesen aber auch mit der Eigenschaft Provider <\/b>des Connection<\/b>-Objekts angeben.<\/p>\n Für den SQL Server verwenden wir für aktuelle Versionen (ab SQL Server 2012) diesen Provider:<\/p>\n Für ältere SQL Server-Versionen können wir diesen Provider nutzen:<\/p>\n Für Access-Datenbanken:<\/p>\n Wenn beim Zugriff auf eine SQL Server-Datenbank Fehler auftreten, können wir diese mit der herkömmlichen Err<\/b>-Klasse nur bedingt analysieren.<\/p>\n Deshalb bietet uns ADODB für das Connection<\/b>-Objekt eine eigene Errors<\/b>-Auflistung.<\/p>\n Wie man diese nutzt und welche Besonderheiten es insgesamt bei der Fehlerbehandlung bei den Zugriffstechniken DAO und ADODB gibt, beschreiben wir im Artikel SQL Server: Fehlerbehandlung in DAO und ADODB<\/b> (www.vbentwickler.de\/****<\/b>).<\/p>\n Mit der Mode<\/b>-Eigenschaft des Connection<\/b>-Objekts können wir die Art des Datenzugriffs festlegen.<\/p>\n Die Eigenschaft kann die folgenden Werte annehmen:<\/p>\n Mit der Eigenschaft Version <\/b>können wir die Version der ADODB-Bibliothek ermitteln.<\/p>\n Dazu brauchen wir keine Connection zu öffnen, das Erstellen allein reicht aus, um auf diese Eigenschaft zuzugreifen:<\/p>\n Für die in diesem Beispiel verwendete Bibliothek Microsoft ActiveX Data Objects 6.1 Library <\/b>erhalten wir den Wert 10<\/b>.<\/p>\n Wie viele andere Klassen liefert auch die Connection<\/b>-Klasse eine Properties<\/b>-Auflistung.<\/p>\n Diese durchlaufen wir wie folgt:<\/p>\n Wenn wir diese wie oben für ein frisch erstelltes Connection<\/b>-Objekt ausführen, erhalten wir nur wenige Eigenschaften mit den entsprechenden Werten (siehe Bild 3).<\/p>\n Bild 3: Ausgabe der Properties des Connection-Objekts<\/span><\/b><\/p>\n Wenn wir allerdings eine Verbindungszeichenfolge definieren und wie folgt erst danach die Properties durchlaufen, erhalten wir ein anderes Ergebnis:<\/p>\n Danach sieht die Ausgabe der Eigenschaften wie in Bild 4 aus.<\/p>\n Bild 4: Ausgabe der Properties des Connection-Objekts mit Verbindungszeichenfolge<\/span><\/b><\/p>\n Bisher haben wir die Open<\/b>-Methode immer ohne Parameter verwendet. Allerdings bietet diese Methode durchaus verschiedene Parameter an:<\/p>\n Die Verwendung von adAsyncConnect <\/b>sorgt dafür, dass die aufrufende Prozedur tatsächlich direkt die nächste Anweisung ausführt.<\/p>\n Wenn diese beispielsweise ein Recordset auf Basis der zuvor zu öffnenden Connection öffnen soll, kann das zu einem Fehler führen, weil die Verbindung noch nicht hergestellt wurde.<\/p>\n Ein sinnvoller Einsatzzweck wäre, wenn man weiß, dass das Herstellen der Verbindung länger dauern kann, diese bereits beim Starten der Anwendung zu öffnen und diese dann später zum Zugriff auf die Daten zu nutzen.<\/p>\n Die Close<\/b>-Methode der Connection<\/b>-Klasse trennt die Verbindung zur Datenquelle. Sie gibt Systemressourcen frei, die von der Verbindung genutzt wurden und setzt die State<\/b>-Eigenschaft der Verbindung auf adStateClosed<\/b> (0<\/b>). Falls offene Recordset- oder Command-Objekte existieren, bleiben diese erhalten, sind aber möglicherweise nicht mehr verwendbar.<\/p>\n Wir sollten die Close<\/b>-Methode immer aufrufen, wenn die Connection nicht mehr benötigt wird. Ein erneutes Aufrufen bei einer bereits geschlossenen Verbindung löst einen Fehler aus.<\/p>\n Mit der Cancel<\/b>-Methode können wir beispielsweise den Aufbau einer Verbindung abbrechen, wenn dieser zu lange dauert.<\/p>\n Das können wir in Zusammenhang mit dem Parameter adAsyncConnect <\/b>nutzen. Im folgenden Beispiel stellen wir den ConnectionTimeout <\/b>auf fünf Sekunden ein, öffnen die Verbindung mit adAsyncConnect <\/b>und lassen dann eine Do While<\/b>-Schleife laufen, solange die Verbindung noch nicht hergestellt ist.<\/p>\n War dieser nach fünf Sekunden noch nicht erfolgreich, wird die Cancel<\/b>-Methode aufgerufen. Deren Ausführung kann noch einige Sekunden dauern, bis der asynchrone Verbindungsaufbau beendet ist.<\/p>\n Zumindest wissen wir aber hier bereits nach der angegebenen Zeit, dass die Verbindung wohl nicht geöffnet werden kann:<\/p>\n Die Execute-Methode liefert schnelle Möglichkeiten, über die Connection direkt Recordsets zu füllen oder Aktionsabfragen auszuführen.<\/p>\n Wir gehen in einem eigenen Artikel namens ADODB: SQL-Befehle schnell ausführen mit Execute (www.vbentwickler.de\/447<\/b>) auf diese Methode ein.<\/p>\n Diese Methode erlaubt uns, Metadaten über die Elemente einer Datenbank abzurufen. Auch diesem Thema widmen wir einen eigenen Artikel: ADODB: Datenbankinformationen mit OpenSchema ermitteln <\/b>(www.vbentwickler.de\/469<\/b>).<\/p>\n Die Connection<\/b>-Klasse bietet sowohl die Methoden zum Starten, Abschließen oder Zurücksetzen von Transaktionen (wie BiginTrans<\/b>, CommitTrans <\/b>und RollbackTrans<\/b>) als auch noch eine weitere Eigenschaft, mit der wir das Verhalten beim Durchführen von Transaktionen beeinflussen können (IsolationLevel<\/b>).<\/p>\n Diese schauen wir uns in einem weiteren Artikel namens Transaktionen mit ADODB und SQL Server <\/b>(www.vbentwickler.de\/450<\/b>) an.<\/p>\n Enthaltene Beispieldateien:<\/p>\n ADODB_Connections.accdb<\/p>\nEigenschaften der Connection-Klasse<\/h2>\n
\n
Methoden der Connection-Klasse<\/h2>\n
\n
Zugriff auf die aktuelle Access-Datenbank<\/h2>\n
CurrentProject.Connection.ConnectionString\r\nProvider=Microsoft.ACE.OLEDB.12.0;User ID=Admin;Data Source=C:\\...\\ADODB_Connections.accdb;Mode=Share Deny None;Extended Properties=\"\";Jet OLEDB:System database=C:\\Users\\User\\AppData\\Roaming\\Microsoft\\Access\\System.mdw;Jet OLEDB:Registry Path=Software\\Microsoft\\Office\\16.0\\Access\\Access Connectivity Engine;Jet OLEDB:Database Password=\"\";Jet OLEDB:Engine Type=6;Jet OLEDB:Database Locking Mode=0;Jet OLEDB:Global Partial Bulk Ops=2;Jet OLEDB:Global Bulk Transactions=1;Jet OLEDB:New<\/span> Database Password=\"\";Jet OLEDB:Create System Database=False;Jet OLEDB:Encrypt Database=False;Jet OLEDB:Don''t Copy Locale on Compact=False;Jet OLEDB:Compact Without Replica Repair=False;Jet OLEDB:SFP=False;Jet OLEDB:Support Complex Data=True;Jet OLEDB:Bypass UserInfo Validation=False;Jet OLEDB:Limited DB Caching=False;Jet OLEDB:Bypass ChoiceField Validation=False<\/span><\/pre>\nPublic Sub <\/span>AktiveDatenbank()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Set<\/span> cnn = CurrentProject.Connection\r\n Debug.Print<\/span> cnn.ConnectionString\r\nEnd Sub<\/span><\/pre>\nVerbindungszeichenfolgen für den Zugriff per ADODB<\/h2>\n
Verbindungszeichenfolge für SQL Server mit Windows-Authentifizierung<\/h2>\n
Provider=MSOLEDBSQL;Server=amvDesktop2023;Database=Mitarbeiterverwaltung;Trusted_Connection=yes;<\/pre>\n
Verbindungszeichenfolge für SQL Server mit SQL Server-Authentifizierung<\/h2>\n
Provider=MSOLEDBSQL;Server=amvDesktop2023;Database=Mitarbeiterverwaltung;UID=[Benutzername];PWD=[Kennwort];<\/pre>\n
Verbindungszeichenfolge ohne Angabe der Datenbank<\/h2>\n
Verbindungszeichenfolge für Access-Datenbanken<\/h2>\n
Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\...\\ADODB_Test.accdb;Persist Security Info=False;<\/pre>\n
Öffnen und Testen der Datenbankverbindung<\/h2>\n
Dim <\/span>cnn As <\/span>ADODB.Connection\r\nSet<\/span> cnn = CurrentProject.Connection\r\ncnn.Open<\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2024_06\/pic_446_002.png\")
<\/p>\nPrüfen, ob Verbindung bereits geöffnet ist<\/h2>\n
\n
Funktion zur lesbaren Ausgabe der Konstanten für ObjectStateEnum<\/h2>\n
Public Function <\/span>ObjectStateEnum_String(lngObjectStateEnum As Long<\/span>) As String<\/span>\r\n Select Case lngObjectStateEnum\r\n Case <\/span>0\r\n ObjectStateEnum_String = \"adStateClosed\"\r\n Case <\/span>1\r\n ObjectStateEnum_String = \"adStateOpen\"\r\n Case <\/span>2\r\n ObjectStateEnum_String = \"adStateConnecting\"\r\n Case <\/span>4\r\n ObjectStateEnum_String = \"adStateExecuting\"\r\n Case <\/span>8\r\n ObjectStateEnum_String = \"adStateFetching\"\r\n Case Else<\/span>\r\n ObjectStateEnum_String = \"Unbekannter Status\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nDim <\/span>cnn As <\/span>ADODB.Connection\r\nSet<\/span> cnn = CurrentProject.Connection\r\ncnn.Open\r\nDebug.Print<\/span> ObjectStateEnum_String(cnn.State)<\/pre>\nConnection immer wieder schließen<\/h2>\n
cnn.Close<\/pre>\n
Set<\/span> cnn = Nothing<\/pre>\nUnterschiede zwischen server- und clientseitigem Cursor in ADODB<\/h2>\n
Aktuelle Datenbank der Connection einstellen und ermitteln<\/h2>\n
Set<\/span> cnn = New<\/span> ADODB.Connection\r\nstrConnection = \"Provider=MSOLEDBSQL;Server=amvDesktop2023;Trusted_Connection=yes;\"\r\ncnn.ConnectionString = strConnection\r\ncnn.Open\r\nDebug.Print<\/span> cnn.DefaultDatabase\r\n...<\/pre>\nDatenbank für eine Verbindung wechseln<\/h2>\n
cnn.DefaultDatabase = \"Mitarbeiterverwaltung\"<\/pre>\n
Provider der Verbindung ermitteln<\/h2>\n
MSOLEDBSQL<\/pre>\n
SQLOLEDB<\/pre>\n
ACE.OLEDB.12.0<\/pre>\n
Fehler beim Zugriff mit ADODB auswerten<\/h2>\n
Verschiedene Modi für den Datenbankzugriff<\/h2>\n
\n
ADODB-Version ermitteln<\/h2>\n
Public Function <\/span>ADODBVersion()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n Debug.Print<\/span> cnn.Version\r\nEnd Function<\/span><\/pre>\nDie Property-Auflistung der Connection-Klasse<\/h2>\n
Public Function <\/span>ADODBProperties()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>prp As <\/span>ADODB.Property\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n For Each prp In cnn.Properties\r\n Debug.Print<\/span> prp.Name, prp.Value\r\n Next<\/span> prp\r\nEnd Function<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2024_06\/pic_446_003.png\")
<\/p>\nDim <\/span>strConnection As String<\/span>\r\nDim <\/span>cnn As <\/span>ADODB.Connection\r\nDim <\/span>prp As <\/span>ADODB.Property\r\nSet<\/span> cnn = New<\/span> ADODB.Connection\r\nstrConnection = \"Provider=MSOLEDBSQL;Server=amvDesktop2023;Trusted_Connection=yes;\"\r\ncnn.ConnectionString = strConnection\r\nFor Each prp In cnn.Properties\r\n Debug.Print<\/span> prp.Name, prp.Value\r\nNext<\/span> prp<\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2024_06\/pic_446_004.png\")
<\/p>\nÖffnen von Connections<\/h2>\n
\n
Schließen von Connections<\/h2>\n
Abbrechen des Verbindungsaufbaus<\/h2>\n
Public Sub <\/span>AsynchronerAufbauMitAbbruch()\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>dblStart As Double<\/span>\r\n Set<\/span> cnn = CreateObject(\"ADODB.Connection\")\r\n cnn.Open \"Provider=SQLOLEDB;...\", , , adAsyncConnect \r\n dblStart = Timer\r\n Do While<\/span> cnn.State = adStateConnecting\r\n DoEvents\r\n Debug.Print<\/span> Timer, dblStart, Timer - dblStart\r\n If <\/span>Timer - dblStart > 5 Then<\/span>\r\n Debug.Print<\/span> _\r\n \"Verbindungsaufbau wird abgebrochen.\"\r\n cnn.Cancel\r\n Debug.Print<\/span> \"Verbindungsaufbau abgebrochen!\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n Debug.Print<\/span> \"Verbindungsaufbau erfolgreich.\"\r\nEnd Sub<\/span><\/pre>\nDie Execute-Methode<\/h2>\n
Die OpenSchema-Methode<\/h2>\n
Transaktionen mit ADODB<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n