android sqlite tabelle_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 3: Eine Tabelle in der SQLite Datenbank erstellen


In der dritten Lektion unseres mehrteiligen Android SQLite Tutorials werden wir eine Tabelle in unserer SQLite Datenbank erstellen.

Dazu werden wir Veränderungen an drei Klassen unseres SQLite Projekts vornehmen. Doch bevor wir mit dem Programmieren beginnen, werden wir uns damit beschäftigen, wie man eine Tabelle in die Android SQLite Datenbank einfügt.

Dabei betrachten wir auch, was sich hinter den Kulissen abspielt. Also welche Schritte im Android System beim Erstellen der Tabelle im Hintergrund ablaufen.

Anschließend werden wir in der Klasse ShoppingMemoDbHelper die Eigenschaften unserer SQLite Datenbank und der zu erstellenden Tabelle definieren.

Danach stellen wir in der ShoppingMemoDataSource-Klasse eine Verbindung zu unserer SQLite Datenbank her. Dabei wird automatisch vom Android System die Tabelle nach unseren Vorgaben erstellt. Mehr dazu im dritten Abschnitt.

Um die Änderungen an dem Quellcode zu testen, werden wir von der MainActivity-Klasse aus auf die DataSource zugreifen. Dazu fügen wir den notwendigen Testcode in die Klasse MainActivity ein.

Somit werden wir folgende Arbeitsschritte in dieser Lektion des SQLite Tutorials ausführen:

  1. Definieren der Eigenschaften unserer Datenbank in der ShoppingMemoDbHelper-Klasse.
  2. Herstellen der Verbindung zur SQLite Datenbank in der ShoppingMemoDataSource-Klasse.
  3. Öffnen der Datenquelle und Zugriff auf die Datenbank in der MainActivity-Klasse

Nun wünschen wir euch viel Spaß bei Teil 3 unseres Android SQLite Datenbank Tutorials. Los geht’s!

1. Wie man eine Tabelle in einer Android SQLite Datenbank erstellt

Natürlich gibt es viele verschiedene Wege eine Tabelle in einer Android SQLite Datenbank zu erstellen. Der hier gezeigte Weg, ist nur einer von vielen.

Wir haben ihn gewählt, da er oft verwendet wird und zudem leicht verständlich ist.

Um ihn umzusetzen, benötigen wir als Hilfsmittel die Klasse SQLiteOpenHelper aus dem Package android.database.sqlite. Wir verwenden diese Klasse zum Anlegen und Öffnen einer SQLite Datenbank in unserer Android Anwendung.

Doch bevor wir sie verwenden können, müssen wir eine eigene Klasse von ihr ableiten und in dieser unsere Datenbank-Operationen vorgeben.

Den ersten Schritt dazu haben wir bereits in der vorherigen Lektion ausgeführt und unsere Klasse ShoppingMemoDbHelper von der SQLiteOpenHelper-Klasse abgeleitet. Doch bisher geben wir in der abgeleiteten Klasse noch keine auszuführenden Datenbankanweisungen vor.

Dies werden wir im nächsten Kapitel nachholen. Doch vorher betrachten wir noch kurz was beim Anlegen der SQLite Datenbank im Hintergrund abläuft, um besser verstehen zu können, an welcher Stelle im Code es sinnvoll ist die Anweisung für das Erzeugen einer Tabelle einzufügen.

1.1 Was passiert wenn eine Datenbank angefragt bzw. erzeugt wird?

Um eine SQLite Datenbank anzufragen bzw. zu erzeugen, müssen wir den Konstruktor der Super-Klasse SQLiteOpenHelper aufrufen. Der Konstruktor benötigt Informationen über die Datenbank (Datenbankname) und die Umgebung (meist die Activity), in der die SQLite Datenbank ausgeführt wird.

Nachdem der Konstruktor der Super-Klasse ausgeführt wurde, können wir SQL-Befehle mit der Methode execSQL() auf der Datenbank ausführen lassen. Dazu benötigen wir aber noch eine Referenz auf die angelegte Datenbank.

Mit den beiden geerbten Methoden getWritableDatabase() und getReadableDatabase() können wir diese Datenbank-Referenz anfragen. Da wir nicht nur lesend sondern auch schreibend auf unsere SQLite Datenbank zugreifen möchten, lassen wir uns mit der Methode getWritableDatabase() die Referenz auf das Datenbankobjekt liefern. Das Objekt ist vom Datentyp SQLiteDatabase.

Nun geschieht das Wichtige. Beim Aufruf der getWritableDatabase()-Methode wird vom Android System geprüft, ob die Datenbank bereits existiert. Falls die im Konstruktor angegebene Datenbank schon vorhanden ist, wird diese geöffnet und die zugehörige Referenz zurückgegeben.

Falls die Datenbank noch nicht existiert, wird diese jetzt neu angelegt und dazu die Methode onCreate() unserer Hilfsklasse ShoppingMemoDbHelper ausgeführt. Sie ist eine der beiden geerbten Methoden, die wir in der vorherigen Lektion überschreiben mussten. Die andere Methode ist onUpgrade().

Da eine Datenbank ohne Tabelle keinen Sinn ergibt, ist die onCreate()-Methode unserer abgeleiteten Hilfsklasse ShoppingMemoDbHelper genau die Stelle in unserem Quellcode, an der wir unsere Tabelle erzeugen lassen.

Dies erfolgt durch einen SQL-String, der vorgibt, welchen Namen die Tabelle trägt und welche Spalten (mit Angabe des SQL-Datentyps) sie besitzt.

1.2 Erstellen einer Tabelle in die SQLite Datenbank

Auf die Datenbanksprache SQL werden wir in diesem Tutorial nicht eingehen. Wir werden aber die verwendeten SQL-Kommandos zum besseren Verständnis erklären. Wenn ihr mehr über SQL erfahren möchten, könnt ihr hier nachschauen: http://sqlzoo.net.

Nun zurück zur Tabelle.

Die Tabelle werden wir mit dem folgenden SQL-String in die SQLite Datenbank einfügen:


Der obere SQL-Code bedeutet für das SQLite Datenbanksystem Folgendes:

  • Eine Tabelle mit dem, in der Konstante TABLE_SHOPPING_LIST gespeicherten, Namen soll angelegt werden.
  • Die Tabelle soll aus drei Spalten bestehen.
  • Spalte 1 wird als Namen den Wert der Konstante COLUMN_ID tragen und als Primärschlüssel fungieren. Mit AUTOINCREMENT geben wir vor, dass die nächste ID automatisch um 1 erhöht wird. INTEGER gibt den SQL-Datentyp vor, also wird die ID als ganzzahliger Wert gespeichert.
  • Spalte 2 wird als Namen den Wert der Konstante COLUMN_PRODUCT tragen und den eingegebenen Produktnamen als eine Zeichenkette speichern. Mit NOT NULL legen wir fest, dass in jedem Datensatz hier ein Wert eingetragen sein muss.
  • Spalte 3 wird als Namen den Wert der Konstante COLUMN_QUANTITY tragen und die zu kaufende Menge als ganzzahligen Wert speichern. Auch diese Zelle muss immer befüllt werden.

Den eben beschriebenen SQL-String übergeben wir später der Methode execSQL(), die wir auf dem Datenbankobjekt aufrufen können, und lassen dadurch die Tabelle erstellen.

Der Aufruf würde dann bspw. auf diese Art erfolgen:


Da wir nun wissen, wo wir das Erstellen der Tabelle vornehmen (in der onCreate() Methode) und auch den SQL-String zum Erzeugen der Tabelle kennen, werden wir unsere neu erlangten Kenntnisse in der Praxis anwenden und im nächsten Abschnitt unsere Tabelle in die SQLite Datenbank einfügen.

2. Definieren der Eigenschaften unserer SQLite Datenbank und Tabelle in der ShoppingMemoDbHelper-Klasse

Das Erstellen der Tabelle kann mit einer einzigen Anweisung erfolgen. Dies ist aber nicht empfehlenswert, da die Arbeit mit der Tabelle und der SQLite Datenbank dann sehr fehleranfällig wird.

Um sauber mit der Tabelle und der SQLite Datenbank arbeiten zu können, werden wir einige String-Konstanten in der Klasse ShoppingMemoDbHelper definieren.

In den Konstanten sind wichtige Eigenschaften der Datenbank und Tabelle gespeichert. Da die Konstanten als public deklariert werden, können wir so auch von anderen Klassen auf die Eigenschaften der Datenbank und Tabelle zugreifen.

Dieser Weg wirkt zu Beginn etwas umständlich und aufgeblasen, bei der späteren Arbeit mit der Datenbank möchte man die Datenbank-Konstanten aber nicht mehr missen. Sie erleichtern den Zugriff und stellen das akkurate Arbeiten mit der SQLite Datenbank sicher.

Das Erzeugen der Tabelle wird durch die folgenden drei Arbeitsschritte realisiert:

  1. String-Konstanten anlegen – sie enthalten die wichtigen Eigenschaften der Tabelle und Datenbank.
  2. Aufruf des Super-Konstruktors anpassen – wir ersetzen den bisherigen Beispielaufruf durch einen Aufruf mit echten Werten, durch Zuhilfenahme der String-Konstanten.
  3. Tabelle in onCreate() Methode erzeugen – wir definieren die onCreate() Methode und lassen den SQL-String mit execSQL() darin ausführen.

Wir werden jetzt die Arbeitsschritte der Reihe nach ausführen. Sollte etwas unklar sein, könnt ihr am Ende dieses Abschnitts den gesamten Quellcode der Klasse ShoppingMemoDbHelper in Ruhe analysieren.

2.1 Definieren der String-Konstanten unserer SQLite Datenbank

Als Erstes öffnen wir die Klasse ShoppingMemoDbHelper in dem Editor von Android Studio. Das Gerüst der Klasse haben wir bereits in der vorherigen Lektion des SQLite Tutorials angelegt.

Jetzt nehmen wir die Definition der Datenbank-Konstanten vor. Dazu fügen wir den folgenden Quellcode direkt nach der Definition der bereits vorhandenen LOG_TAG-Konstanten ein:


In den ersten beiden Zeilen legen wir den Namen der Datenbankdatei und die Versionsnummer der Datenbank fest. In Zeile 4 geben wir den Namen der zu erzeugenden Tabelle vor.

Die Namen der drei Tabellenspalten legen wir in den Zeilen 6 bis 8 fest. Die ID-Spalte wird als Primärschlüssel genutzt werden und trägt den Namen _id. Es ist sehr ratsam diese Bezeichnung zu wählen, da einige Klassen aus der Android-API, bspw. die Klasse SimpleCursorAdapter, diese Bezeichnung zwingend erwarten.

In unserem Android SQLite Tutorial könnten wir auch einen anderen Namen wählen, bleiben aber bei dieser weit verbreiteten Standardbezeichnung.

In den Zeilen 10 bis 14 definieren wir den SQL-String, mit dem wir die Tabelle in unserer SQLite Datenbank erstellen werden. Unsere Tabelle wird drei Spalten besitzen und darin die Daten der Einkaufsliste verwalten. Die Definition der Tabelle erfolgt mit den vorher angelegten String-Konstanten.

Dies ist später bei Datenbankanfragen sehr hilfreich, da wir mit Hilfe dieser Spalten-Konstanten unsere SQL-Anfrage erstellen werden.

Da wir nun alle Datenbankeigenschaften in den String-Konstanten festgehalten haben, können wir die Datenbank im nächsten Schritt mit Hilfe des Super-Konstruktors erzeugen lassen.

2.2 Aufruf des Super-Konstruktors anpassen

Zu Testzwecken haben wir bereits einen Beispielaufruf des Super-Konstruktors in dem Konstruktor der Klasse ShoppingMemoDbHelper angegeben. Dieser hat nun ausgedient und wird durch folgenden Aufruf ersetzt:


Mit der oberen markierten Codezeile (Zeile 3) rufen wir den Konstruktor der ShoppingMemoDbHelper-Elternklasse auf, diese ist die SQLiteOpenHelper-Klasse.

Dabei übergeben wir den context, den DB_NAME und die DB_VERSION. In den beiden String-Konstanten haben wir den Namen der Datenbank (“shopping_list.db”) und die Versionsnummer (1) gespeichert. Das dritte Argument ist null, hier könnte man eine CursorFactory übergeben, die wir in unserem Tutorial aber nicht benötigen.

Durch den Aufruf des Super-Konstruktors wird somit eine Datenbank erzeugt, die ihre Daten in der Datei “shopping_list.db” speichert und die Versionsnummer 1 trägt. Die Versionsnummer ist für spätere Upgrades der SQLite Datenbank wichtig, wenn bspw. eine weitere Spalte der Tabelle hinzugefügt werden soll.

Da nun das Erzeugen der SQLite Datenbank sichergestellt ist, können wir im nächsten Arbeitsschritt das Erstellen der Tabelle umsetzen.

2.3 Erstellen der Tabelle in der onCreate() Methode vorbereiten

Wie wir in Abschnitt 1 erfahren haben, wird die onCreate() Methode automatisch aufgerufen, wenn die SQLite Datenbank neu angelegt wird. Ist die Datenbank erst einmal angelegt, wird die onCreate() Methode nicht mehr aufgerufen.

Diesen Zusammenhang dürfen wir nicht vergessen, wenn wir bspw. zu Testzwecken eine Datenbank bereits angelegt haben und im Anschluss daran eine Tabelle einfügen wollen. In einem solchen Fall muss die zugehörige Datenbankdatei erst gelöscht werden.

Dies geschieht automatisch, wenn ihr die App von eurem Android Gerät oder dem Android Emulator deinstalliert. Da wir aber bisher noch keine Datenbank mit dem Namen “shopping_list.db” erzeugt haben, müssen wir unsere SQLite-App vorher nicht deinstallieren.

Um die Tabelle in der SQLite Datenbank anzulegen, fügen wir den folgenden Quellcode in die onCreate() Methode ein:


Dies ist auch schon alles. Die Tabelle wird mit der Anweisung in Zeile 6 erstellt und in die SQLite Datenbank eingefügt. Dazu übergeben wir mittels execSQL() dem SQLiteDatabase-Objekt das SQL-Kommando zur Ausführung.

Sollte ein Fehler beim Erstellen der Tabelle aufgetreten sein, fangen wir diesen mit dem try/catch-Block ab.

2.4 Der komplette Quellcode der ShoppingMemoDbHelper-Klasse

Nun haben wir alle Veränderungen an der ShoppingMemoDbHelper-Klasse vorgenommen und das Erstellen der Tabelle in die Android SQLite Datenbank vorbereitet.

In dem unten angegebenen Quellcode ist die gesamte ShoppingMemoDbHelper-Klasse zur Kontrolle für euch aufgeführt. Die neu eingefügten Zeilen sind gelb markiert.

Der vollständige Quelltext der Klasse ShoppingMemoDbHelper:


In Android Studio sollte die Klasse ShoppingMemoDbHelper nun wie folgt aussehen:

android sqlite dbhelper

Die überarbeitete Klasse ShoppingMemoDbHelper mit Markierungen

In der oberen Abbildung sind die in den drei Arbeitsschritten vorgenommenen Änderungen mit einem blauen Rahmen markiert.

Die Datenbank- und Tabellen-Konstanten sind mit A markiert, der überarbeitete Konstruktor mit B und die Methode onCreate(), in der wir unsere Tabelle erstellen lassen, ist mit einem blauen C gekennzeichnet.

Somit sind die Vorbereitungen in der ShoppingMemoDbHelper-Klasse abgeschlossen. Wir können sie nun in der ShoppingMemoDataSource-Klasse verwenden.

3. Herstellen der Verbindung zur SQLite Datenbank mit der ShoppingMemoDataSource-Klasse

Bisher haben wir das Erstellen der Tabelle in die Datenbank nur vorbereitet.

Der Quellcode, den wir in die onCreate() Methode der ShoppingMemoDbHelper-Klasse eingefügt haben, wird noch nicht ausgeführt und somit wird auch keine Tabelle angelegt.

Erst wenn wir die geerbte Methode getWritableDatabase() der ShoppingMemoDbHelper-Klasse aufrufen, wird der Erstellungsprozess der Datenbank vom Android System gestartet.

Hierbei wird entweder eine Referenz auf die bereits vorhandene SQLite Datenbank zurückgeliefert oder, wenn noch keine Datenbank vorhanden ist, eine neue SQLite Datenbank angelegt.

Da in unserer Klasse ShoppingMemoDataSource eine Instanz der Klasse ShoppingMemoDbHelper vorhanden ist, können wir auf dieser Instanz die getWritableDatabase() Methode aufrufen und dadurch den Erstellungsprozess der SQLite Datenbank und der Tabelle auslösen.

Wenn die SQLite Datenbank erfolgreich angelegt wurde, erhalten wir als Rückgabewert eine Referenz auf das Datenbankobjekt. Wir stellen also mit dem Aufruf der getWritableDatabase() Methode auch immer eine Verbindung zu dem SQLite Datenbankobjekt her.

Daher führen wir diesen Aufruf in der Methode open() unserer ShoppingMemoDataSource-Klasse aus. Die Verbindung zur Datenbank schließen wir dann wieder in der close() Methode der selben Klasse.

Als nächste Veränderung in unserem Quellcode werden wir daher diese beiden Methoden in der Klasse ShoppingMemoDataSource erstellen. Dazu öffnen wir die ShoppingMemoDataSource-Klasse im Editor von Android Studio und fügen den gelb markierten Code-Block in den Quelltext ein:


Für das Öffnen und Schließen der SQLite Datenbankverbindung bedienen wir uns den beiden Methoden getWritableDatabase() und close() der Klasse SQLiteOpenHelper, die wir über das ShoppingMemoDbHelper-Objekt aufrufen.

Mit dem Aufruf in Zeile 23 stellen wir die Verbindung zu unserer SQLite Datenbank her. Beim ersten Start unserer App, wenn also noch keine Datenbankdatei vorhanden ist, wird durch den Aufruf auch der Erstellungsprozess der Datenbank gestartet.

Dabei wird die onCreate() Methode unserer ShoppingMemoDbHelper-Klasse einmalig ausgeführt und dadurch auch die Tabelle mit db.execSQL(SQL_CREATE); erstellt. In Zeile 28 schließen wir die Verbindung zur Datenbank wieder.

Mit den beiden neuen Methoden open() und close() können wir nun sehr einfach eine Verbindung zu unserer SQLite Datenbank herstellen und wieder schließen. Um Details müssen wir uns dabei nicht kümmern, das übernimmt für uns die, extra dafür angelegte, Hilfsklasse ShoppingMemoDbHelper.

Diese Kapselung wird uns bei der Arbeit mit der Datenbank später eine große Hilfe sein und sorgt für leicht verständlichen und übersichtlichen Quellcode.

In Android Studio sollte die Klasse ShoppingMemoDataSource nun wie folgt aussehen:

android sqlite datasource

Die überarbeitete Klasse ShoppingMemoDataSource mit Markierungen

Im nächsten Abschnitt werden wir in der MainActivity-Klasse unsere Datenquelle (ShoppingMemoDataSource) öffnen und damit die Verbindung zur Datenbank herstellen lassen. Dabei überprüfen wir auch gleichzeitig, ob unsere SQLite-App nach den vorgenommenen Änderungen noch korrekt funktioniert.

4. Öffnen der Datenquelle und Zugriff auf die Datenbank in der MainActivity-Klasse

Wir haben in der Datenbank-Hilfsklasse ShoppingMemoDbHelper den Code für das Anlegen der SQLite Datenbank und Erstellen einer Tabelle hinterlegt. Die Klasse ShoppingMemoDataSource haben wir als Datenquelle erstellt, von der aus wir eine Verbindung zur Datenbank aufbauen und später die Manipulationen an der Datenbank vornehmen werden.

Somit sind die Grundlagen für die Arbeit mit einer SQLite Datenbank gelegt. Jetzt müssen wir noch die Datenquelle öffnen und erhalten so Zugriff auf die Datenbank. Dies werden wir in der MainActivity-Klasse vornehmen und von dort die Zugriffe auf die SQLite Datenbank über die Datenquelle (DataSource) steuern.

Für das Öffnen und Schließen der Datenquelle benötigen wir jeweils nur eine Anweisung. Um die beiden Anweisungen zusammen mit Log-Meldungen in die MainActivity-Klasse einzufügen, öffnen wir die zugehörige Projektdatei im Editor von Android Studio.

Anschließend fügen wir die gelb markierten Zeilen in den bisherigen Quellcode ein:


Die beiden Anweisungen sind selbsterklärend, nicht aber was sich im Hintergrund abspielt. Beim Öffnen der Datenquelle, wird mit Hilfe des dataSource Objekts vom Typ ShoppingMemoDataSource eine Verbindung zur SQLite Datenbank angefragt.

Falls keine Datenbank vorhanden ist, wird nun mit Hilfe der ShoppingMemoDbHelper-Klasse eine SQLite Datenbank angelegt und dabei auch die von uns definierte Tabelle.

Mit dataSource.close(); schließen wir die Datenquelle wieder. Dabei wird auch die Verbindung zur Datenbank getrennt.

In Android Studio sollte die Klasse ShoppingMemoDataSource nun wie folgt aussehen:

android sqlite main activity

Die überarbeitete Klasse MainActivity mit Markierungen

Damit haben wir alle notwendigen Änderungen an den Projektdateien vorgenommen.

Im nächsten Abschnitt werden wir unsere Android App ausführen und die Log-Meldungen analysieren. Dadurch können wir die Funktion unserer SQLite-App überprüfen und gleichzeitig besser verstehen, was beim Öffnen der Datenquelle passiert und in welcher zeitlichen Abfolge dies stattfindet.

5. Starten und Testen unserer SQLite-App

Nun möchten wir unsere Android App ausführen und überprüfen, ob unsere Tabelle korrekt in der SQLite Datenbank angelegt wird.

Dazu werden wir zunächst die Anwendung auf einem Android Gerät ausführen und anschließend die zurückgelieferten Log-Meldungen in Android Studio analysieren.

5.1 Ausführen der Android SQLite-App

Nun wollen wir unsere App ausführen und testen. Dazu installieren wir die Anwendung auf unser angeschlossenes Android Gerät (Smartphone oder Tablet) oder in einer AVD des Android Emulators.

Wie eine Android App installiert wird, könnt ihr in den folgenden beiden Teilen unseres großen Android App Programmieren Tutorials nachlesen:

Hier noch einmal in Kürze die wichtigsten Arbeitsschritte.

Zuerst schließen wir unser Android Gerät an den PC an und stellen eine Verbindung über die ADB (Android Debug Bridge) her. Danach klicken wir auf das Run 'app'-Symbol. Unser Android Projekt wird dadurch neu erstellt und auf dem angeschlossenen Gerät ausgeführt.

Das Run 'app'-Symbol befindet sich in der oberen Menüleiste, siehe folgende Abbildung:

android sqlite app starten

Android App über das Run App-Symbol starten

Nach einigen Momenten öffnet sich der Choose Device-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

  1. Radio Button Choose a running device aktivieren
  2. Das angeschlossene Android Gerät auswählen
  3. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten
android choose device

Auswählen des angeschlossenen Android Geräts zum Aufspielen unserer App

Der Dialog schließt sich und unsere Android App wird auf das angeschlossene Gerät übertragen und installiert. Die Installation dauert nur einen kurzen Augenblick und verläuft fast unbemerkt im Hintergrund. Danach wird unsere App automatisch gestartet.

5.2 Überprüfen der Log-Meldungen in Android Studio

Unsere SQLite-App sollte jetzt auf dem Android Gerät gestartet worden sein. Die grafische Benutzeroberfläche der Anwendung hat sich nicht geändert, daher sieht auf dem Gerät alles genau so aus wie in Lektion 1 des Android SQLite Tutorials.

Um die Log-Meldungen zu überprüfen, öffnen wir in Android Studio die Android-Ansicht bei angeschlossenem Android Gerät.

In der unteren Abbildung sind die Log-Meldungen unserer Android App dargestellt. Der in der vorherigen Lektion angelegte Log-Filter ist aktiviert (rote Markierung X). Unsere Meldungen werden im logcat-Textbereich angezeigt und sind von einem blauen Rahmen umschlossen (Markierung 1).

android sqlite log start

Erstes Ausführen der SQLite-App – Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter

Uns werden die folgenden Log-Meldungen ausgegeben:

1: MainActivity﹕ Inhalt der Testmemo: 5 x Birnen
2: ShoppingMemoDataSource﹕ Unsere DataSource erzeugt jetzt den dbHelper.
3: ShoppingMemoDbHelper﹕ DbHelper hat die Datenbank: shopping_list.db erzeugt.
4: MainActivity﹕ Die Datenquelle wird geöffnet.
5: ShoppingMemoDataSource﹕ Eine Referenz auf die Datenbank wird jetzt angefragt.
6: ShoppingMemoDbHelper﹕ Die Tabelle wird mit SQL-Befehl: CREATE TABLE shopping_list(_id INTEGER PRIMARY KEY AUTOINCREMENT, product TEXT NOT NULL, quantity INTEGER NOT NULL); angelegt.
7: ShoppingMemoDataSource﹕ Datenbank-Referenz erhalten. Pfad zur Datenbank: /data/data/de.programmierenlernenhq.shoppinglisthq/databases/shopping_list.db
8: MainActivity﹕ Die Datenquelle wird geschlossen.
9: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Die drei ersten Log-Meldungen haben wir bereits in der vorherigen Lektion überprüft. Neu hinzugekommen sind die Meldungen 4 bis 9.

Vor dem Öffnen der Datenquelle wird die Log-Meldung Die Datenquelle wird geöffnet. von der MainActivity aus ausgegeben. Anschließend wird die Datenquelle geöffnet und dadurch eine Referenz auf die Datenbank in der ShoppingMemoDataSource-Klasse angefragt.

Da noch keine Datenbank mit dem Namen shopping_list.db auf dem Android Gerät vorhanden ist, wird sie angelegt und dabei die onCreate() Methode der ShoppingMemoDbHelper-Klasse ausgeführt. Dies wird uns mit der 6. Log-Meldung quittiert. Mit dieser Meldung können wir auch den SQL-String, den wir für das Erstellen der Tabelle verwenden, überprüfen.

Die Datenquelle besitzt jetzt eine Referenz auf die Datenbank und gibt uns den Pfad zur SQLite Datenbank als Meldung aus. Die letzten beiden Meldungen informieren uns über das Schließen der Datenquelle und Datenbank.

Sollte bei euch die Tabelle nicht angelegt werden (Log-Meldung 6), müsst ihr die App von eurem Android Gerät deinstallieren und dann erneut aufspielen. Dadurch wird die alte Datenbankdatei gelöscht und eine Neue wieder angelegt.

Wenn wir nun die App erneut über Android Studio starten, erhalten wir eine etwas andere Log-Meldung zurück. Die folgende Abbildung enthält die resultierenden Log-Meldungen, wenn die App das erste Mal und danach ein zweites Mal gestartet wird.

android sqlite log

Zweites Ausführen der SQLite-App – Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter

Die beim erstmaligen Start ausgegebenen Log-Meldungen sind von einem blauen Rahmen umschlossen (Markierung 1). Darin ist mit einer grünen Linie die Log-Meldung unterstrichen, die bei dem Erstellen der Tabelle ausgegeben wird (Markierung A).

Die Log-Meldungen, welche beim zweiten Start ausgegeben werden, sind darunter mit einem orangenen Rahmen umschlossen (Markierung 2). Bei ihnen fehlt die sechste Meldung, da die Tabelle nicht erneut in der Datenbank erstellt wurde.

Möchten wir die Tabelle erneut erstellen, müssen wir die App vom Android Gerät deinstallieren und anschließend neu starten.

Wenn bei euch die gleichen Log-Meldungen ausgegeben werden, habt ihr alle Arbeitsschritte korrekt umgesetzt und eure App verfügt nun über eine SQLite Datenbank mit einer Tabelle. In der nächsten Lektion des Android SQLite Tutorials können wir nun diese Tabelle mit Datensätzen füllen.

Zusammenfassung

In dieser Lektion unseres Android SQLite Tutorials haben wir eine Tabelle in die Datenbank eingefügt. Dazu mussten wir Änderungen an den folgenden drei Klassen vornehmen.

  1. ShoppingMemoDbHelper – Diese Klasse ist unsere Hilfsklasse. Hier haben wir die Eigenschaften der Datenbank und Tabelle definiert und die Tabelle mit einem SQL-Kommando erstellt.
  2. ShoppingMemoDataSource – Diese Klasse ist unsere Datenquelle und hält die Verbindung zur Datenbank aufrecht. Hier haben wir eine Referenz zu dem Datenbankobjekt angefragt und damit den Erstellungsprozess der Tabelle gestartet.
  3. MainActivity – Mit unserer Hauptklasse steuern wir die Datenbankzugriffe. In ihr haben wir unsere Datenquelle geöffnet und wieder geschlossen.

Durch das Testen unserer Android SQLite-App im letzten Abschnitt haben wir abschließend überprüft, ob die Tabelle ordnungsgemäß angelegt wurde.

Somit sind jetzt alle Bedingungen für das Arbeiten mit der Datenbank und ihrer Tabelle erfüllt. In der nächsten Lektion des Tutorials werden wir erstmals Datensätze in die Tabelle einfügen und wieder auslesen.


Comments 8

  1. Pingback: Android SQLite Tutorial - Teil 2: SQLite Datenbank integrieren

  2. Stefan

    Zwei echt gute Tutorials für den Einstieg in Android.
    Setzt du das “Android SQLite Datenbank Tutorial ” irgendwann mit Teil 4 fort?

    Gruß

    1. Post
      Author
      Chris

      Hallo Stefan,

      danke für das Lob! Der vierte Teil ist in Arbeit und erscheint Ende nächster Woche.

      Viele Grüße, Chris

  3. Uwe

    Hallo Chris,

    großes Lob für die beiden Android-Tutorials. Du hast Dir sehr viel Mühe gegeben. Mir gelang damit der Einstieg in die Android-Programmierung sehr gut.
    Ich freue mich schon auf die Fortsetzung mit dem 4. Teil am Ende dieser Woche.

    Viele Grüße

    Uwe

    1. Post
      Author
  4. Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen

  5. Kim

    Hi,

    das Tutorial ist echt super, hat bisher auch super bei mir funktioniert, jetzt bin ich aber auf ein Problem gestoßen, bei dem ich nicht weiterkomme. Im Javafile der dbHelper Klasse bekomme ich bei dem Stück des Aufrufs des Superkonstruktors eine Error Meldung. Genauer gesagt schon beim vorigen Aufruf des Konstruktors der dbHelper Klasse.
    Der Compiler sagt: “invalid method declaration; return type required.”
    Dabei handelt es sich doch nicht um eine Methodendeklaration oder? Ich hab alles etliche male durchgeschaut, verglichen etc. und komme nicht darauf wo der Fehler liegt…

    Danke, und viele Grüße,

    Kim

    1. Post
      Author
      Chris

      Hallo Kim,

      ohne Quellcode ist der Fehler schwer zu finden. Wenn du möchtest, kannst Du mir die Quelldatei der dbHelper Klasse per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann.

      Viele Grüße, Chris

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *