android sqlite_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 4: Daten in die SQLite Datenbank schreiben und auslesen


Am Ende der vierten Lektion des Android SQLite Tutorials werden wir unsere App ausführen und dabei überprüfen, ob die Daten korrekt in die SQLite Datenbank geschrieben werden.

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

1. Daten in die SQLite Datenbank schreiben und auslesen

Android Apps Programmieren Online-Kurs

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Auf eine SQLite Datenbank können vier Grundoperationen angewandt werden, die unter dem Akronym CRUD zusammengefasst werden.

Die vier Grundoperatoren sind:

  • Create – Erstellen neuer Datensätze.
  • Read – Auslesen von Datensätzen.
  • Update – Aktualisieren von Datensatzinhalten.
  • Delete – Löschen von Datensätzen.

Alle Grundoperationen können als SQL-String vorgegeben werden und dann mit Hilfe der Methode execSQL() auf dem SQLiteDatabase-Objekt ausgeführt werden.

Es geht aber auch bequemer. Für einfache Datenbankoperationen können die von der SQLDatabase-Klasse zur Verfügung gestellten Methoden verwendet werden. Für diese Basiszugriffe werden keine expliziten SQL-Kommando benötigt.

Wie dabei vorzugehen ist, zeigen wir euch in den folgenden Unterabschnitten. Zuerst werden wir beschreiben wie Daten in die SQLite Datenbank geschrieben werden. Dabei stellen wir die Klasse ContentValues und den Insert-Befehl vor.


Anschließend zeigen wir, wie das Auslesen von Datensätzen aus der SQLite Datenbank abläuft. Dabei zeigen wir was ein Cursor ist und wie er verwendet wird.

Im dritten Unterabschnitt stellen wir die die Hilfsmethode cursorToShoppingMemo() vor. Wir verwenden diese Methode, um Datensätze aus der Datenbank in ShoppingMemos umzuwandeln.

1.1 Daten in die SQLite Datenbank schreiben

Datensätze lassen sich in Android sehr einfach in die SQLite Datenbank einfügen.

Wir benötigen dafür ein Hilfsobjekt vom Typ ContentValues, in das wir die einzutragenden Inhalte als Key-Value Pairs (Schlüssel-Wert Paare) ablegen.

Das ContentValues-Objekt können wir dann in die SQLite Datenbank einfügen.

Die Schlüsselnamen (Keys) müssen dabei unbedingt den Spaltennamen der Tabelle entsprechen. Pro Schlüssel kann genau ein Wert zugewiesen werden.

Im unteren Quelltext erzeugen wir ein ContentValues-Objekt und legen darin zwei Schlüssel-Wert Paare ab:

ContentValues values = new ContentValues();
values.put(ShoppingMemoDbHelper.COLUMN_PRODUCT, product);
values.put(ShoppingMemoDbHelper.COLUMN_QUANTITY, quantity);

Mit der put() Methode werden die Schlüssel-Wert Paare abgelegt. Dabei entspricht das erste Argument dem Spaltennamen der Tabelle und das zweite Argument übergibt den abzuspeichernden Wert.

Im Quellcode arbeiten wir mit der Hilfsklasse ShoppingMemoDbHelper, die uns die korrekten Spaltennamen als String-Konstanten liefert.

Es muss nicht für jede Spalte der Tabelle ein Wert übergeben werden. Unsere Tabelle besteht aus den Spalten _id, product und quantity. Da wir die Spalte _id mit AUTOINCREMENT definiert haben, wird dieser Wert automatisch vom SQLite Datenbanksystem gesetzt.

Wir dürfen daher keinen Eintrag für die _id-Spalte in dem ContentValues-Objekt einfügen. Die anderen beiden Spalten müssen zwingend mit Werten gefüllt werden, da wir in der Tabellendefinition für die Spalten product und quantity den Zusatz NOT NULL vorgegeben haben.

Um die vorbereiteten Daten in die Datenbank einzutragen, übergeben wir das ContentValues-Objekt der insert() Methode, die wir auf dem SQLiteDatabase-Objekt aufrufen.

Mit der folgenden Anweisung wird ein Datensatz in die Tabelle der SQLite Datenbank eingefügt:

long insertId = database.insert(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST, null, values);

Die Methode insert() erwartet drei Argumente, von denen wir nur das erste und letzte verwenden. Mit dem ersten Argument übergeben wir den Namen unserer Tabelle und mit dem dritten Argument schließlich die einzutragenden Werte in Form des vorher befüllten ContentValues-Objekts. Das zweite Argument wird nur benötigt, wenn man ein leeres ContentValues-Objekts übergeben würde.

Ist das Einfügen der Werte in die Tabelle der Datenbank erfolgreich gewesen, erhalten wir eine eindeutige ID für den erzeugten Datensatz zurück. Diese ID ist vom Datentyp long und sollte unbedingt gespeichert werden, damit wir später direkt auf den eben eingefügten Datensatz zugreifen können.

Weiterführende Informationen über ContentValues und die insert() Methode sind auf der Android Developer Webseite zu finden.

1.2 Daten aus der SQLite Datenbank auslesen

Wir können sehr einfach nach Einträgen in der Android SQLite Datenbank suchen.

Dafür werden Queries (Suchanfragen) verwendet, in denen über bestimmte Suchkriterien die zu liefernden Datensätze beschrieben werden.

Das Verwenden komplexer Suchanfragen ist ein wesentlicher Vorteil von Datenbanken gegenüber anderen Speicherformen.

Die Klasse SQLiteDatabase stellt uns für diese Zwecke die query() Methode zur Verfügung.

Die Methode ist vierfach überladen und erwartet mindestens 7 Argumente, von denen wir aber nicht alle mit Werten füllen müssen. Als Rückgabewert liefert sie ein Cursor-Objekt zurück, eine Art Zeiger auf eine Zeile der SQLite Tabelle. Man bezeichnet einen Cursor daher auch häufig als Datensatzzeiger.

Genaue Angaben über die Parameterliste der query() Methoden könnt ihr auf der Android Developer Webseite nachlesen.

Mit folgendem Quellcode suchen wir nach einem Datensatz mit einer bestimmten ID:

Cursor cursor = database.query(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST,
                columns, ShoppingMemoDbHelper.COLUMN_ID + "=" + insertId,
                null, null, null, null);

Folgende Argumente werden von uns beim Aufruf der query() Methode genutzt:

  • Argument 1: Enthält den Namen der zu durchsuchenden Tabelle. Wir nutzen wieder die Hilfsklasse ShoppingMemoDbHelper, die uns den korrekten Tabellennamen als String-Konstante liefert.
  • Argument 2: Enthält den Namen der Tabellenspalten, die von der Suchanfrage zurückgeliefert werden sollen. Bei null werden alle Spalten zurückgeliefert.
  • Argument 3: Enthält den String mit den Suchkriterien. Dieser Such-String enthält den Namen der zu vergleichenden Spalte und testet mit dem = Operator, ob die Werte den vorgegebenen Daten entsprechen. Wenn der Such-String null ist, werden alle Datensätze der Tabelle zurückgeliefert.
  • Argumente 4-7: Diese werden nicht von uns benutzt und tragen den Wert null. Über sie kann die Suche weiter verfeinert werden.

Als Ergebnis der Suchanfrage erhalten wir ein spezielles Datenzugriffsobjekt (Data Access Object) vom Typ Cursor zurück. Mit diesem Cursor können wir die Datensätze im Suchergebnis durchlaufen und auf ihre inneren Werte zugreifen.

Um zu einem anderen Datensatz zu navigieren, kann der Cursor (Datensatzzeiger) durch Aufrufen der folgenden Methoden explizit an eine andere Stelle (Datensatz) verschoben werden:

  • moveToFirst() – Bewegt den Cursor zum ersten Datensatz.
  • moveToNext() – Bewegt den Cursor zum nächsten Datensatz.
  • moveToPrevious() – Bewegt den Cursor zum vorherigen Datensatz.
  • moveToLast() – Bewegt den Cursor zum letzten Datensatz.
  • moveToPosition(int pos) – Bewegt den Cursor zum Datensatz an einer bestimmten Positon.

Jede Methode liefert als Rückgabewert true oder false zurück und zeigt damit an, ob die Cursor-Verschiebung erfolgreich durchgeführt werden konnte. Die Anzahl der gefundenen Datensätze kann mit der Methode getCount() abgefragt werden.

Die Werte in den Datensätzen können mit den verschiedenen get-Methoden des Cursor-Interfaces ausgelesen werden. Die Methoden getString(), getInt(), getLong() und getFloat() liefern die Spaltenwerte des ausgewählten Datensatzes zurück. Als Argument erwarten sie den Index der Spalte (Column Index), deren Wert ausgelesen werden soll.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Die Indizes der Spalten entsprechen der Erstellungsreihenfolge, nach der die Spalten in die Tabelle angelegt wurden. Die Indizes der Tabellenspalten können auch nach dem Erzeugen der Tabelle mit der Methode getColumnIndex(String columnName) noch ausgelesen werden. Man muss dazu aber den Namen der Spalte wissen. Ist die Spalte nicht vorhanden wird der Wert -1 zurückgeliefert, sonst der Index der Spalte.

Wie das Cursor-Objekt in der Praxis eingesetzt wird und damit Werte aus den Datensätzen der Datenbank ausgelesen werden, beschreiben wir im nächsten Unterabschnitt genauer.

1.3 Die Hilfsmethode cursorToShoppingMemo()

In unserer SQLite-App werden wir die Hilfsmethode cursorToShoppingMemo() verwenden, um ein Cursor-Objekt in ein ShoppingMemo-Objekt umzuwandeln.

Dabei benutzen wir vier wichtige Methoden des Cursor-Interfaces, diese sind:

  • getColumnIndex(String columnName) – Durch Angabe des Spaltennamens unserer Tabelle erhalten wir den Index der Spalte zurück.
  • getString(int columnIndex) – Mit dem übergebenen Spaltenindex wird die relevante Spalte gefunden und der darin gespeicherte String-Wert zurückgegebenen.
  • getInt(int columnIndex) – In diesem Fall wird als Rückgabewert ein int-Wert zurückgeliefert.
  • getLong(int columnIndex) – In diesem Fall wird als Rückgabewert ein long-Wert zurückgeliefert.

Mit dem folgenden Quellcode definieren wir die Hilfsmethode cursorToShoppingMemo():

private ShoppingMemo cursorToShoppingMemo(Cursor cursor) {
    int idIndex = cursor.getColumnIndex(ShoppingMemoDbHelper.COLUMN_ID);
    int idProduct = cursor.getColumnIndex(ShoppingMemoDbHelper.COLUMN_PRODUCT);
    int idQuantity = cursor.getColumnIndex(ShoppingMemoDbHelper.COLUMN_QUANTITY);

    String product = cursor.getString(idProduct);
    int quantity = cursor.getInt(idQuantity);
    long id = cursor.getLong(idIndex);

    ShoppingMemo shoppingMemo = new ShoppingMemo(product, quantity, id);

    return shoppingMemo;
}

Der Code ist größtenteils selbsterklärend. In den Zeilen 2 bis 4 lesen wir die Indizes unserer Tabellenspalten aus. Anschließend lassen wir uns in den Zeilen 6 bis 8 die Inhalte der Suchanfrage mit den get-Methoden ausgeben. Dazu nutzen wir die vorher erhaltenen Spaltenindizes.

Das Cursor-Objekt zeigt dabei auf einen Datensatz der vorher ausgeführten Suchanfrage. Über die Spaltenindizes kann auf die Zellen des Datensatzes zugegriffen und mit der entsprechenden get-Methode deren Inhalt ausgelesen werden.

In Zeile 10 erzeugen wir schließlich mit den ausgelesenen Daten das ShoppingMemo-Objekt. Dieses können wir nun in unserer Anwendung weiterverwenden, bspw. in einem ListView anzeigen lassen, und geben es daher als Rückgabewert zurück.

Die eben beschriebene Hilfsmethode werden wir in unserer Android SQLite App öfter verwenden. Mit ihrer Hilfe könne sehr einfach und bequem Datensätze in ShoppingMemo-Objekte umgewandelt werden.

Nun haben wir den theoretischen Teil dieser Lektion des Android SQLite Datenbank Tutorials abgeschlossen und können des Erlernte in unserem Android Projekt einsetzen.

Dazu werden wir in dem nächsten Abschnitt den Quellcode unserer Datenquelle, der ShoppingMemoDataSource-Klasse, vervollständigen, so dass wir Daten in unsere SQLite Datenbank schreiben und auch wieder auslesen können.

2. Mit Hilfe unserer Datenquelle Daten in die SQLite Datenbank speichern und aus dieser auslesen

Jetzt werden wir unserer Datenquelle wichtige Zugriffsfunktionen hinzufügen. Dies werden wir durch die drei folgenden Änderungen an dem Quellcode der Klasse ShoppingMemoDataSource verwirklichen:

  1. Einfügen der Import-Anweisungen – Zuerst importieren wir die benötigten Klassen und Interfaces.
  2. Anlegen des Spalten-Arrays – Die Spaltennamen unserer Tabelle speichern wir in einem String-Array.
  3. Definieren der Methoden – Wir definieren drei Methoden, die uns beim Zugreifen auf Datensätze der SQLite Datenbank helfen. Eine Methode wird das Schreiben von Datensätzen in die Datenbank realisieren. Eine andere Methode wird für das Auslesen aller Datensätze aus der SQLite Datenbank zuständig sein. Die dritte Methode ist die bereits weiter oben vorgestellte Hilfsmethode cursorToShoppingMemo() und wandelt ein Cursor-Objekt in ein ShoppingMemo-Objekt um.

Hinweis: 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 ShoppingMemoDataSource-Klasse in Ruhe analysieren und direkt erkennen, an welcher Stelle welcher Code-Block eingefügt werden muss.

Nun beginnen wir mit dem ersten Arbeitsschritt.

2.1 Einfügen der Import-Anweisungen

Als Erstes öffnen wir die Klassendatei ShoppingMemoDataSource.java in dem Editor von Android Studio. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.shoppinglist unseres Projekts. Das Gerüst der Klasse haben wir bereits in der vorherigen Lektion des SQLite Tutorials angelegt.

Anschließend fügen wir den folgenden Quellcode unter den bereits vorhandenen Import-Anweisungen ein:

ShoppingMemoDataSource.java

import android.content.ContentValues;
import android.database.Cursor;
import java.util.ArrayList;
import java.util.List;

Die vier Klassen bzw. Interfaces machen wir mittels Import-Anweisungen innerhalb der Klasse ShoppingMemoDataSource sichtbar, so dass wir sie ohne den Namen ihres Packages verwenden können.

Die Klasse ContentValues benötigen wir für das Schreiben von Daten in die SQLite Datenbank. Das Interface Cursor nutzen wir für Lese-Zugriffe auf die Datenbank. Das Interface List und die Klasse ArrayList werden wir für das Speichern von ShoppingMemo-Objekten in einer Liste verwenden. Den Inhalt der Liste werden wir später vom ListView unserer Android App ausgeben lassen.

2.2 Anlegen des Spalten-Arrays

Auch der zweite Arbeitsschritt ist schnell ausgeführt. Den folgenden Quellcode fügen wir direkt unter den bereits angelegten Membervariablen in die Klasse ShoppingMemoDataSource.java ein:

ShoppingMemoDataSource.java

private String[] columns = {
  ShoppingMemoDbHelper.COLUMN_ID,
  ShoppingMemoDbHelper.COLUMN_PRODUCT,
  ShoppingMemoDbHelper.COLUMN_QUANTITY
};

Den Spalten-Array werden wir später für Suchanfragen verwenden. Er enthält die Namen der drei Spalten unserer Tabelle. Die Namen geben wir nicht selbst ein, sondern nutzen dafür die String-Konstanten der Hilfsklasse ShoppingMemoDbHelper.

2.3 Definieren der Methoden

Im letzten Arbeitsschritt werden wir drei Methoden definieren, die uns beim Zugriff auf die SQLite Datenbank unterstützen. Die Hilfsmethode cursorToShoppingMemo() haben wir bereits im theoretischen Teil dieser Lektion kennengelernt. Die beiden anderen Methoden sind neu. Wir werden sie daher im Anschluss an den Quelltext ausführlich beschreiben.

Jetzt fügen wir den folgenden Quellcode in den Methodenbereich der ShoppingMemoDataSource-Klasse direkt nach der close() Methode ein:

ShoppingMemoDataSource.java

public ShoppingMemo createShoppingMemo(String product, int quantity) {
  ContentValues values = new ContentValues();
  values.put(ShoppingMemoDbHelper.COLUMN_PRODUCT, product);
  values.put(ShoppingMemoDbHelper.COLUMN_QUANTITY, quantity);

  long insertId = database.insert(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST, null, values);

  Cursor cursor = database.query(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST,
                  columns, ShoppingMemoDbHelper.COLUMN_ID + "=" + insertId,
                  null, null, null, null);

  cursor.moveToFirst();
  ShoppingMemo shoppingMemo = cursorToShoppingMemo(cursor);
  cursor.close();

  return shoppingMemo;
}

private ShoppingMemo cursorToShoppingMemo(Cursor cursor) {
  int idIndex = cursor.getColumnIndex(ShoppingMemoDbHelper.COLUMN_ID);
  int idProduct = cursor.getColumnIndex(ShoppingMemoDbHelper.COLUMN_PRODUCT);
  int idQuantity = cursor.getColumnIndex(ShoppingMemoDbHelper.COLUMN_QUANTITY);

  String product = cursor.getString(idProduct);
  int quantity = cursor.getInt(idQuantity);
  long id = cursor.getLong(idIndex);

  ShoppingMemo shoppingMemo = new ShoppingMemo(product, quantity, id);

  return shoppingMemo;
}

public List<ShoppingMemo> getAllShoppingMemos() {
  List<ShoppingMemo> shoppingMemoList = new ArrayList<>();

  Cursor cursor = database.query(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST,
                  columns, null, null, null, null, null);

  cursor.moveToFirst();
  ShoppingMemo shoppingMemo;

  while(!cursor.isAfterLast()) {
    shoppingMemo = cursorToShoppingMemo(cursor);
    shoppingMemoList.add(shoppingMemo);
    Log.d(LOG_TAG, "ID: " + shoppingMemo.getId() + ", Inhalt: " + shoppingMemo.toString());
    cursor.moveToNext();
  }

  cursor.close();

  return shoppingMemoList;
}

Mit der ersten Methode createShoppingMemo() können wir Datensätze in die Tabelle unserer SQLite Datenbank einfügen. In der Methode erzeugen wir in den Zeilen 2 bis 4 ein ContentValues-Objekt, in das wir den Produktnamen und die Menge einfügen.

Anschließend tragen wir diese Werte mit Hilfe des ContentValues-Objekts in die Tabelle ein. Dazu verwenden wir den insert-Befehl in Zeile 6, den wir auf dem SQLiteDatabase-Objekt ausführen. Als Argumente übergeben wir den Namen der Tabelle, als ColumnHack den Wert null und als einzutragende Daten das vorbereitete ContentValues-Objekt. Als Rückgabewert erhalten wir die ID des erstellten Datensatzes zurück.

Nun lesen wir die eingetragenen Werte zur Kontrolle mit der Anweisung in Zeile 8 bis 10 direkt wieder aus. Als Argumente übergeben wir den Namen der Tabelle, den Spalten-Array (die Suchanfrage soll die Werte für alle Spalten zurückliefern) und den Such-String mit dem wir nach dem eben eingefügten Datensatz suchen. Die restlichen Argumente sind alle null.

Als Ergebnis auf die Suchanfrage erhalten wir ein Cursor-Objekt zurück, das die gefundenen Datensätze enthält. In unserem Fall besteht es aus genau einem Datensatz, dem eben eingefügten.

Mit der Anweisung in Zeile 12 bewegen wir den Cursor an die Position seines ersten Datensatzes. Anschließend rufen wir die cursorToShoppingMemo() Methode auf und wandeln dadurch den Datensatz des Cursor-Objekts in ein ShoppingMemo-Objekt um.

Das so erzeugte ShoppingMemo-Objekt geben wir an die aufrufende Methode zurück. Doch vorher schließen wir noch das Cursor-Objekt mit der Anweisung in Zeile 14.

Die zweite Methode cursorToShoppingMemo() haben wir bereits im ersten Kapitel ausführlich besprochen und gehen hier nicht noch einmal darauf ein.

Mit der dritten Methode getAllShoppingMemos() lesen wir alle vorhandenen Datensätze aus der Tabelle unserer SQLite Datenbank aus. Dazu erzeugen wir gleich zu Beginn der Methode in Zeile 34 eine Liste, die ShoppingMemo-Objekt in sich aufnehmen kann.

Anschließend starten wir eine Suchanfrage in Zeile 36 und 37. Diesmal übergeben wir als Argumente nur den Namen der Tabelle und den Spalten-Array. Alle anderen Argumente sind null, d.h. auch der Such-String ist null, wodurch alle in der Tabelle existierenden Datensätze als Ergebnis zurückgeliefert werden.

In den Zeilen 39 und 40 setzen wir das erhaltenen Cursor-Objekt an seine erste Position und deklarieren eine Variable vom Typ ShoppingMemo.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Mit der while-Schleife in den Zeilen 42 bis 47 lesen wir alle Datensätze der Suchanfrage aus, wandeln sie in ShoppingMemo-Objekte um und fügen sie der ShoppingMemo-Liste hinzu. Mit der Log-Meldung können wir später in der Konsole überprüfen, welche Datensätze sich in der Tabelle befinden.

In Zeile 49 schließen wir den Cursor wieder. Dies ist eine ganz wichtige Anweisung und darf nicht vergessen werden! Am Ende der Methode geben wir die erzeugte ShoppingMemo-Liste, die alle Datensätze der Tabelle enthält, an die aufrufende Methode zurück.

2.4 Der komplette Quellcode der ShoppingMemoDataSource-Klasse

Nun haben wir alle Änderungen an der ShoppingMemoDataSource-Klasse vorgenommen und das Erstellen von Datensätzen in die Tabelle der Android SQLite Datenbank vorbereitet. Zudem können wir die eingetragenen Daten auch wieder auslesen.

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

In Android Studio sollte die ShoppingMemoDataSource.java Klassendatei nun wie folgt aussehen:

An dieser Stelle endet der freie Inhalt dieser Lektion. Wir hoffen, sie hat dir bis hierher gefallen! Du kannst sie im geschützten Bereich von ProgrammierenLernenHQ fortsetzen, in welchem sich alle Lektionen unserer Android Online-Kurse befinden.

Unsere Android Kurse bestehen aus insgesamt 43 großen Lektionen und sind unterteilt in 13 frei zugängliche und 30 Premium-Lektionen. Die Premium-Lektionen befinden sich in dem geschützten Bereich und sind nur für Käufer unserer Android Online-Kurse zugänglich.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813 An dieser Stelle endet der freie Inhalt dieser Lektion. Wir hoffen, sie hat dir bis hierher gefallen! Du kannst sie durch Kauf unseres Android Online-Kurs Gesamtpakets freischalten.

In unserem Android Online-Kurs Gesamtpaket befinden sich 43 große Lektionen, in denen wir dir schrittweise zeigen, wie voll funktionstüchtige Android Apps programmiert werden.

Diese Lektion ist Teil unserer Android Kurse. Insgesamt sind unsere Online-Kurse unterteilt in 13 frei zugängliche und 30 Premium-Lektionen.

Die Premium-Lektionen befinden sich in dem geschützten Bereich und sind nur für Käufer des Android Online-Kurs Gesamtpakets zugänglich.



Welche Inhalte befinden sich im Android Online-Kurs Gesamtpaket?

  • Das Gesamtpaket enthält alle Android Online-Kurse von ProgrammierenLernenHQ.
  • Im Paket enthalten ist unser großer Android Apps Programmieren Online-Kurs. Dieser besteht aus 35 großen Lektionen und ist als Einstiegskurs konzipiert worden. Die Grundlagen der Android App Entwicklung praxisnah und verständlich zu lehren, ist das Hauptziel des Android Apps Programmieren Kurses.
  • Im Paket enthalten ist auch unser SQLite Datenbank App Programmieren Online-Kurs. Dieser besteht aus 8 großen Lektionen und ist als weiterführender Kurs konzipiert worden. Der Kurs schließt an unseren Android Apps Programmieren Hauptkurs an und widmet sich dem speziellen Thema der SQLite Datenbanken.
  • Durch den Kauf erhältst du unbegrenzten Zugang zu all unseren Android Online-Kursen. Wir werden in Zukunft weitere Android Kurse hinzufügen. Auch auf alle zukünftigen Kurse erhältst du vollen Zugriff.

Wir hoffen, Dich bald als neuen Kursteilnehmer unserer Android Online-Kurse begrüßen zu dürfen!

Einmal kaufen und dadurch zeitlich unbegrenzten Zugriff auf alle Inhalte unserer Android Online-Kurse erhalten.



Hinweis: Der untere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernenHQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

android_sqlite_lektion4_blurry_a

Der obere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernenHQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

In der oberen Abbildung ist die überarbeitete ShoppingMemoDataSource.java Klassendatei dargestellt. Der bisherige Quellcode wurde an drei Stellen (Markierung A, B und C) erweitert.

Welche Bedeutung der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

  1. A – Die benötigten Import-Anweisungen zum Sichtbarmachen der Klassen bzw. Interfaces ContentValues, Cursor, ArrayList und List.
  2. B – Die Variable columns enthält die Namen der drei Spalten unserer Tabelle, die für die Suchanfragen benötigt werden.
  3. C – Die Methoden createShoppingMemo(), cursorToShoppingMemo() und getAllShoppingMemos() zum Schreiben in die Datenbank, Umwandeln eines Cursor– in ein ShoppingMemo-Objekt und Auslesen aller Datenbankeinträge für die Ausgabe in dem ListView unserer Android App.

Mit diesen Änderungen im Quellcode der ShoppingMemoDataSource-Klasse haben wir unsere Datenquelle um zwei sehr nützliche Funktionen erweitert. Wir können jetzt mit ihrer Hilfe Daten in die SQLite Datenbank schreiben und alle vorhandenen Datensätze aus der Datenbank auslesen.

Diese neuen Funktionen werden wir im nächsten Abschnitt nutzen und erstmals Datensätze in unsere Datenbank schreiben. Anschließend werden wir alle vorhandenen Datensätze unserer Datenbank auf dem Android Gerät im ListView der MainActivity ausgeben.

3. Inhalt der SQLite Datenbank im ListView ausgeben

Nun werden wir von der MainActivity aus Daten in die SQLite Datenbank schreiben. Die eingetragenen Daten werden wir anschließend wieder aus der Datenbank auslesen. Für beide Operationen nutzen wir die neuen Funktionen unserer Datenquelle.

Um dies zu realisieren nehmen wir diese drei Änderungen am Quellcode der Klasse MainActivity vor:

  1. Einfügen der Import-Anweisungen – Zuerst importieren wir die benötigten Klassen und Interfaces.
  2. Überarbeiten der onCreate() Methode – Hier fügen wir die Anweisungen für das Schreiben in die Datenbank und das Auslesen aus der Datenbank ein, zusammen mit einigen Log-Meldungen.
  3. Definieren der showAllListEntries() Methode – Diese Methode liest alle Datensätze aus der Tabelle unserer SQLite Datenbank aus und gibt die Einträge in dem ListView der MainActivity auf dem Android Gerät aus. Sie nutzt dazu die neuen Funktionen unserer Datenquelle.

Hinweis: 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 MainActivity-Klasse in Ruhe analysieren und direkt erkennen, an welcher Stelle welcher Code-Block eingefügt werden muss.

Nun beginnen wir mit dem ersten Arbeitsschritt.

3.1 Einfügen der Import-Anweisungen

Wir öffnen nun die Klassendatei MainActivity.java in dem Editor von Android Studio. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.shoppinglist unseres Projekts. Das Gerüst der Klasse haben wir bereits in der vorherigen Lektion des SQLite Tutorials angelegt.

Anschließend fügen wir den folgenden Quellcode unter den bereits vorhandenen Import-Anweisungen ein:

MainActivity.java

import android.widget.ArrayAdapter;
import android.widget.ListView;
import java.util.List;

Die drei Klassen bzw. Interfaces machen wir mittels Import-Anweisungen innerhalb der Klasse MainActivity sichtbar, so dass wir sie ohne den Namen ihres Packages verwenden können.

Die Klasse ArrayAdapter benötigen wir für das Verbinden des ListViews mit der ShoppingMemo-Liste, die alle Einträge aus der SQLite Datenbank enthält. Die ListView-Klasse für den ListView und das List-Interface für die ShoppingMemo-Liste.

3.2 Überarbeiten der onCreate() Methode der MainActivity

Im zweiten Arbeitsschritt überarbeiten wir die onCreate() Methode unserer MainActivity-Klasse. Wir werden von der onCreate() Methode aus Daten in die Datenbank schreiben und wieder auslesen lassen.

Den markierten Quellcode fügen wir nun in die onCreate() Methode der MainActivity.java ein:

Hinweis: Der untere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernenHQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

MainActivity.java

android_sqlite_table_mainactivity_blurry

In Zeile 14 schreiben wir Daten in die Datenbank. Dazu nutzen wir die createShoppingMemo() Methode unserer Datenquelle und lassen durch sie einen Testeintrag in die Tabelle der SQLite Datenbank einfügen.

In den Zeilen 15 und 16 geben wir zwei Log-Meldungen an die Konsole aus, in denen wir über den erfolgten Eintrag und dessen Inhalt informiert wird.

Anschließend lesen wir in Zeile 19 den Testeintrag mit der Hilfsmethode showAllListEntries() wieder aus der Datenbank aus. Die Hilfsmethode werden wir im dritten Arbeitsschritt erstellen.

3.3 Definieren der showAllListEntries() Methode

Als letzten Arbeitsschritt definieren wir die Hilfsmethode showAllListEntries() in der MainActivity-Klasse. Diese Methode liest für uns alle vorhandenen Datensätze aus der Tabelle unserer SQLite Datenbank aus und speichert diese in einer Liste als ShoppingMemo-Objekte ab.

Die Liste übergeben wir an einen ArrayAdapter, der für uns die Verwaltungsarbeit übernimmt. Die ausgelesenen Einträge lassen wir jeweils in einem vordefinierten Standardlayout, dem simple_list_item_multiple_choice, anzeigen.

Damit unsere Datenbankeinträge auch auf dem Android Gerät angezeigt werden, binden wir den ArrayAdapter an den ListView der MainActivity. Was ein ArrayAdapter im Detail macht, erklären wir sehr detailliert in unserem großen Android Apps Programmieren Kurs im fünften Kursmodul.

Jetzt fügen wir den folgenden Quellcode in den Methodenbereich der MainActivity.java-Klasse direkt nach der onCreate() Methode ein:

MainActivity.java

private void showAllListEntries () {
    List<ShoppingMemo> shoppingMemoList = dataSource.getAllShoppingMemos();

    ArrayAdapter<ShoppingMemo> shoppingMemoArrayAdapter = new ArrayAdapter<> (
            this,
            android.R.layout.simple_list_item_multiple_choice,
            shoppingMemoList);

    ListView shoppingMemosListView = (ListView) findViewById(R.id.listview_shopping_memos);
    shoppingMemosListView.setAdapter(shoppingMemoArrayAdapter);
}

In Zeile 2 rufen wir über unsere Datenquelle die Methode getAllShoppingMemos() auf, die uns alle Datenbankeinträge als Liste zurück liefert. Die Einträge dieser Liste sind vom Typ ShoppingMemo, unserem Datenmodell.

Mit den Zeilen 4 bis 7 erzeugen wir den ArrayAdapter und weisen ihm als Context die Instanz der MainActivity, als Layout für die Einträge das vordefinierte Standardlayout simple_list_item_multiple_choice und als Liste das shoppingMemoList Objekt zu.

Anschließend suchen wir in Zeilen 9 und 10 nach dem ListView des MainActivity-Layouts und binden den ArrayAdapter an das ListView-Objekt, wodurch unsere SQLite Datenbankeinträge auf dem Android Gerät angezeigt werden.

3.4 Der komplette Quellcode der MainActivity-Klasse

Nun haben wir alle Änderungen an der MainActivity-Klasse vorgenommen.

Durch den eingefügten Quellcode wird einen Testeintrag erstellt und zwar jedes Mal wenn unsere Activity erzeugt wird. Also auch beim Drehen des Android Geräts. Zudem lassen wir alle angelegten Datensätze aus der Tabelle der SQLite Datenbank auslesen und diese im ListView anzeigen.

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

In Android Studio sollte die MainActivity.java Klassendatei nun wie folgt aussehen:

Hinweis: Der untere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernenHQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

android_sqlite_lektion4_blurry_b

Der obere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernenHQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

In der oberen Abbildung ist die überarbeitete MainActivity.java Klassendatei dargestellt. Der bisherige Quellcode wurde an drei Stellen (Markierung A, B und C) erweitert.

Welche Bedeutung der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

  1. A – Die benötigten Import-Anweisungen zum Sichtbarmachen der Klassen bzw. Interfaces ArrayAdapter, ListView und List.
  2. B – Die in die onCreate() Methode eingefügten Anweisungen zum Schreiben eines Eintrags in die SQLite Datenbank und Aufrufen der showAllListEntries() Methode.
  3. C – Die showAllListEntries() Methode zum Auslesen aller Datensätze der Tabelle und Ausgeben dieser in dem ListView unserer Android App.

Mit diesen Änderungen im Quellcode der MainActivity-Klasse haben wir unsere SQLite App um zwei sehr nützliche Funktionen erweitert. Wir können jetzt Daten in die SQLite Datenbank unter Zuhilfenahme der Datenquelle schreiben und alle vorhandenen Datensätze aus der Datenbank auf dem Android Gerät ausgeben.

Im nächsten Abschnitt werden wir die neuen Funktionen unserer Android App testen und prüfen, ob die Daten korrekt in die Datenbank geschrieben werden.

4. Starten und Testen der Android SQLite App

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen und die Log-Meldungen unserer Anwendung im Logcat Tool Window überprüfen. Auf diese Weise können wir das Verhalten unserer App direkt in Android Studio analysieren und überprüfen, ob die Testdaten korrekt in die Tabelle unserer SQLite Datenbank eingetragen werden. Zusätzlich prüfen wir auch, ob die Einträge korrekt im ListView der MainActivity auf dem Android Gerät angezeigt werden.

Hinweis: Wenn ihr Probleme beim Ausführen der App im Android Emulator oder auf einem Android Gerät haben solltet, könnt ihr unseren großen Android Apps Programmieren Kurs als Hilfe nutzen. Darin zeigen wir, wie eine Android App im Emulator oder auf einem physikalischen Android Gerät ausgeführt wird.

Unsere App starten wir dazu wie gewohnt über den Run > Run 'app' Menüeintrag, den wir über die obere Menüleiste erreichen.

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

Hinweis: Das Emulator-Fenster mit dem darin laufenden Android Virtual Device muss für die nächsten Arbeitsschritte geöffnet bleiben. Zudem muss in dem AVD unsere eigene App ausgeführt werden. Sollte dies nicht der Fall sein, muss die App erneut im Emulator gestartet werden.

Um die Log-Meldungen zu überprüfen, öffnen wir in Android Studio das Logcat Tool Window während unsere App auf dem AVD im Emulator ausgeführt wird.

Dazu führen wir die folgenden Schritte aus:

  1. Wir öffnen das Logcat Tool Window mit einem Klick auf den Logcat-Tab am unteren Bildschirmrand.
  2. Anschließend wählen wir Emulator Nexus_9 als AVD in der Drop-Down Liste aus.
  3. Nun wählen wir unsere App de.codeyourapp.shoppinglist in der Liste rechts daneben aus.
  4. Danach stellen wir die Prioritätsstufe auf Verbose ein.
  5. Und geben in das anschließende Suchfeld MainActivity|ShoppingMemo als Suchbegriff ein.
  6. Zuletzt wählen wir den Eintrag Show only selected application in Liste ganz rechts aus.
android_sqlite_access_logcat_start

Überprüfen der Log-Meldungen unserer App im Logcat Tool Window von Android Studio

Uns werden die folgenden Log-Meldungen ausgegeben:

01: MainActivity﹕ Inhalt der Testmemo: 5 x Birnen
02: ShoppingMemoDataSource﹕ Unsere DataSource erzeugt jetzt den dbHelper.
03: ShoppingMemoDbHelper﹕ DbHelper hat die Datenbank: shopping_list.db erzeugt.
04: MainActivity﹕ Die Datenquelle wird geöffnet.
05: ShoppingMemoDataSource﹕ Eine Referenz auf die Datenbank wird jetzt angefragt.
06: ShoppingMemoDataSource﹕ Datenbank-Referenz erhalten. Pfad zur Datenbank: /data/user/0/de.codeyourapp.shoppinglist/databases/shopping_list.db
07: MainActivity﹕ Es wurde der folgende Eintrag in die Datenbank geschrieben:
08: MainActivity﹕ ID: 1, Inhalt: 2 x Testprodukt
09: MainActivity﹕ Folgende Einträge sind in der Datenbank vorhanden:
10: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 2 x Testprodukt
11: MainActivity﹕ Die Datenquelle wird geschlossen.
12: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Die sechs ersten Log-Meldungen haben wir bereits in der vorherigen Lektion überprüft, ebenso wie die letzten beiden Meldungen. Neu hinzugekommen sind die Meldungen 7 bis 10.

Die Meldung 8 informiert uns über die ID und den Inhalt des eben eingetragenen Datensatzes. Die ausgegebenen Werte entsprechen den Werten in der Tabelle unserer SQLite Datenbank, da wir sie nach dem Eintragen in die Tabelle sofort wieder ausgelesen und mit den ausgelesenen Werten das ShoppingMemo-Objekt erstellt haben.

Mit den Meldungen 9 und 10 geben wir den Inhalt unserer SQLite Datenbank aus. Momentan ist nur ein Datensatz in der Tabelle der Datenbank vorhanden, daher wird auch nur ein Eintrag zurückgeliefert. Dies werden wir nun ändern.

Wir erzeugen nun weitere Datenbankeinträge, indem wir die MainActivity zerstören und neu erstellen lassen. Dabei wird jedes Mal die onCreate() Methode der MainActivity-Klasse aufgerufen und somit jeweils ein Testeintrag in die SQLite Datenbank geschrieben.

Die MainActivity können wir durch Drehen des Android Devices zerstören und neu erstellen, das liegt an dem Activity Lifecycle vom Android System. Welche Zustände eine Activity in ihrem Leben durchläuft solltet ihr unbedingt hier: Der Activity und Fragment Lifecycle in Android nachlesen.

Wir könnten aber auch die SQLite App mittels Back-Button vollständig beenden und anschließend neu starten. Egal welchen Weg wir wählen, es wird dabei immer beim Erzeugen der MainActivity ein Eintrag in die SQLite Datenbank erstellt.

Nach mehrfachem Drehen des Android Geräts werden uns die folgenden Log-Meldungen ausgegeben:

android_sqlite_access_logcat_end

Es wurden 5 Einträge in die SQLite Datenbank geschrieben

Diesmal werden uns die folgenden Log-Meldungen ausgegeben:

01: MainActivity﹕ Inhalt der Testmemo: 5 x Birnen
02: ShoppingMemoDataSource﹕ Unsere DataSource erzeugt jetzt den dbHelper.
03: ShoppingMemoDbHelper﹕ DbHelper hat die Datenbank: shopping_list.db erzeugt.
04: MainActivity﹕ Die Datenquelle wird geöffnet.
05: ShoppingMemoDataSource﹕ Eine Referenz auf die Datenbank wird jetzt angefragt.
06: ShoppingMemoDataSource﹕ Datenbank-Referenz erhalten. Pfad zur Datenbank: /data/user/0/de.codeyourapp.shoppinglist/databases/shopping_list.db
07: MainActivity﹕ Es wurde der folgende Eintrag in die Datenbank geschrieben:
08: MainActivity﹕ ID: 5, Inhalt: 2 x Testprodukt
09: MainActivity﹕ Folgende Einträge sind in der Datenbank vorhanden:
10: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 2 x Testprodukt
11: ShoppingMemoDataSource﹕ ID: 2, Inhalt: 2 x Testprodukt
12: ShoppingMemoDataSource﹕ ID: 3, Inhalt: 2 x Testprodukt
13: ShoppingMemoDataSource﹕ ID: 4, Inhalt: 2 x Testprodukt
14: ShoppingMemoDataSource﹕ ID: 5, Inhalt: 2 x Testprodukt
15: MainActivity﹕ Die Datenquelle wird geschlossen.
16: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Es hat sich nicht viel gegenüber dem vorherigen Output geändert. Neu hinzugekommen sind Log-Meldungen 11 bis 14, die uns über den Inhalt der Datenbank informieren.

Anhand der ausgegebenen Meldungen können wir feststellen, dass unsere App die Testeinträge korrekt in die Datenbank schreibt und wieder aus ihr ausliest. Auch die ID wird als laufende Nummer automatisch bei jedem neuen Datensatz um 1 erhöht, so wie es sein soll.

Die Log-Meldungen helfen uns dabei die Korrektheit unseres Quellcodes sicherzustellen, sie sind jedoch für unsere Anwender nicht sichtbar. Wir werden nun die grafische Oberfläche unserer SQLite App testen und überprüfen, welche Daten auf dem Display ausgegeben werden.

In der unteren Abbildung ist das User Interface unsere SQLite App auf dem Android Virtual Device im Emulator zu sehen:

android_sqlite_app_access

Unsere SQLite App zeigt den Inhalt der ihrer Datenbank an

Die Datensätze in der Tabelle unserer SQLite Datenbank werden im ListView der MainActivity angezeigt.

Durch Ändern der Bildschirmorientierung (Drehen des Android Geräts) lassen wir automatisch einen neuen Testeintrag in die Datenbank erstellen. Diese Funktion werden wir in der nächsten Lektion durch eine, für die Nutzer, sinnvolle Funktion ersetzen. Momentan dient sie uns aber sehr gut zu Testzwecken.

Die einzelnen Listeneinträge können zwar bereits angeklickt werden, reagieren jedoch noch nicht darauf. Auch der + Button reagiert noch nicht auf Benutzereingaben.

Dies werden wir in der nächsten Lektion ändern und das User Interface auf Benutzereingaben reagieren lassen, so dass es möglich ist eigene echte Einträge in die Datenbank der Einkaufslisten-App zu schreiben.

Wenn bei euch die gleichen Log-Meldungen ausgegeben werden und ihr die Einträge der Datenbank auch auf dem Display eures Android Geräts oder dem Android Emulator angezeigt bekommt, habt ihr alle Arbeitsschritte korrekt umgesetzt.

Eure App speichert dann die Daten korrekt in die Tabelle der SQLite Datenbank ab. In der nächsten Lektion des Android SQLite Tutorials können wir nun die grafische Benutzeroberfläche mit Funktionalität füllen.

Zusammenfassung

In dieser Lektion unseres Android SQLite Tutorials haben wir Datensätze in die Tabelle der SQLite Datenbank geschrieben. Die Datensätze haben wir anschließend wieder ausgelesen und im ListView der MainActivity ausgegeben. Um dies zu erreichen, haben wir die folgenden beiden Klassen unseres Android Projekts überarbeitet:

  • ShoppingMemoDataSource – Wir benutzen diese Klasse als Datenquelle, die eine Verbindung zur SQLite Datenbank aufrecht hält und für alle Lese- und Schreib-Zugriffe verantwortlich ist. In dieser Lektion haben wir ihr drei Methoden hinzugefügt, mit denen wir nun Daten in die Datenbank schreiben und aus ihr wieder auslesen können.
  • MainActivity – Mit unserer Hauptklasse steuern wir die Datenbankzugriffe und verwalten die Elemente der grafischen Benutzeroberfläche unserer SQLite App. In dieser Lektion haben wir von der MainActivity aus Daten in die SQLite Datenbank schreiben und aus ihr auslesen lassen, unter Zuhilfenahme unserer Datenquelle.

Abschließend haben wir die neuen Funktionen unserer Android SQLite App überprüft und dadurch sichergestellt, dass die Datensätze korrekt in die Datenbank geschrieben werden.

Wir sind nun bei der Entwicklung unserer Android SQLite App einen großen Schritt weiter gekommen. Unsere Einkaufslisten-App kann jetzt Daten in die Datenbank schreiben, diese auslesen und auf dem Display ausgeben. Bisher aber nur Testdaten.

Daher werden wir in der nächsten Lektion unseres SQLite Tutorials die Bedienelemente unserer Android App so überarbeiten, dass sie auf Eingaben der User reagieren. Dadurch wird unsere SQLite App in der Lage sein echte Daten in die Datenbank zu schreiben und somit erstmals sinnvoll nutzbar sein.



Comments 71

  1. Super Tutorial, jedoch, warum liegt du den Code der dafür da ist ein neues Product hinzuzufügen in onCreate() von mainActivity ? Dadurch wir immer wenn die App gestarted wird, ein neues Produkt der Datenbank hinzugefügt, so dass Duplikate auftrete, wäre es nicht besser, eine Check durchzuführen, ob gleich viele Elemente hinzugefügt werden sollen wie in der Datenbank drin sind und falls nein(App wird zum ersten mal geöffnet) dann die Datenbank beschreiben und sonst einfach die bestehenden Werte unverändert lässt.

    1. Post
      Author

      Hallo Florian,

      danke für dein Lob!

      Der Code in der onCreate() Methode dient in Teil 4 unseres Android SQLite Tutorials nur zu Testzwecken. Der Testcode wird bereits im nächsten Teil gelöscht, wenn die Callback-Methoden onPause() und onResume() erstellt werden. Dabei wird die onCreate() Methode bereinigt.

      Viele Grüße, Chris

  2. Sehr schöne Anleitung! Es gelingt auch gleich eine andere Tabelle zu erstellen (bei meinen wenigen SQLITE Kenntnissen aus Delphi).

    Ich habe 2 Anmerkungen:
    Bei Punkt 2.4 in Zeile 68 ist ein kleiner Fehler (den man aber schnell bemerkt):
    Statt
    ShoppingMemo shoppingMemo = new ShoppingMemo(product, quantity, id);
    muss es sein:
    ShoppingMemo shoppingMemo = new ShoppingMemo(id, product, quantity);
    [Reihung der Parameter nicht korrekt]

    Dann noch eine Anmerkung:
    Ich mag es nicht, wenn das Telefon die Datenbank irgendwo tief bei der App versteckt. Daher habe ich meiner App einen Pfad, den ich selbst bestimme, hinzugefügt, der jedes Mal beim Start aus einer Datei gelesen wird. Da hat es mich dann etwas Zeit gekostet herauszufinden, wie ich diesen Pfad als Parameter in die DbHelper (bei der Definition des DB_NAME) übergeben kann. Letztlich habe ich die Variable path in der Main Activity als static definiert und mittels MainActivity.path übergeben. Ich dachte schon ich scheitere da, weil in DBHelper, die Variable ja final ist. Funktioniert so aber! UNd ich habe etwas gelernt.
    Nochmals: VIELEN DANK!

    1. Post
      Author

      Hallo Cord,

      vielen Dank für’s Lob und deine beiden Hinweise!

      Hinweis 1: Ich habe Zeile 68 noch einmal genau überprüft. Es muss ShoppingMemo shoppingMemo = new ShoppingMemo(product, quantity, id); heißen, da der Konstruktor unseres Datenmodells ShoppingMemo die Parameter genau in dieser Reihenfolge erwartet: (produkt, quantity, id).

      Hinweis 2: Sehr interessant! Ich habe den Pfad zur Datenbank immer so belassen, wie er standardmäßig vom Android System vorgegeben wird.

      Viele Grüße, Chris

  3. Hallo,

    super Tutorials!
    Aber ich habe ein Problem: ich benötige als Suchkriterium eine übergebene String-Variable. Allerdings bekomme ich bei der Ausführung immer eine exception, syntax error, code 1.

    Wie ist es denn möglich, als Suchkriterium nicht die ID, sondern eine String-Variable zu verwenden?

  4. Danke! Habe selten so gut aufbereite Lernkurse gesehen, und das auch noch gratis…
    Weiter so.

    1. Post
      Author
  5. Zusatz: getAllShoppingMemos funktioniert. Also funktioniert wohl der insert-Befehl. Der Fehler tritt in createShoppingMemo auf -> insert Ok, query -> count 0.

  6. Hi. Auch von mir erstmal ein großes Kompliment für das ausführliche Tutorial. Alles super nachvollziehbar.

    Ich habe dennoch ein Problem mit dem Einfügen des ersten Test-Datensatzes:

    Der insert-Befehl liefert 1 zurück. Wenn ich danach aber den query abschicke und den cursor auswerte, sind keine Daten drin und getcount ist 0. Ich habe den query schon abgewandelt, so dass er alle Daten abfragen soll, dennoch bleibt es bei 0. Ich lasse die App unter Android 7.1.1 Nougat api 25 revision 3 emuliert laufen. Gibt es da Probleme?

    VG Martin

  7. Weiß zwar nicht, ob ich noch eine Antwort erhalten werde, aber folgendes Problem:
    Ich habe bis einschließlich dieses Teil 4 des Tutorials alles 1:1 in Android nachempfunden, allerdings stürzt die App bei mir immer ab. Die letzte korrekt ausgeführte Codezeile ist die „long insertId = database.insert(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST, null, values);“ aus der ShoppingMemoDataSource.java. Dies habe ich mit mehreren normalen Log.d.-Nachrichten überprüfen können.
    Das heißt das Programm steigt beim erstellen des Cursor cursor (…) Objekts aus. Woran könnte das liegen? Ich habe alles genauso gemacht, wie hier in dem Tutorial beschrieben..
    Android Version ist: 2.3.3

    Vielen Dank für die Antworten..

  8. Hi!
    Danke für Deinen Tutorial! Ist sehr ausführlich und schön geschrieben. Ich finde es auch echt gut, dass Du Dir die Zeit genommen hast und alle Schritte mit Screenshots unterlegt hast!

    Eine kleine Ergänzung habe ich dennoch. Du schreibst
    „In Zeile 49 schließen wir den Cursor wieder. Dies ist eine ganz wichtige Anweisung und darf nicht vergessen werden!“

    Aus diesem Grund würde ich es immer im finally-Block machen.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.