<\/p>\n
Haben Sie sich nicht auch schon immer gefragt, welche Zugriffstechnik am besten für den Zugriff auf Tabellen in aktiven Datenbanksystemen geeignet ist Falls Sie dies bereits mit ADODB- und DAO-Methoden getestet haben, wissen Sie vermutlich, dass keine Zugriffsmethode alle Wünsche eines Access-Programmierers erfüllt. Es bleibt also nichts anderes übrig, als die Einschränkungen hinzunehmen oder unterschiedliche Methoden parallel einzusetzen.<\/b><\/p>\n
Im Beitrag Anmeldung an SQL Server und Co.<\/b> wurde eine Methodensammlung zum Anmelden an aktive Datenbankmanagementsysteme (DBMS) vorgestellt (s. Shortlink 668). Diese Sammlung erweitern wir nun um eine Klassenstruktur zur Kapselung unterschiedlicher Verbindungstechniken. Voraussetzung zum Testen der nachfolgend vorgestellten Klassen ist eine Datenbank unter MySQL oder Microsoft SQL Server, die Sie über die Methoden des oben vorgestellten Beitrags mit der Frontend-Datenbank verknüpfen. Ist dies erledigt, können Sie mit den Methoden und Eigenschaften sehr viel einfacher auf die Datenbank zugreifen als zuvor – und noch besser: Wenn Sie sich entscheiden, die Backend-Datenbank vom SQL Server nach MySQL zu übertragen oder umgekehrt, brauchen Sie den Code für den Zugriff auf die Daten nicht zu ändern (das gilt wegen unterschiedlicher Dialekte jedoch nicht uneingeschränkt für die enthaltenen SQL-Anweisungen). Bevor wir hinter die Kulissen schauen, hier ein paar Beispiele. Das erste betrifft die Domänenfunktionen wie etwa DCount<\/b>. Damit können Sie sich die Anzahl der Datensätze einer in der Datenbank enthaltenen oder verknüpften Tabelle wie folgt ausgeben lassen:<\/p>\n Die nachfolgend vorgestellten Klassen ermöglichen erstens einen Zugriff auf die gleichen Informationen, allerdings auf Basis eines Recordsets. Handelt es sich um eine verknüpfte Tabelle, verwenden Sie einfach die folgende Anweisung:<\/p>\n Vielleicht arbeiten Sie gar nicht mit einer Verknüpfung, sondern möchten per ADODB direkt auf die Tabelle des MySQL- oder SQL Servers zugreifen Dann funktioniert diese Variante:<\/p>\n Die Klassen bieten noch eine Reihe weiterer Funktionen, beispielsweise um ein Recordset zu erzeugen. Für eine verknüpfte Tabelle sieht dies so aus:<\/p>\n Ist die Tabelle nicht verknüpft, hilft die ADODB-Variante weiter:<\/p>\n Sie können aber auch mit einem DAO-Recordset arbeiten, das via ODBC erzeugt wurde:<\/p>\n Es gibt noch einige weitere Funktionen, mit denen Sie etwa den Connectionstring der aktuell verwendeten Verbindung ausgeben können. Mehr dazu erfahren Sie weiter unten.<\/p>\n Grundlagen<\/b><\/p>\n Für den Zugriff von einem Access-Frontend auf ein DBMS stehen unterschiedliche Verbindungstechniken zur Verfügung:<\/p>\n Die folgenden Abschnitte stellen diese Möglichkeiten und deren Vor- und Nachteile kurz vor.<\/p>\n Verknüpfte Tabellen und Sichten<\/b><\/p>\n Die Tabellen oder Sichten aus der Datenbank werden im Access-Frontend über ODBC verknüpft. Der Zugriff auf die Daten erfolgt über die lokale Frontend-Database-Instanz. Bei Abfragen mit verknüpften Tabellen wird die SQL-Anweisung von Jet beziehungsweise ACE (ab Access 2007) entgegengenommen und für die Weitergabe per ODBC an das Datenbanksystem aufbereitet.<\/p>\n Der ODBC-Manager übernimmt die aufbereitete SQL-Anweisungen und transferiert sie über den ODBC-Treiber an das DBMS. Das DBMS arbeitet die nun erhaltene SQL-Anweisung ab und gibt das Ergebnis an Jet zurück.<\/p>\n Sobald Jet- beziehungsweise VBA-Funktionen in der Abfrage eingesetzt werden, können diese nicht an das DBMS weitergereicht werden und müssen von Jet selbst abgearbeitet werden.<\/p>\n Tipp: Betrachten Sie die vom ODBC-Treiber für den SQL Server aufbereitete SQL-Anweisung und deren Abarbeitung mit dem SQL-Server-Profiler. Der Microsoft SQL Server übernimmt auch beim Einsatz von Access-Abfragen mit verknüpften Tabellen einen Großteil der Datenaufbereitung und nicht – wie oftmals behauptet wird – nur Access und Jet. <\/p>\n Zugriffsweg<\/b>: Access  Jet\/ACE  ODBC-Manager  ODBC-Treiber  DBMS<\/p>\n Vorteil<\/b>: Vorgehensweise wie bei Access\/Jet-Tabellen und somit wenig Umstellungsaufwand beim Wechsel von einer Jet-Datenbank zu einer Datenbank in einem aktiven DBMS.<\/p>\n Nachteil<\/b>: Bei komplexeren Access-Abfragen auf verknüpfte Tabellen kann es zu Geschwindigkeitseinbußen kommen. Außerdem können die Fähigkeiten des DBMS nicht vollständig eingesetzt werden (etwa Einsatz von gespeicherten Prozeduren).<\/p>\n Pass-Through-Abfragen<\/b><\/p>\n Pass-Through-Abfragen erhalten über einen ODBC-Connectionstring eine Verbindung zum DBMS. Bei Pass-Through-Abfragen entfällt die Auswertung der SQL-Anweisung durch Jet. Daher muss die in einer Pass-Through-Abfrage enthaltene SQL-Anweisung im SQL-Dialekt des DBMS vorliegen.<\/p>\n Zugriffsweg<\/b>: Access  ODBC-Manager  ODBC-Treiber  DBMS<\/p>\n Vorteil<\/b>: Die SQL-Anweisung wird direkt ohne Umweg über Jet im DBMS ausgeführt. Dadurch können die Fähigkeiten des DBMS besser genutzt werden.<\/p>\n Nachteil<\/b>: Die über eine Pass-Through-Abfrage erhaltenen Datensätze können nicht bearbeitet werden (bei einer verknüpften Sicht sind die Datensätze bearbeitbar, wenn im Access-Frontend ein Primärschlüssel eingestellt wurde).<\/p>\n ADO-Verbindung zur Datenbank<\/b><\/p>\n Der Zugriff erfolgt über einen OLEDB-Provider auf das DBMS. Beachten Sie, dass eine dezidierte Verbindung zum DBMS aufgebaut werden muss und nicht die ADODB-Connection des Frontends über CurrentProject.Connection <\/b>und die verknüpften Tabellen genutzt wird. Denn sonst würde der Zugriff abermals über die ODBC-Verbindung laufen.<\/p>\n Damit die Verbindung direkt zum DBMS aufgebaut werden kann, müssen Sie eine ADODB-Connection mit dem OLEDB-Provider des DBMS öffnen. Für den Zugriff auf einen MSSQL-Server können beispielsweise die OLEDB-Provider „SQLOLEDB“ oder „SQLNCLI“ verwendet werden. Sollte für ein DBMS, wie bei MySQL, kein spezieller OLEDB-Provider vorhanden sein, können Sie als Brücke zwischen OLEDB und ODBC den Microsoft OLEDB-Provider für ODBC verwenden und für den Verbindungsaufbau den ODBC-Treiber des DBMS einsetzen. In diesem Fall wird zwar intern wieder über ODBC auf das DBMS zugegriffen, trotzdem können Sie die meisten Fähigkeiten der ADO-Bibliothek nutzen. Die in ADODB-Methoden eingesetzten SQL-Anweisungen werden über ADO an den OLEDB-Provider übergeben und von dort an das DBMS weitergereicht – ähnlich, wie bei den Pass-Through-Abfragen. Die SQL-Anweisungen müssen daher im jeweiligen SQL-Dialekt des DBMS verfasst werden.<\/p>\n Zugriffsweg<\/b>: Access  ADO  OLEDB-Provider  DBMS<\/p>\n Vorteil<\/b>: Für die meisten aktiven DBMS ist die ADO-Variante die schnellste Zugriffsmethode. Das ADODB-Objektmodell bietet außerdem umfangreichere Methoden für den Datenzugriff als das DAO-Objektmodell (zum Beispiel Ausführung von SQL-Anweisung über ADODB.Command<\/b>).<\/p>\n Nachteil<\/b>: Der Programmieraufwand der Standard-ADODB-Methoden ist höher als beim DAO-Zugriff. Datenverarbeitung über ADODB kann nur mit VBA oder Formulare genutzt werden. Der Einsatz für Access-Berichte ist in einer .mdb <\/b>beziehungsweise .accdb <\/b>nicht möglich (nur beim Einsatz eines ADP-Frontends erfolgt der Zugriff über ADODB\/OLEDB).<\/p>\n ODBCDirect<\/b><\/p>\n Mit einem ODBC-Connectionstring wird ein DAO-Arbeitsbereich (DAO.Workspace<\/b>) erstellt. Diese Zugriffsvariante stellt im Prinzip ein DAO-Gegenstück zur ADODB-Verbindung dar. Die SQL-Anweisungen erfolgen im SQL-Dialekt des DBMS.<\/p>\n Zugriffsweg<\/b>: Access  ODBCDirect  ODBC-Manager  ODBC-Treiber  DBMS<\/p>\n Da diese Variante ab Access 2007 nicht mehr zur Verfügung steht, wird sie im folgenden Text nicht weiter berücksichtigt.<\/p>\n DAO-Database-Instanz mit ODBC-Connectionstring <\/b><\/p>\n Mithilfe eines ODBC-Connectionstrings wird eine DAO-Database-Instanz geöffnet. Die SQL-Anweisungen erfolgen im Access\/Jet-SQL-Dialekt. Sie können diese Variante mit dem Vorgehen bei einem Jet-Backend vergleichen, bei dem nicht über verknüpfte Tabellen auf die Tabellen im Backend zugegriffen wird, sondern auf die Backend-Datenbank über eine eigene Database-Instanz.<\/p>\n Zugriffsweg<\/b>: Access  Jet\/ACE  ODBC-Manager  ODBC-Treiber  DBMS<\/p>\n Vorteil<\/b>: Tabellen beziehungsweise Sichten müssen nicht verknüpft werden. Die Datensätze im geöffneten Recordset sind bearbeitbar, wenn die verwendete SQL-Anweisung eine Bearbeitung erlaubt.<\/p>\n Nachteil<\/b>: Es können keine gespeicherten Prozeduren ausgeführt werden.<\/p>\n Zusammenfassung<\/b><\/p>\n Jede Verbindungstechnik hat in einem bestimmten Bereich Vorteile. Aus diesem Grund ist der Einsatz einer Kombination ausgewählter Techniken im Access-Frontend sinnvoll. Für MSSQL oder MySQL könnte etwa folgende Kombination eingesetzt werden:<\/p>\n Vorteil: Die jeweils passende Technik ermöglicht effizienten Datenzugriff und Nutzung der Fähigkeiten des DBMS.<\/p>\n Nachteil: DAO- und ADO-Methoden müssen unterschiedlich programmiert werden. Das erschwert einen Wechsel der Zugriffstechnik.<\/p>\n Beispiel: Recordset öffnen<\/b><\/p>\n Das Öffnen eines DAO-Recordsets geschieht durch folgende Anweisungen:<\/p>\n Die entsprechende Vorgehensweise für ein ADODB-Recordset benötigt diese Zeilen:<\/p>\n Ziel dieses Beitrags<\/b><\/p>\n Der Zugriff auf ein DBMS soll standardisiert und DAO- und ADODB-Methoden sollen über eine ähnliche Schnittstelle aufrufbar werden.<\/p>\n Ausgangssituation und Konzept<\/b><\/p>\n Ein Access-Frontend wird für den Zugriff auf eine Datenbank in einem aktiven DBMS eingesetzt. Komplexere SQL-Anweisungen werden im DBMS in Form von Sichten und gespeicherten Prozeduren zur Verfügung gestellt. Aus diesem Grund ist der Einsatz von ADODB-Methoden beziehungsweise Pass-Through-Abfragen sinnvoll.<\/p>\n Anforderungen:<\/p>\n Lösungsansatz:<\/p>\n Funktionsweise:<\/p>\n Über das Startformular frmAppWatcher<\/b> wird die Startprozedur StartApplication <\/b>aufgerufen. Diese Prozedur startet den Verbindungsaufbau und die Instanzierung der Klasse für die Zugriffssteuerung. Die Verbindungsparameter werden über die DbConnectionInfo<\/b>-Instanz ausgelesen und der Zugriffssteuerung bei Bedarf bereitgestellt. Über die Klasse DbConnectionHandler <\/b>steht ein Objektmodell zur Verfügung, dessen Elemente Sie bequem über die Punkt-Syntax ansprechen können – zum Beispiel CurrentDBConnection.ODBC.OpenRecordset(…)<\/b>.<\/p>\n Das Objektmodell stellt drei verschiedene Zugriffsvarianten zur Verfügung:<\/p>\n Zugriffsvariante ADODB<\/b><\/p>\n Diese Variante eignet sich für den direkten Zugriff auf die Datenbanken im DBMS. Sie bietet folgende Eigenschaften:<\/p>\n Außerdem können Sie folgende Methoden für die Ausführung von SQL-Anweisungen verwenden:<\/p>\n <\/p>\n Methoden zum Öffnen von Recordsets:<\/p>\n Recordset-Ersatzfunktionen für Domänenfunktionen:<\/p>\n Zugriffsvariante DAO<\/b><\/p>\n Diese Variante ermöglicht den Zugriff über verknüpfte Tabellen beziehungsweise den Einsatz von CurrentDb <\/b>des Frontends. Die Klasse bietet nur eine Eigenschaft:<\/p>\n Die Methoden für die Ausführung von SQL-Anweisungen sehen so aus:<\/p>\n Methoden zum Öffnen von Recordsets:<\/p>\n Recordset-Ersatzfunktionen für Domänenfunktionen:<\/p>\n Zugriffsvariante ODBC <\/b><\/p>\n Diese Klasse dient dem Zugriff über ODBC (dynamische PT-Abfrage beziehungsweise DAO-Database-Instanz mit ODBC-Connectionstring). Sie offeriert folgende Eigenschaften:<\/p>\n Methoden für die Ausführung von SQL-Anweisungen:<\/p>\n Methoden zum Öffnen von Recordsets:<\/p>\n Recordset-Ersatzfunktionen für Domänenfunktionen:<\/p>\n Die übrigen Domänenfunktionen sind wie unter DAO aufgebaut. Hilfsmethoden:<\/p>\n Die Klasse DbConnection<\/b><\/p>\n Eine weitere Klasse namens DbConnection<\/b> liefert weitere hilfreiche Methoden – zum Beispiel den verkürzten Methoden-\/Eigenschaftszugriff von Zugriffsklassen:<\/p>\n Außerdem gibt es Ereignisse zur Problemlösung (auch für nachträgliche Initialisierung verwendbar). Diese Ereignisse können Sie beispielsweise verwenden, um zur Laufzeit für einzelne Zugriffe andere Verbindungszeichenfolgen zu verwenden:<\/p>\n Wie das aussehen kann, zeigt folgendes Beispiel:<\/p>\n Umsetzung<\/b><\/p>\n Auf den folgenden Seiten ist eine Umsetzungsvariante für die zuvor getroffenen Anforderungen beschrieben. Aufgrund des umfangreicheren Codes in der Beispielanwendung werden in der folgenden Beschreibung nur Code-Auszüge gezeigt. Wenn Sie mehr Details zu den gezeigten Prozeduren benötigen, öffnen Sie bitte den Code in der Beispielanwendung DBMSZugriff.mdb<\/b>.<\/p>\n Einstellen der Verbindungsdaten<\/b><\/p>\n Die Verbindungsdaten werden über die Klasse DbConnectionInfo <\/b>bereitgestellt. Als Schnittstelle zwischen DbConnectionInfo <\/b>und der Zugriffsklasse DbConnectionHandler <\/b>dient die Klasse AccUtilInstancer<\/b>. Die Übergabe der Verbindungsparameter erfolgt beim ersten Zugriff auf die Instanz von DbConnectionHandler <\/b>über die Eigenschaft DbConnection <\/b>in AccUtilInstancer <\/b>(s. Listing 1). Sollte noch keine Instanz von DbConnectionInfo <\/b>vorhanden sein, wird diese durch die Verwendung von ConnectionInfo <\/b>erzeugt und die Verbindungsparameter werden ermittelt. Falls Sie sich die Frage stellen, warum DbConnectionInfo <\/b>nicht als Element von DbConnectionHandler <\/b>eingesetzt wird, damit das Instanzieren von zwei Klassen über die Hilfsklasse entfällt: Durch die Verbindung der Instanzen von DbConnectionHandler <\/b>und DbConnectionInfo <\/b>über AccUtilInstancer <\/b>bleiben die Klassen unabhängig voneinander und können flexibler eingesetzt werden. Wenn eine Anwendung nur für eine einzige Datenbankverbindung genutzt werden soll, benötigen Sie die Klasse DbConnectionInfo <\/b>nicht, da Sie die Verbindungsparameter als Konstante im VBA-Code ablegen können. In diesem Fall müssten Sie Me.ConnectionInfo.OdbcConnectionString <\/b>beziehungsweise Me.ConnectionInfo.OledbConnectionString <\/b>in der Prozedur initDbConnection <\/b>durch eine passende String-Konstante ersetzen.<\/p>\n Beim Zugriff über Me.DbConnection.CurrentDb<\/b>, Me.DbConnection.OdbcConnectionString <\/b>und Me.DbConnection.OledbConnectionString <\/b>wird bereits der erste verkürzte Aufruf zu den Zugriffsvarianten aus der DbConnectionHandler<\/b>-Klasse genutzt (s. Listing 2).<\/p>\n Listing 3: CurrentDbC-Variante in DaoHandler-Klasse<\/p>\n Das Speichern der lokalen DAO-Database-Instanz in der Klasse DaoHandler <\/b>hat den Vorteil, dass bei Bedarf auch eine externe Database<\/b>-Instanz übergeben werden könnte. Das ist notwendig, falls Sie die Zugriffsklassen in eine COM-Bibliothek oder ähnliches verschieben wollen. Außerdem entsteht dadurch der Effekt, den man über die oft empfohlene CurrentDbC<\/b>-Eigenschaft von Michael Kaplan erreicht (s. Listing 3). Der Unterschied zur üblichen CurrentDbC<\/b>-Variante ist das Beschaffen einer Database<\/b>-Instanz, falls die Membervariable m_DaoDb <\/b>auf Nothing verweist. In der CurrentDbC<\/b>-Variante von Michael Kaplan würde die Referenz direkt in der Property<\/b>-Prozedur durch Application.CurrentDb <\/b>gesetzt werden. In der CurrentDb<\/b>-Methode der Klasse DaoHandler <\/b>wird ein Ereignis ausgelöst, auf welches in der Klasse AccUtilInstancer <\/b>reagiert wird (s. Listing 4).<\/p>\n Listing 5: Einsatz der Klassenstruktur: Test der Recordset-Ersatzfunktionen für DLookup<\/p>\n Listing 7: OpenRecordset-Methode<\/p>\n Der Vorteil dieser Variante besteht in der Zuweisung der Referenz über das Ereignis. Dadurch ist die Referenzübergabe nicht fix in der Klassenstruktur enthalten und kann über die Hauptanwendung gesteuert werden (Anm.: AccUtilInstancer <\/b>ist immer als Teil der Hauptanwendung zu betrachten und wird nie in eine Code-Bibliothek ausgelagert).<\/p>\n Einsatz der Zugriffsklassen<\/b><\/p>\n Sobald die Verbindungsparameter übergeben wurden, sind die Zugriffsmethoden einsatzbereit (s. Listing 5). Der Zugriff auf die DbConnectionHandler<\/b>-Instanz erfolgt über die Property<\/b>-Prozedur CurrentDbConnection <\/b>im Modul modAccessUtilities<\/b> (s. Listing 6).<\/p>\n Listing 9: OpenAdoRecordset-Funktion im Modul modADO<\/p>\n Die Property<\/b>-Prozedur CurrentDbConnection <\/b>stellt die anwendungsweite DbConnectionHandler<\/b>-Instanz zur Verfügung.<\/p>\n Über die Eigenschaften ADODB, DAO beziehungsweise ODBC können Sie die gewünschte Zugriffstechnik wählen. ADODB greift über die ADODB-Connection auf die Datenbank zu. DAO nutzt die verknüpfte Tabelle im Access-Frontend und ODBC setzt eine auf einer ODBC-Verbindung basierende DAO-Database-Instanz ein.<\/p>\n Die nahezu identisch aufgebauten Methoden in den Zugriffsklassen erleichtern die Wahl der Zugriffsmethode, da Sie sich nur noch einen Methodennamen für drei Zugriffsvarianten merken müssen.<\/p>\n Code-Auszüge: OpenRecordset<\/b><\/p>\n Die Methode OpenRecordset <\/b>gibt über die AdodbHandler<\/b>-Klasse ein geöffnetes ADODB<\/b>-Recordset zurück. DaoHandler <\/b>und OdbcHandler <\/b>liefern ein DAO-Recordset (s. Listing 7).<\/p>\n In der OpenRecordset<\/b>-Methode der Zugriffsklassen wird der jeweilige Zugriffscode (ADODB oder DAO) gekapselt. Damit müssen Sie sich im restlichen Code nicht mehr um die unterschiedliche Erstellung eines Recordsets je Zugriffsvariante kümmern.<\/p>\n Bei der Verwendung dieser Methoden müssen Sie allerdings die passende SQL-Syntax beachten. Vor allem beim Like<\/b>-Ausdruck werden manchmal die unterschiedlichen Platzhalter übersehen (DAO: *<\/b>, ADODB und ODBC-Pass-Through: %<\/b>).<\/p>\n Die restlichen Methoden sind ähnlich aufgebaut und beliebig erweiterbar. Es ist hilfreich, wenn Sie die Recordset-Ersatzfunktionen für die Domänenfunktionen DLookup<\/b>, DMax <\/b>und so weiter in den Zugriffsklassen kapseln. Beispiele für erweiterte Domänenfunktionen werden im Artikel Schnelle Domänenfunktionen <\/b>aus Heft 3\/2009 gezeigt (s. Shortlink 644). <\/p>\n Tabellen verknüpfen<\/b><\/p>\n In der OdbcHandler<\/b>-Klasse sind zusätzlich einige Hilfsmethoden zum Verknüpfen von Tabellen enthalten. Einen möglichen Anwendungsfall sehen Sie im Formular frmConfig_LinkTables<\/b>. Dieses Formular ermöglicht die Wartung der verknüpften Tabellen. Zur Visualisierung der durchgeführten Verknüpfungsaktualisierung werden Ereignisse aus der Klasse OdbcHandler <\/b>eingesetzt (s. Listing 8).<\/p>\n Methodenaufruf abkürzen<\/p>\n Ist Ihnen das Schreiben von CurrentDbConnection.ADODB.OpenRecordset(…) <\/b>zu aufwendig Dann verkürzen Sie den Aufruf mithilfe einer Funktion in einem allgemeinen Modul (s. Listing 9).<\/p>\n Zusätzliche DBMS-Verbindungen verwenden<\/b><\/p>\n Sollten Sie eine weitere DBMS-Verbindung benötigen, können Sie eine neue Instanz von DbConnectionHandler <\/b>erzeugen und die passenden Verbindungsparameter in Form eines ODBC- und\/oder OLEDB-Connectionstrings übergeben:<\/p>\n Mit diesem Beispiel wird der Vorteil einer Klassenstruktur gut erkennbar. Würde der Zugriffscode über eine Funktion in einem allgemeinen Modul ablaufen, müssten zusätzliche Parameter zur Connectionstring-Übergabe vorhanden sein, damit die Funktion für mehrere parallele DBMS-Verbindungen genutzt werden kann.<\/p>\n Das entfällt beim Einsatz von Klassen, da jede erzeugte Instanz unterschiedlich einstellbar ist.<\/p>\n Einsatz in Formularen<\/b><\/p>\n Wenn Sie in einem Formular die Daten aus einem ADODB-Recordset anzeigen wollen, können Sie die ADODB-Recordset-Referenz dem Formular-Recordset übergeben:<\/p>\n Bei diesem Code müssen Sie beachten, dass Sie die CursorLocation <\/b>auf adUseClient <\/b>setzen. Das Formular frmTest_Zugriffsvarianten <\/b>zeigt ein ausführlicheres Beispiel, wie Sie die unterschiedlichen Zugriffstechniken als Datenquelle für ein Formular einsetzen können (siehe Bild 1).<\/p>\n Bild 1: Formular zum Testen unterschiedlicher Zugriffstechniken<\/span><\/b><\/p>\n Über die Auswahl der Datenbasis im linken unteren Listenfeld wird die jeweilige Zugriffstechnik zur Datenanzeige im Unterformular verwendet (s. Listing 12).<\/p>\n Mit diesem Formular können Sie testen, wie sich die unterschiedlichen Zugriffstechniken auf die Bearbeitbarkeit der Datensätze auswirken.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die hier vorgestellten Methoden zum Zugriff auf ein aktives DBMS über ADO\/OLEDB oder DAO\/ODBC sind als Basis für eine umfangreiche Methodensammlung zu betrachten. <\/p>\n Für den Ausbau Ihrer Klassenstruktur haben wir noch einige Anregungen:<\/p>\n Listing 2: Verbindung in der Zugriffsklasse DbConnectionHandler einstellen<\/p>\n Listing 4: Reaktion auf ErrorMissingCurrentDb in AccUtilInstancer mit Übergabe der Database-Referenz<\/p>\n Listing 6: Zugriff auf DbConnectionHandler-Instanz<\/p>\n Listing 12: Unterschiedliche Zugriffstechniken testen<\/p>\n Listing 1: Verbindungsinitialisierung in der Klasse AccUtilInstancer<\/p>\n Listing 8: Tabellen verknüpfen<\/p>\n Listing 10: Zusätzliche DbConnectionHandler-Instanz verwenden<\/p>\n Enthaltene Beispieldateien:<\/p>\n DbmsZugriff.mdb<\/p>\nDebug.Print DCount(\"*€, \"tblArtikel€)<\/pre>\n
Debug.Print CurrentDBConnection.DAO.DCount(\"*€, \"tblArtikel€)<\/pre>\n
Debug.Print CurrentDBConnection.ADODB.DCount(\"*€, \"tblArtikel€)<\/pre>\n
Set rst = CurrentDBConnection.DAO.OpenRecordset(\"SELECT * FROM tblArtikel€)<\/pre>\n
Set rst = CurrentDBConnection.ADODB.OpenRecordset(\"SELECT * FROM tblArtikel€)<\/pre>\n
Set rst = CurrentDBConnection.ODBC.OpenRecordset(\"SELECT * FROM tblArtikel€)<\/pre>\n
\n
\n
Dim rst As DAO.Recordset\r\nSet rst = CurrentDb.OpenRecordset(\"SELECT *\r\nFROM Tabelle€, dbOpenDynaset, dbSeeChanges)<\/pre>\n
Dim rst As ADODB.Recordset\r\nSet rst = New ADODB.Recordset\r\nrst.Open \"SELECT * FROM Tabelle€,\r\nCurrentConnection, adOpenDynamic<\/pre>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
Private Sub m_DbConnection_ErrorMissingCurrentDb\r\n (ByVal Msg As String, _\r\n NewCurrentDbRef As DAO.Database)\r\n Set NewCurrentDbRef = Application.CurrentDb\r\n End Sub<\/pre>\n
Private m_DaoDb As DAO.Database\r\nPublic Property Get CurrentDb() As DAO.Database\r\nIf (m_DaoDb Is Nothing) Then\r\n RaiseEvent ErrorMissingCurrentDb( _\r\n \"DaoHandler.CurrentDb: unavailable CurrentDb-Database€, m_DaoDb)\r\nEnd If\r\nSet CurrentDb = m_DaoDb\r\nEnd Property<\/pre>\n
Private Sub DLookupTest()\r\n Dim x As Variant\r\n x = CurrentDbConnection.ADODB.DLookup(\"FeldA€, \"Tabelle€, \"ID=1€) €ADODB-Variante\r\n Debug.Print x\r\n x = CurrentDbConnection.DAO.DLookup(\"FeldA€, \"Tabelle€, \"ID=2€) |DAO-Variante\r\n Debug.Print x\r\n x = CurrentDbConnection.ODBC.DLookup(\"FeldA€, \"Tabelle€, \"ID=3€) €ODBC-Variante\r\n Debug.Print x\r\n End Sub<\/pre>\n
€ADODB:\r\nPublic Function OpenRecordset(ByVal Source As String, Optional ByVal CursorType As CursorTypeEnum _\r\n = adOpenForwardOnly, Optional ByVal LockType AsLockTypeEnum = adLockReadOnly, Optional _\r\n ByVal CursorLocation As CursorLocationEnum = adUseServer) As ADODB.Recordset\r\n Dim rst As ADODB.Recordset\r\n Set rst = New ADODB.Recordset\r\n With rst\r\n .CursorLocation = CursorLocation\r\n .Open Source, Me.CurrentConnection, CursorType, LockType\r\n End With\r\n Set OpenRecordset = rst\r\nEnd Function\r\n€DAO:\r\nPublic Function OpenRecordset(ByVal Source As String, Optional ByVal RecordsetType As RecordsetTypeEnum = _\r\n dbOpenForwardOnly, Optional ByVal RecordsetOptions As RecordsetOptionEnum = dbSeeChanges, Optional ByVal _\r\n LockEdit As LockTypeEnum = dbOptimistic) As DAO.Recordset\r\n [...]\r\n Set OpenRecordset = Me.CurrentDb.OpenRecordset(Source, RecordsetType, RecordsetOptions, LockEdit)\r\nEnd Function\r\n€ ODBC:\r\nPublic Function OpenRecordset(ByVal Source As String, Optional ByVal RecordsetType As RecordsetTypeEnum = _\r\n dbOpenForwardOnly, Optional ByVal RecordsetOptions As RecordsetOptionEnum = dbSeeChanges, Optional _\r\n ByVal LockEdit As LockTypeEnum = dbOptimistic) As DAO.Recordset\r\n [...]\r\n Set OpenRecordset = Me.CurrentDbBE.OpenRecordset(Source, RecordsetType, RecordsetOptions, LockEdit)\r\nEnd Function\r\nPublic Function OpenRecordsetPT(ByVal sSQL As String, Optional ByVal RecordsetType As RecordsetTypeEnum = _\r\n dbOpenForwardOnly, Optional ByVal RecordsetOptions As RecordsetOptionEnum = dbSeeChanges Or _\r\n dbSQLPassThrough, Optional ByVal LockEdit As LockTypeEnum = dbOptimistic) As DAO.Recordset\r\n Dim qdf As DAO.QueryDef\r\n Dim rst As DAO.Recordset\r\n [...]\r\n Set qdf = Me.CurrentDb.CreateQueryDef(\"\")\r\n With qdf\r\n .Connect = Me.ConnectionString\r\n .ODBCTimeout = 0\r\n .SQL = sSQL\r\n Set rst = .OpenRecordset(RecordsetType, RecordsetOptions, LockEdit)\r\n .Close\r\n End With\r\n Set OpenRecordsetPT = rst\r\nEnd Function<\/pre>\n
Public Function OpenAdoRecordset(ByVal Source As String, Optional ByVal CursorType As CursorTypeEnum = _\r\n adOpenForwardOnly, Optional ByVal LockType As LockTypeEnum = adLockReadOnly, _\r\n Optional ByVal CursorLocation As CursorLocationEnum = adUseServer) As ADODB.Recordset\r\n Set OpenAdoRecordset = CurrentDbConnection.ADODB.OpenRecordset(Source, CursorType, LockType, CursorLocation)\r\nEnd Function<\/pre>\n
Dim dbc As DbConnectionHandler\r\nSet dbc = New DbConnectionHandler\r\ndbc.OledbConnectionString = \"Provider=SQLOLEDB;\r\nData Source=...;Initial Catalog=...;\r\nIntegrated Security = SSPI;€\r\nDebug.Print dbc.ADODB.DLookupSQL( _\r\n\"Select Count(*) FROM Tabelle WHERE\r\nFeldA like €abc%€™€)<\/pre>\n
Set Me.Recordset = CurrentDbConnection. _\r\nADODB.OpenRecordset(strSQL, adOpenDynamic, _\r\nadLockOptimistic, adUseClient)<\/pre>\n
![\"frmTest_Zugriffsvarianten.png\"](\"..\/fileadmin\/_temp_\/2009_04\/DBMS-web-images\/frmTest_Zugriffsvarian_opt.jpeg\")
<\/p>\n\n
€Zugriff auf die Database-Instanz des Frontend\r\nPublic Property Set CurrentDb(ByRef NewCurrentDb As DAO.Database)\r\nSet Me.DAO.CurrentDb = NewCurrentDb\r\nEnd Property\r\nPublic Property Get DAO() As DaoHandler\r\nIf m_DaoHandler Is Nothing Then\r\n Set m_DaoHandler = New DaoHandler\r\nEnd If\r\nSet DAO = m_DaoHandler\r\nEnd Property\r\n€ODBC-Verbindung\r\nPublic Property Let OdbcConnectionString(ByVal sConnectionString As String)\r\nMe.ODBC.ConnectionString = sConnectionString\r\nEnd Property\r\nPublic Property Get ODBC() As OdbcHandler\r\nIf m_OdbcHandler Is Nothing Then\r\n Set m_OdbcHandler = New OdbcHandler\r\nEnd If\r\nSet ODBC = m_OdbcHandler\r\nEnd Property\r\n€ADOB-Verbindung\r\nPublic Property Let OledbConnectionString(ByVal sConnectionString As String)\r\nMe.ADODB.ConnectionString = sConnectionString\r\nEnd Property\r\nPublic Property Get ADODB() As AdodbHandler\r\nIf m_AdodbHandler Is Nothing Then\r\n Set m_AdodbHandler = New AdodbHandler\r\nEnd If\r\nSet ADODB = m_AdodbHandler\r\nEnd Property<\/pre>\n
Private Sub m_DbConnection_ErrorMissingCurrentDb(ByVal Msg As String, _\r\n NewCurrentDbRef As DAO.Database)\r\n Set NewCurrentDbRef = Application.CurrentDb\r\n End Sub<\/pre>\n
Public Property Get DbConnection() As DbConnectionHandler\r\nIf m_DbConnection Is Nothing Then\r\n Set m_DbConnection = New DbConnectionHandler\r\n initDbConnection\r\nEnd If\r\nSet DbConnection = m_DbConnection\r\nEnd Property\r\nPrivate Sub initDbConnection()\r\n Set Me.DbConnection.CurrentDb = Application.CurrentDb\r\n € ... CurrentDb-Übergabe ist nicht unbedingt erforderlich,\r\n € wird bei Bedarf über Event angefordert\r\n Me.DbConnection.OdbcConnectionString = Me.ConnectionInfo.OdbcConnectionString\r\n Me.DbConnection.OledbConnectionString = Me.ConnectionInfo.OledbConnectionString\r\n End Sub\r\n€Code in frmTest_Zugriffsvarianten:\r\nPrivate Sub setSfrDataMode()\r\n Dim strTabName As String\r\n strTabName = Nz(Me!lstTab, vbNullString)\r\n Me.sfrConnTest.Form.SetDataMode Nz(Me!lstDataMode, 0), strTabName\r\n End Sub\r\n€Code in frmTest_Zugriffsvarianten_SF_Daten\r\n€(UF von frmTest_Zugriffsvarianten):\r\nPublic Sub SetDataMode(ByVal lDataMode As Long, ByVal sTabName As String)\r\n€lDataMode:\r\n€ 1 .. verknüpfte Tabelle\r\n€ 2 .. DAO-Recordset auf BE\r\n€ 3 .. DAO-Recordset von PT-Abfrage\r\n€ 4 .. ADO-Recordset auf BE\r\n[...]\r\nSelect Case lDataMode\r\nCase 1 €verknüpfte Tabelle\r\n€Recordset wieder auf DAO-Recordset setzen\r\n€.. ist erforderlich, falls zuvor ADODB-Recordset verwendet wurde\r\nIf Not Me.Recordset Is Nothing Then\r\n If TypeOf Me.Recordset Is ADODB.Recordset Then\r\n Set Me.Recordset = CurrentDbConnection.DAO.OpenRecordset(\"select * from tab1DS where 1=0€, dbOpenDynaset)\r\n Me.Recordset.Close\r\n Set Me.Recordset = Nothing\r\nEnd If\r\nEnd If\r\n€Datenbasis einstellen\r\nMe.RecordSource = sTabName\r\nMe.labDataMode.Caption = \"verknüpfte Tabelle€\r\nsetControls_DAO\r\nCase 2 €DAO-Recordset auf BE\r\nSet Me.Recordset = CurrentDbConnection.ODBC.OpenRecordset(\"select * from [\" & sTabName & \"]€, _\r\ndbOpenDynaset, dbSeeChanges)\r\nMe.labDataMode.Caption = \"DAO-Recordset auf BE€\r\nsetControls_DAO\r\nCase 3 €DAO-Recordset über PT-Abfrage\r\nSet Me.Recordset = CurrentDbConnection.ODBC.OpenRecordsetPT(\"select * from \" & sTabName, dbOpenDynaset)\r\nMe.labDataMode.Caption = \"DAO-Recordset über PT€\r\nCase 4 €ADO-Recordset auf BE\r\nstrSQL = \"select * from \" & sTabName\r\nSet Me.Recordset = CurrentDbConnection.ADODB.OpenRecordset(strSQL, adOpenKeyset, adLockOptimistic, adUseClient)\r\nMe.labDataMode.Caption = \"ADO-Recordset auf BE€\r\nsetControls_ADO\r\nCase Else\r\nMe.RecordSource = vbNullString\r\nMe.labDataMode.Caption = vbNullString\r\nEnd Select\r\nEnd Sub\r\nPublic Property Get CurrentDbConnection() As DbConnectionHandler\r\nIf m_AccessUtilsApplicationInstancer Is Nothing Then\r\n Set m_AccessUtilsApplicationInstancer = New AccUtilInstancer\r\nEnd If\r\nSet CurrentDbConnection = m_AccessUtilsApplicationInstancer.DbConnection\r\nEnd Property<\/pre>\n
€ Code im Formular frmConfig_LinkTables\r\n€ -------------------------------------\r\nPrivate WithEvents m_OdbcHandler As OdbcHandler\r\n€ Verknüpfung der bereits vorhandenen Tabellen starten:\r\nPrivate Sub startReconnectOdbc()\r\n Me.labObjectCounter.Caption = \"Tabellen\/Abfragen wurden verknüpft€\r\n Set m_OdbcHandler = CurrentDbConnection.ODBC\r\n m_OdbcHandler.RelinkTablesAndQueries CurrentConnectionInfo.SavePassword, 1\r\n End Sub\r\n€ Anzeige des Verknüpfungsvorgangs\r\nPrivate Sub m_OdbcHandler_DbObjectRelinked(ByVal LastDbObjectName As String, ByVal lCounter As Long)\r\n Me.txtLastObjectName.Value = LastDbObjectName\r\n Me.txtObjectCounter.Value = lCounter\r\n Me.Repaint €erforderlich, damit änderungen sichtbar werden\r\n End Sub\r\n€ Code im OdbcHandler-Klassenmodul\r\n€ --------------------------------\r\nPublic Event DbObjectRelinked(ByVal LastDbObjectName As String, ByVal lCounter As Long)\r\nPublic Function RelinkTablesAndQueries( Optional ByVal bSavePWD As Boolean = False, _\r\n Optional ByVal lEventCounter As Long = 0) As Boolean\r\n Dim dbs As DAO.Database\r\n Dim tdf As DAO.TableDef\r\n Dim qdf As DAO.QueryDef\r\n Dim lConnectCounter As Long\r\n Set dbs = Me.CurrentDb\r\n € Tabellen\r\n dbs.TableDefs.Refresh\r\n For Each tdf In dbs.TableDefs\r\n With tdf\r\n If Left$(.Connect, 4) = \"ODBC€ Then\r\n .Connect = Me.ConnectionString\r\n .RefreshLink\r\n [...]\r\n If lEventCounter > 0 Then €0 ... Rückgabe ist deaktiviert\r\n lConnectCounter = lConnectCounter + 1\r\n If lConnectCounter Mod lEventCounter = 0 Then\r\n RaiseEvent DbObjectRelinked(.Name, lConnectCounter)\r\n End If\r\n End If\r\n End If\r\n End With\r\nNext tdf\r\n€ Abfragen\r\n[...]\r\nRelinkTablesAndQueries = True\r\nEnd Function<\/pre>\n
Public Function OpenAdoRecordset(ByVal Source As String, Optional ByVal CursorType As CursorTypeEnum = _\r\nadOpenForwardOnly, Optional ByVal LockType As LockTypeEnum = adLockReadOnly, _\r\nOptional ByVal CursorLocation As CursorLocationEnum = adUseServer) As ADODB.Recordset\r\nSet OpenAdoRecordset = CurrentDbConnection.ADODB.OpenRecordset(Source, CursorType, LockType, CursorLocation)\r\nEnd Function<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n