<\/p>\n
Ist Ihnen der Begriff SQLite schon einmal untergekommen Wenn nicht, so ist das nicht weiter verwunderlich, handelt es sich dabei doch um ein Datenbanksystem, das Sie als Access-Benutzer wahrscheinlich nicht brauchen und viele ähnlichkeiten mit Access aufweist. Wenn doch, so könnte das der Verbreitung von Android-Smartphones und -Tablets geschuldet sein, denn unter Android ist SQLite das Standarddatenbankformat mit Systemunterstützung – die allermeisten Apps verwenden es, wenn größere Datenmengen zu speichern sind. Grund genug, dieses Format einmal genauer unter die Lupe zu nehmen.<\/b><\/p>\n
Was ist SQLite<\/b><\/p>\n
SQLite gibt es bereits seit dem Jahr 2000. Es wird im Kern von drei Programmierern weiterentwickelt, jedoch von einer großen Schar von Unterstützern mitbetreut, da der Quellcode unter Public Domain steht. Einst war es als Datenbanksystem für einige wenige Aufgaben gedacht gewesen. Statt etwa Programmeinstellungen in INI-Dateien unterzubringen, sollte die Möglichkeit bestehen, diese komfortabler in einer Datenbank zu verwalten, ohne dafür extra eine umfangreiche Datenbank-Engine installieren zu müssen. Dieser Grundgedanke – das Lite im Namen – steht auch heute noch an erster Stelle. Wenn Sie sich auf der Website von sqlite.org <\/b> die Precompiled Binaries für Windows herunterladen, sind Sie vielleicht erstaunt, dass sich lediglich zwei Dateien im ZIP-Paket befinden. Die eine davon, die Kommandozeilenanwendung sqlite3.exe<\/b>, reicht dabei schon völlig für die Verwaltung der Datenbankdateien aus.<\/p>\n
Inzwischen hat sich SQLite gemausert und steht den Möglichkeiten der Access Database Engine (vormals Jet-Engine) kaum nach. Die Größe der Datenbanken kann in die Gigabytes gehen, alle analogen Datentypen sind vorhanden, der SQL-Dialekt ist umfangreicher als der von Access und ähnelt eher dem größerer DBMS, Fremdschlüssel werden unterstützt und Mehrbenutzerzugriffe sind kein Problem. Auch Transaktionen, Views und Trigger fehlen nicht. Inzwischen sind zahlreiche Schnittstellen zu allerlei Programmierumgebungen entstanden. Viele namhafte Software-Firmen haben das Format inzwischen adaptiert und verwenden es auch jenseits Android. Um einige Programme zu nennen, die einen großen Teil ihrer Daten über SQLite verwalten: Firefox, Chrome, Skype, Dropbox, XNView.<\/p>\n
Um Missverständnisse zu vermeiden: SQLite ist ein Pendant zur Access Database Engine, nicht jedoch zu Access. Es gibt keine grafische Oberfläche wie für den Tabellenentwurf oder die Datenblatt-ansicht unter Access, sondern mit der sqlite3.exe <\/b>lediglich ein Kommandozeilen-Tool zur Anlage und Abfrage der Datenbanken, oder mit der sqlite3.dll <\/b>eine Programmierschnittstelle, die per API angesprochen werden muss. Wer eine grafische Verwaltung haben will, der benötigt separate Editoren, von denen allerdings zahlreiche vorhanden sind. Dazu später mehr.<\/p>\n
Eine SQLite-Datenbank besteht aus nur einer Datei, die üblicherweise die Endung .sqlite <\/b>oder .db <\/b>aufweist, so, wie bei Access auch nur eine .mdb<\/b>– oder .accdb<\/b>-Datei nötig ist. Intern kann die Datei allerdings mehrere Datenbanken enthalten, wovon die eigentlich genutzte meist den Namen main <\/b>trägt, während die anderen Systemdatenbanken sind. Darunter befinden sich die Tabellen, die relational miteinander verknüpft sein können. Dabei können Fremdschlüsselbeziehungen angelegt oder Beschränkungen (Constraints) definiert werden. Beziehungen zwischen mehreren Datenbankdateien, so wie gelinkte Tabellen unter Access, sind jedoch nicht direkt möglich. Views schließlich dienen der gefilterten Ausgabe der Tabellendaten. SQLite-Views sind im Unterschied zu den meisten DBMS aber nicht aktualisierbar.<\/p>\n
Eine umfassende Darstellung des Formats und seiner Features kann an dieser Stelle nicht gegeben werden. Schauen Sie sich bei Interesse die durchaus gelungene Dokumentation auf der Seite der Herausgeber an. Betrachten wir eher, was wir unter Access mit SQLite anfangen können.<\/p>\n
SQLite und Access<\/b><\/p>\n
Wie kommen die Daten einer SQLite-Datenbank in oder zu Access Eine direkte Verknüpfung ist zunächst nicht möglich, da hierfür der entsprechende ISAM-Treiber fehlt. Per Code könnten Sie die sqlite3.dll <\/b>ansprechen, benötigten dafür aber API-Deklarationen, die Sie für VB(A) vergeblich suchen werden. Zum Glück ist das aber überflüssig, da Olaf Schmidt mit dem vbRichClient <\/b>eine kostenlose Schnittstelle zur Verfügung stellt, deren Programmierung fast identisch zu der von DAO oder ADO ist.<\/p>\n
ODBC<\/b><\/p>\n
Um eine Datenbank eines fremden DBMS direkt in Access zu bekommen, braucht es einen ODBC-Treiber, wie ihn etwa der MS SQL-Server oder MYSQL mitbringen. Auch für SQLite existieren ODBC-Treiber, wobei sich jener von Christian Werner quasi zum Standard entwickelt hat. Andere Treiber sind meist Modifikationen seines Treibers, der im Quellcode veröffentlicht ist. Laden Sie sich also das Installationspaket von dessen Seite herunter und starten das Setup.<\/p>\n
Danach finden Sie im ODBC-Datenquellen-Administrator von Windows einen neuen Eintrag SQLite3 ODBC Driver <\/b>auf der Treiberseite, wie in Bild 1. Den Datenquellen-Administrator finden Sie in den neueren Windows-Versionen über Startmenü|Verwaltung|Daten-quellen (ODBC)<\/b>.<\/p>\n
![\"Der](\"..\/fileadmin\/_temp_\/2014_04\/01_ODBCAdmin.png\")
<\/p>\n
Bild 1: Der ODBC-Datenquellen-Administrator von Windows mit der Liste installierter Treiber<\/span><\/b><\/p>\n Um anschließend eine neue Datenquelle (DSN) zu einer SQLite-Datenbank im Administrator anzulegen, öffnen Sie die Seite Benutzer-DSN<\/b>, klicken Hinzufügen <\/b>an und wählen dann den neuen Treibereintrag aus. Ein Klick auf Fertig stellen <\/b>führt zum Konfigurationsdialog des Treibers (s. Bild 2). Die Voreinstellungen des Dialogs können Sie zunächst getrost übernehmen. Essentiell sind jedoch zwei Einträge: Unter Database Name <\/b>geben Sie den Pfad zur SQLite-Datei an, den Sie auch über die Schaltfläche Browse <\/b>ermitteln können. Was dann passiert, hängt aber vom Kontrollkästchen Don“t create Database <\/b>ab. Ist hier kein Häkchen gesetzt, so wird nach dem Klick auf OK <\/b>automatisch eine leere SQLite-Datei erstellt, falls die angegebene Datei noch nicht existiert. Ansonsten wird eine Verbindung zur bestehenden Datei hergestellt. Ist das Häkchen gesetzt, so wird keine leere Datei angelegt. Existiert die angegebene dann Datei nicht, so erfolgt beim Verbinden eine Fehlermeldung des Treibers. Lassen Sie für unseren Test, abweichend zur Abbildung, das Häkchen weg. Die wichtigsten weiteren Parameter des Dialogs:<\/p>\n Bild 2: Konfiguration einer SQLite-ODBC-Verbindung (DSN)<\/span><\/b><\/p>\n Nachdem Sie den Dialog mit OK<\/b> bestätigt haben, finden Sie in der Liste der Benutzerdatenquellen den Eintrag, den Sie im Dialog unter Data Source Name <\/b>vergeben hatten.<\/p>\n Import\/Export<\/b><\/p>\n Schreiten Sie nun zur Tat und öffnen eine beliebige Access-Datenbank, etwa die Demodatenbank sqlite_demo.mdb <\/b>zu diesem Beitrag. Markieren Sie eine Tabelle, in unserem Test die Tabelle tblTest<\/b>, und gehen Sie dann unter Access 2003 und früher auf Datei|Exportieren<\/b>, wählen als Dateityp ODBC-Datenbanken() <\/b>und geben einen neuen Namen für die zu exportierende Tabelle an.<\/p>\n Verwenden Sie hier tblTest2<\/b>. Unter Access 2007 und neuer öffnen Sie stattdessen das Kontextmenü der Tabelle, gehen auf Exportieren|ODBC-Datenbank<\/b>.<\/p>\n Anschließend öffnet sich der Datenquellendialog, in dem Sie unter Computerdatenquellen <\/b>die zuvor angelegte SQLite-Verbindung auswählen. Im Normalfall sollte die Aktion nun erfolgreich quittiert werden – schon haben Sie eine Access-Tabelle nach SQLite transferiert.<\/p>\n Interessant ist, dass dies selbst bei Tabellen mit Anlagefeldern fehlerfrei funktioniert – versuchen Sie es etwa mit der versteckten Systemtabelle MsysResources <\/b>unter Access 2010. Allerdings werden Sie anschließend mit dem Anlagefeld, welches als Memofeld in die SQLite-Datei exportiert wurde, nicht viel anfangen können. Dort steht dann nur der Name der Anlage, nicht aber deren Binärdaten.<\/p>\n Nachdem die Tabelle exportiert wurde, kommt jetzt der umgekehrte Vorgang. Wir möchten die Tabelle fürs Erste aber nicht reimportieren, sondern eine Verknüpfung zu ihr anlegen. Dazu gehen Sie unter Access 2003 auf Datei|Externe Daten|Tabellen verknüpfen <\/b>und wählen wieder ODBC-Datenbanken()<\/b>.<\/p>\n Unter Access 2007 und neuer wählen Sie den Ribbon-Eintrag Externe Daten|ODBC-Datenbank|Verknüpfen<\/b>. Nach Auswahl der SQLite-Verbindung sollten Sie mit einem Dialog konfrontiert werden, der die enthaltenen Tabellen anzeigt.<\/p>\n Lief im vorherigen Schritt alles glatt, dann sollte hier die Tabelle tblTest2 <\/b>aufgeführt sein. Markieren Sie diese und klicken Sie auf OK <\/b>– schon finden Sie die per ODBC verknüpfte Tabelle im Datenbankfenster oder Navigationsbereich vor.<\/p>\n Nun wird es spannend: was ist beim Export und Import aus den Feldern der ursprünglichen Tabelle geworden Die tblTest <\/b>enthält alle Feldtypen, die bis Access 2007 möglich waren. öffnen Sie die Tabellen tblTest <\/b>und tblTest2 <\/b>parallel im Entwurf, sodass Sie das Schema vergleichen können – siehe Bild 3. <\/p>\n Bild 3: Originale Testtabelle unter Access und das ODBC-verknüpfte Pendant aus SQLite rechts im Entwurf<\/span><\/b><\/p>\n <\/p>\n Tatsächlich sind die Felddefinitionen bis auf einige Ausnahmen identisch. Das ID-Feld wurde mit Long<\/b>-Wert korrekt als Primärschlüssel übernommen. Der Autowert funktioniert ebenfalls, auch wenn er im Entwurf so nicht angezeigt wird. Abweichungen gibt es bei der GUID, die unter Access als Zahl\/Replikations-ID definiert ist. In SQLite wurde diese als Binärfeld angelegt, was im Entwurf durch den Feldtyp OLE-Objekt<\/b> ersichtlich wird.<\/p>\n Das ist sicherlich tragbar, wird dieser Feldtyp doch sehr selten verwendet. Bei Dezimalfeld kam es zur Konvertierung in ein Memo-Feld, also ein Textfeld mit mehr als 255 Zeichen.<\/p>\n Auch das ist zu verschmerzen, da der Dezimaltyp ohnehin weitere Angaben zur Genauigkeit und zur Kommaposition braucht. Der Single-Type kommt als Double zurück, was ebenfalls akzeptiert wird. Weniger Toleranz sollte dagegen die Wandlung von Währung in Memo erfahren. Zwar ist der Sachverhalt hier ähnlich, wie beim Dezimalfeld, jedoch lässt sich mit einem Memofeld schlecht rechnen. Zur Erläuterung finden Sie im Absatz zu den SQLite-Datentypen weitere Informationen.<\/p>\n Dass schließlich der proprietäre Typ Hyperlink <\/b>nach Memo <\/b>umgewandelt wird, ist nicht erstaunlich. Was außerdem fehlt, sind Standardwerte, die für Felder unter Access vergeben wurden. <\/p>\n Zusammenfassend lässt sich feststellen, dass der Export\/Import-Vorgang zwar brauchbar ist, jedoch verbesserungswürdig. Dazu kommen zwei Lösungen infrage: entweder Sie modifizieren die SQLite-Felder nach Export mit einem SQLite-Editor Ihrer Wahl, oder Sie legen die Tabellen gleich per VBA-Code als DDL-SQL-Anweisungen selbst an. Dazu finden sie in der Demodatenbank einige Routinen, die später gesondert besprochen werden.<\/p>\n Machen wir als Nächstes den Test, was aus den Feldinhalten geworden ist. öffnen Sie dazu die beiden Tabellen übereinander, wie in Bild 4.<\/p>\n Bild 4: Anzeige der Daten aus originaler und verknüpfter Tabelle<\/span><\/b><\/p>\n Mit dem Ergebnis kann man zufrieden sein. Allerdings schleichen sich beim Single-Feld offenbar Rundungsfehler ein. Dasselbe gilt übrigens für alle Fließkommazahlentypen, auch wenn das aus der Abbildung nicht hervorgeht.<\/p>\n Es betrifft also alle Felder vom Type Single<\/b>, Double <\/b>und Currency<\/b>. Erfreulich ist, dass offenbar auch das OLE-Objekt korrekt übernommen wurde: ein Doppelklick auf die Zelle öffnet das Icon, das in ihm verborgen ist. Wenn Sie mit den Datensätzen der verknüpften SQLite-Tabelle spielen, werden Sie bald feststellen, dass es zu seltsamen Fehlermeldungen kommt, ohne dass diese so einfach nachzuvollziehen wären.<\/p>\n Einmal funktioniert das Editieren nicht, dann doch, und das Löschen der Datensätze scheint ebenfalls dem Zufallsprinzip zu unterliegen. Meist erscheint die Fehlermeldung aus Bild 5.<\/p>\n Bild 5: Fehlermeldung beim Löschen von Datensätzen in der ODBC-verknüpften Tabelle<\/span><\/b><\/p>\n Wer ist der andere Benutzer, der dieselben Daten verändern will, und das gar beim Löschen Die Begründung für diese missverständliche Fehlermeldung liegt in den Untiefen der Access Database Engine verborgen.<\/p>\n Ich ließ einen ODBC-Trace während des Löschvorgangs loggen. Ein ODBC-Trace ist ein genaues Protokoll der Vorgänge zwischen Client und Server, hier also Access und dem SQLite-Treiber.<\/p>\n Es lässt sich im ODBC-Administrator über Aktivierung der Ablaufverfolgung anlegen. Eine Analyse der Logs ergab, dass Access beim Löschen und Editieren den entsprechenden Datensatz über eine Kombination fast aller Felder zu ermitteln versucht, statt den Primärschlüssel heranzuziehen, warum auch immer.<\/p>\n Die entscheidende Zeile im Protokoll sieht so aus:<\/p>\n Da aber die Rundungsfehler beim Double- und Singlefeld dazu führen, dass Abweichungen zu den Werten entstehen, die Access in der Tabellenansicht gespeichert hat, geht Access davon aus, dass die entsprechenden Daten mittlerweile von anderer Seite geändert wurden, und hält den Löschvorgang an.<\/p>\n Wir kommen deshalb nicht umhin, uns mit den SQLite-Datentypen zu beschäftigen.<\/p>\n SQLite Datentypen<\/b><\/p>\n Zwar können unter SQLite zahlreiche Feldtypen definiert und für diese wiederum diverse Parameter eingestellt werden, doch intern gibt es lediglich vier sogenannte Storage<\/b>-Klassen. Das sind Integer<\/b>, Real<\/b>, Text <\/b>und Blob<\/b>. Real <\/b>ist dabei ein Fließkommawert mit 8 Bytes.<\/p>\n Das bedeutet, dass jeglicher Datentyp auf einen dieser Grundtypen gecastet werden muss.<\/p>\n SQLite nimmt diese Konvertierung selbst vor, wobei die eigentliche Felddefinition herangezogen wird. Genaueres dazu erfahren Sie auf der Seite zu Data Types <\/b>auf sqlite.org<\/b>. Dort finden Sie eine Zuordnungsmatrix der Feldtypen zu den Grundklassen.<\/p>\n Diesen Umstand zu kennen, ist zweifellos wichtig, wenn es um die Interaktion von Access mit SQLite geht.<\/p>\n Es leiten sich daraus einige Regeln ab, die zu beherzigen sind.<\/p>\n Alles in allem ist die Verbindung Access-SQLite nicht ganz so trivial, wie die zu anderen DBMS. Die Tabellen einer SQLite-Datenbank einfach verknüpfen und die Daten unter Access in Datenblättern und Formularen verwalten, reicht nicht aus. Der ODBC-Treiber ist nicht ganz konform mit der Access Database Engine. Um zusätzliche Programmierung und Workarounds kommen Sie nicht herum, wenn Sie die Datenintegrität sicherstellen wollen. Beispiel: Das Löschen eines Datensatzes, was in der Datenblattansicht schiefgeht, lässt sich problemlos mit folgender Code-Zeile bewerkstelligen:<\/p>\n Programmierung<\/b><\/p>\n Im Vorhergehenden hatten Sie die SQLite-Tabellen manuell mit Access verknüpft. Das geht jedoch auch per Code, und zwar mit der Anweisung DoCmd.TransferDatabase<\/b>. Dieser können Sie als Parameter den ODBC-Connection-String übergeben, statt eine angelegte DSN zu verwenden. Alle Versuche dieser Art schlagen aber fehl. Access quittiert die Anweisung mit der Fehlermeldung -7778<\/b>, „Es gibt keine Meldung für diesen Fehler“, obwohl der Treiber geladen wird. Sie können das im Modul mdlSQLiteODBC<\/b>, Prozedur LinkSQLiteTable <\/b>der Demo-Datenbank nachstellen.<\/p>\n Die Lösung ist, zunächst eine manuelle Verknüpfung anzulegen und später beim Aktualisieren der Verknüpfung über das TableDef<\/b>-Objekt nur den Connect<\/b>-String zu ändern:<\/p>\n ADO<\/b><\/p>\n Aus der Sicht des Access-Programmierers sind die Möglichkeiten beschränkt, wenn es um ODBC-Datenbanken unter DAO geht. Konnte man unter Access 2003 noch über das Connection-Objekt von DAO aus direkten Zugriff auf ODBC-Objekte erhalten, so wie das PassThrough-Abfragen ermöglichen, scheidet diese Methode seit Access 2007 aus.<\/p>\n In der Access Database Engine wurde das Connection<\/b>-Objekt gestrichen. Daher ist nun ADODB das Mittel der Wahl<\/p>\n Für eine Verbindung per ADODB ist ein entsprechender ADO-Provider nötig. Es existieren zwar native SQLite-Provider, doch sind diese entweder nicht kompatibel mit SQLite 3 oder sie arbeiten wenig vertrauenswürdig. Deshalb verwenden Sie besser den ODBC-Provider, der wiederum auf unseren ODBC-Treiber von C. Werner aufsetzt.<\/p>\n Ein rudimentärer ConnectionString für ein ADO-Connection-Objekt sieht so aus:<\/p>\n Die Angaben sind der ADO-Provider für ODBC, der SQLite-ODBC-Treiber, die SQLite-Version und der Pfad zur SQLite-Datei. Nachdem die Verbindung über Connection.Open <\/b>zustande kam, können Sie über Connection.Execute <\/b>beliebige SQL-Anweisungen absetzen:<\/p>\n über die erste Anweisung wird eine SQLite-Tabelle erzeugt. Mit der zweiten wird die SQLite-Datei komprimiert. Das ist übrigens exakt der gleiche Vorgang, den Sie von Access und dem „Komprimieren und Reparieren“-Befehl her kennen. Auch SQLite-Dateien können sich nach umfangreichen Datenoperationen aufblähen.<\/p>\n vbRichClient<\/b><\/p>\n Der rührige Olaf Schmidt stellt mit seiner Bibliothek vbRichClient5 <\/b>eine Freeware-Lösung für den Umgang mit SQLite-Dateien zur Verfügung. Die Bibliothek enthält weitaus mehr als nur Datenbankobjekte. Wir verwenden sie jedoch nur dafür. Es handelt sich um eine ActiveX-DLL, die registriert und in die Verweise der Access-Datenbank gelinkt werden muss, um Objekte wie cConnection<\/b>, cRecordset<\/b>, cCommand <\/b>verwenden zu können, die allesamt ähnlich angesprochen werden, wie die ADO-Pendants. Im gleichen Verzeichnis der DLL sollte sich zudem die neueste Version der sqlite3.dll <\/b>befinden.<\/p>\n Der Vorteil dieser Lösung ist, dass sich über die Methoden und Properties dieser Library vieles ansprechen und einstellen lässt, was über ADO nur über umständliche SQL-Anweisungen möglich ist.<\/p>\n Schauen Sie sich etwa die Liste der Funktionen des CConnection<\/b>-Objekts im Objektkatalog von VBA an.<\/p>\n Sie können da etwa die Grundeinstellungen einer neu erzeugten SQLite-Datenbank vorgeben, Transaktionen steuern, Datentypen umwandeln oder den zuletzt vergebenen Autowert ermitteln lassen.<\/p>\n Sollten Sie in ihrer Systemumgebung nicht die Möglichkeit haben, ActiveX-Bibliotheken registrieren zu lassen, so bietet Olaf Schmidt mit seiner DirectCom-Schnittstelle eine Lösung an, um an die Bibliothek auch über eine Handvoll API-Deklarationen heranzukommen. Die Darstellung dieser Lösung kann im Rahmen dieses Beitrags leider nicht erfolgen.<\/p>\n SQLite-Editoren<\/b><\/p>\n Man kann über die Oberfläche von Access keine änderungen an SQLite-Datenbanken vornehmen. über SQL-Anweisungen und den Zugriff über ADO oder den vbRichClient <\/b>geht es zwar, es ist jedoch alles andere als komfortabel.<\/p>\n Deshalb sollten Sie sich einen der Freeware-Editoren zulegen, die über die Links bis zu finden sind. Viele dieser Editoren sind in ihrem Umfang mit den Verwaltungsoberflächen anderer DBMS zu vergleichen.<\/p>\n Mein Favorit ist derzeit der SQLite Expert wegen seiner aufgeräumten Oberfläche und der Möglichkeit, mehrere Datenbanken parallel zu bearbeiten. Aber auch das Firefox Addon (!) SQLite Manager macht eine gute Figur. Mit diesem können Sie zudem direkten Einblick in die Systemtabellen des Firefox erhalten.<\/p>\n Im Download zum Beitrag befindet sich außerdem ein einfacher SQLite-Editor, der von der Demo-Datenbank direkt aufgerufen wird, der sqlite3explorer<\/b>. Es handelt sich bei ihm um lediglich eine Exe-Datei, die keine Installation erfordert.<\/p>\n SQLite und Android<\/b><\/p>\n Dass SQLite unter Android das Standarddatenbankformat ist, wurde bereits erwähnt. Insofern bekommt der Austausch von Daten zwischen Access und Android-Smartphones zusätzliche Bedeutung. Da es bisher keine wirklich gute App für die Anzeige von Access-Datenbanken gibt, ist der Weg über einen SQLite-Export ein geeignetes Mittel.<\/p>\n Umgekehrt werden Sie überrascht sein, wie viele SQLite-Datenbanken sich auf Ihrem Gerät befinden. Machen Sie etwa ein Komplett-Backup des Geräts auf Ihren Rechner über Software wie das Samsung-Kies <\/b>oder den MyPhoneExplorer <\/b>und lassen Sie die Routine FindSQLite<\/b>-Files aus der Demo-Datenbank darüber laufen, auf die wir noch zu sprechen kommen.<\/p>\n Ob Bildverwaltungen, Music Player, GPS-Anwendungen: fast alle speichern ihre Daten in SQLite-Datenbanken.<\/p>\n Um Inhalte von SQLite-Datenbanken auf Android-Geräten anzuzeigen oder gar zu verwalten, bedienen Sie sich einer der Apps, die beispielhaft unter – aufgeführt sind. Mein Favorit hier ist der aSQLiteManager Lite<\/b>, sowohl von der Bedienung her, wie von den Features.<\/p>\n Die Beispieldatenbank<\/b><\/p>\n Sie finden in der Demo-Datenbank sqlite_demo.mdb <\/b>einige Module, die den Zugriff auf SQLite-Datenbanken verdeutlichen. An dieser Stelle können sie nur kurz umrissen werden. Vertiefen Sie sich bei Interesse in den Code.<\/p>\n Im Modul mdlSQLiteODBC <\/b>finden Sie eine Routine, die über ADO und ODBC unsere Tabelle tblTest2 <\/b>korrekt erstellt (TestCreateSQLiteODBC<\/b>). Außerdem eine, die den richtigen Connection<\/b>-String für die ODBC-Verbindung produziert (ConnectionStringSQLite<\/b>). Und weiter eine Prozedur, die den Link zu einer SQLite-Datei aktualisiert, und eine, die den Aufbau der Datenbank über die ADO-Methode OpenSchema <\/b>ausgibt (TestSQLiteSchema<\/b>).<\/p>\n Im Modul mdlSQLiteRichClient <\/b>finden sich ähnliche Prozeduren, nur dass diese über die Bibliothek vbRichClient <\/b>abgewickelt werden.<\/p>\n Eine bereits angesprochene Lösung enthält das Modul mdlTest<\/b>. Rufen Sie hier die Prozedur FindSQLiteFiles <\/b>über das VBA-Direktfenster auf. Sie durchläuft alle Dateien im Verzeichnis der Wahl inklusive der Unterverzeichnisse und findet heraus, bei welchen davon es sich um SQLite-Datenbanken handelt.<\/p>\n Vor allem im Benutzerprofilverzeichnis AppData werden Sie fündig werden. SQLite-Dateien sind sehr einfach zu identifizieren: Am Anfang der Datei steht binär einfach der String „SQLite format 3“.<\/p>\n Beim Durchlaufen der Dateien werden alle Fundstellen in der Tabelle tblSampleFiles <\/b>abgespeichert, die am Schluss über das Formular frmSampleFiles <\/b>zur Ansicht gelangen, wie in Bild 6.<\/p>\n Bild 6: Demo-Datenbank: Formular mit der Liste aller gefundenen SQLite-Datenbanken unter AppData<\/span><\/b><\/p>\n Der Clou am Formular: Doppelklicken Sie einfach auf einen Pfadeintrag, und schon öffnet sich der SQLite3Explorer mit den Infos zur SQLite-Datei – s. Bild 7.<\/p>\n Bild 7: Aufruf des SQLite3Explorers durch Doppelklick auf Eintrag im Formular<\/span><\/b><\/p>\n Die zweite Anwendung der Beispieldatenbank finden Sie über den Aufruf des Formulars frmBookmarks<\/b>.<\/p>\n Hier werden Sie zunächst mit einer leeren Oberfläche konfrontiert. Sollten Sie Firefox nicht installiert haben, dann können Sie das Formular nun wieder schließen, denn es geht in ihm darum, die Lesezeichen des Browsers zu ermitteln.<\/p>\n Nach Klick auf den Button oben öffnet sich erst ein zusätzliches Formular, das die im Benutzersystem gefundenen Firefox-Profile zur Auswahl anbietet (s. Bild 8).<\/p>\n Bild 8: Auswahl des Firefox-Profils vor dem Import im Formular frmFirefoxBookmarks<\/span><\/b><\/p>\n Diese Profile ergeben sich aus der Verzeichnisstruktur unter (AppData)\\Mozilla\\Firefox\\Profiles<\/b>. Der eigentliche Vorgang läuft dann nach Bestätigen des Dialogs mit OK <\/b>ab. Die SQLite-Datei places.sqlite <\/b>im Profilverzeichnis wird geöffnet und die drei Tabellen moz_bookmarks<\/b>, moz_places <\/b>und moz_favicons <\/b>zum Aufbau des Lesezeichenbaums herangezogen, um anschließend das Treeview des Formulars zu befüllen. Dabei kommt die vbRichClient<\/b>-Bibliothek im Modul mdlFirefox <\/b>zum Einsatz. Selbst die Icons der Lesezeichen werden generiert, wobei dies ohne Umweg über das Dateisystem über unser viel genutztes Modul mdlGDIPlus <\/b>und dessen Funktion ArrayToPicture <\/b>geschieht. Sie können nach Abschluss den Root-Node des Treeviews ausklappen und auf einen Eintrag des Lesezeichenbaums klicken, um die Website im rechts daneben befindlichen Webbrowser-Control aufzurufen (s. Bild 9). <\/p>\n![\"Konfiguration](\"..\/fileadmin\/_temp_\/2014_04\/02_ODBCDialog.png\")
<\/p>\n\n
![\"Originale](\"..\/fileadmin\/_temp_\/2014_04\/03_tblTest_orig_linked1.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_04\/04_tblTest_orig_linked2.png\")
<\/p>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2014_04\/05_error_dlg_deletion.png\")
<\/p>\nDELETE FROM \"tblTest2\" WHERE \"ID\" = AND \"TextFeld\" = ''Sascha Trowitzsch'' AND \"LongFeld\" = 1 \r\nAND \"IntFeld\" = 1 AND \"DoubleFeld\" = 1.2 AND \"SingleFeld\" = 1.29999995231628 AND \"ByteFeld\" = 5 \r\nAND \"BoolFeld\" = AND \"DateFeld\" = {ts ''2015-02-01 08:44:00''}<\/pre>\n\n
CurrentDb.Execute \"DELETE FROM tblTest WHERE ID=2\"<\/pre>\n
sConx = \"ODBC;Driver={SQLite3 ODBC Driver}; Database=c:\\irgendwas\\test_sqlite.db;\"\r\nCurrentDb.TableDefs(\"tblTest2\").Connect = sConx\r\nCurrentDb.TableDefs.Refresh<\/pre>\n\"Provider=MSDASQL.1;Driver={SQLite3 ODBC Driver};Version=3;Database= c:\\irgendwas\\test_sqlite.db;\"<\/pre>\noConnection.Execute \"CREATE TABLE tblTest2 (...)\"\r\noConnection.Execute \"VACUUM;\"<\/pre>\n
![\"Demo-Datenbank:](\"..\/fileadmin\/_temp_\/2014_04\/06_frmSamplefiles.png\")
<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2014_04\/07_SQLiteExplorer.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2014_04\/08_FirefoxBookmarksDialog.png\")
<\/p>\n![\"Darstellung](\"..\/fileadmin\/_temp_\/2014_04\/09_FirefoxBookmarks.png\")
<\/p>\n