Zapisz dane przy użyciu SQLite

Zapisywanie danych w bazie danych jest idealne w przypadku powtarzających się lub uporządkowanych danych, takich jak informacje kontaktowe. Na tej stronie zakładamy, że znasz bazy danych SQL i chcesz zacząć korzystać z baz danych SQLite na Androidzie. Interfejsy API, których potrzebujesz do korzystania z bazy danych na Androidzie, są dostępne w pakiecie android.database.sqlite.

Uwaga: chociaż te interfejsy API są zaawansowane, są dość niskiego poziomu i wymagają dużo czasu i wysiłku:

  • Nie ma weryfikacji nieprzetworzonych zapytań SQL w czasie kompilowania. W miarę zmian w grafie danych musisz ręcznie aktualizować zapytania SQL, których dotyczą te zmiany. Ten proces może być czasochłonny i podatny na błędy.
  • Do konwersji między zapytaniami SQL a obiektami danych musisz używać wielu powtarzalnych kodów.

Z tych powodów zdecydowanie zalecamy używanie biblioteki trwałości danych Room jako warstwy abstrakcji umożliwiającej dostęp do informacji w bazach danych SQLite aplikacji.

Definiowanie schematu i umowy

Jedną z głównych zasad baz danych SQL jest schemat, czyli formalna deklaracja sposobu organizacji bazy danych. Schemat jest odzwierciedlony w instrukcjach SQL, których używasz do utworzenia bazy danych. Pomocne może być utworzenie klasy towarzyszącej, zwanej klasą kontraktową, która wyraźnie określa układ schematu w systematyczny i samodokumentujący się sposób.

Klasa kontraktowa to kontener na stałe, które definiują nazwy identyfikatorów URI, tabel i kolumn. Klasa kontraktowa pozwala używać tych samych stałych we wszystkich innych klasach w tym samym pakiecie. Dzięki temu możesz zmienić nazwę kolumny w jednym miejscu i zastosować ją w całym kodzie.

Dobrym sposobem na uporządkowanie klasy kontraktowej jest umieszczenie definicji, które są globalne dla całej bazy danych, na poziomie głównym klasy. Następnie utwórz klasę wewnętrzną dla każdej tabeli. Każda klasa wewnętrzna wylicza kolumny odpowiedniej tabeli.

Uwaga: dzięki implementacji interfejsu BaseColumns klasa wewnętrzna może dziedziczyć pole klucza podstawowego o nazwie _ID, którego oczekują niektóre klasy Androida, takie jak CursorAdapter. Nie jest to wymagane, ale może pomóc bazie danych harmonijnie współpracować z platformą Androida.

Na przykład ta umowa definiuje nazwę tabeli i nazwy kolumn dla pojedynczej tabeli reprezentującej kanał RSS:

Kotlin

object FeedReaderContract {
    // Table contents are grouped together in an anonymous object.
    object FeedEntry : BaseColumns {
        const val TABLE_NAME = "entry"
        const val COLUMN_NAME_TITLE = "title"
        const val COLUMN_NAME_SUBTITLE = "subtitle"
    }
}

Java

public final class FeedReaderContract {
    // To prevent someone from accidentally instantiating the contract class,
    // make the constructor private.
    private FeedReaderContract() {}

    /* Inner class that defines the table contents */
    public static class FeedEntry implements BaseColumns {
        public static final String TABLE_NAME = "entry";
        public static final String COLUMN_NAME_TITLE = "title";
        public static final String COLUMN_NAME_SUBTITLE = "subtitle";
    }
}

Tworzenie bazy danych za pomocą pomocnika SQL

Po zdefiniowaniu wyglądu bazy danych należy wdrożyć metody, które tworzą i utrzymują bazę danych oraz tabele. Oto kilka typowych instrukcji, które tworzą i usuwają tabelę:

Kotlin

private const val SQL_CREATE_ENTRIES =
        "CREATE TABLE ${FeedEntry.TABLE_NAME} (" +
                "${BaseColumns._ID} INTEGER PRIMARY KEY," +
                "${FeedEntry.COLUMN_NAME_TITLE} TEXT," +
                "${FeedEntry.COLUMN_NAME_SUBTITLE} TEXT)"

private const val SQL_DELETE_ENTRIES = "DROP TABLE IF EXISTS ${FeedEntry.TABLE_NAME}"

Java

private static final String SQL_CREATE_ENTRIES =
    "CREATE TABLE " + FeedEntry.TABLE_NAME + " (" +
    FeedEntry._ID + " INTEGER PRIMARY KEY," +
    FeedEntry.COLUMN_NAME_TITLE + " TEXT," +
    FeedEntry.COLUMN_NAME_SUBTITLE + " TEXT)";

private static final String SQL_DELETE_ENTRIES =
    "DROP TABLE IF EXISTS " + FeedEntry.TABLE_NAME;

Podobnie jak pliki zapisywane w pamięci wewnętrznej urządzenia, Android przechowuje bazę danych w prywatnym folderze aplikacji. Twoje dane są bezpieczne, ponieważ domyślnie ten obszar nie jest dostępny dla innych aplikacji ani użytkownika.

Klasa SQLiteOpenHelper zawiera przydatny zestaw interfejsów API do zarządzania bazą danych. Gdy używasz tej klasy do uzyskiwania odwołań do bazy danych, system wykonuje potencjalnie długo trwające operacje tworzenia i aktualizowania bazy danych tylko wtedy, gdy jest to konieczne, a nie podczas uruchamiania aplikacji. Wystarczy, że zadzwonisz pod numer getWritableDatabase() lub getReadableDatabase().

Uwaga: ponieważ te operacje mogą być długotrwałe, pamiętaj, aby wywoływać getWritableDatabase() lub getReadableDatabase() w wątku w tle. Więcej informacji znajdziesz w artykule Wątki na Androidzie.

Aby użyć SQLiteOpenHelper, utwórz podklasę, która zastępuje metody wywołania zwrotnego onCreate() i onUpgrade(). Możesz też zaimplementować metody onDowngrade() lub onOpen(), ale nie jest to wymagane.

Oto przykład implementacji SQLiteOpenHelper, która używa niektórych z powyższych poleceń:

Kotlin

class FeedReaderDbHelper(context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL(SQL_CREATE_ENTRIES)
    }
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        // This database is only a cache for online data, so its upgrade policy is
        // to simply to discard the data and start over
        db.execSQL(SQL_DELETE_ENTRIES)
        onCreate(db)
    }
    override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        onUpgrade(db, oldVersion, newVersion)
    }
    companion object {
        // If you change the database schema, you must increment the database version.
        const val DATABASE_VERSION = 1
        const val DATABASE_NAME = "FeedReader.db"
    }
}

Java

public class FeedReaderDbHelper extends SQLiteOpenHelper {
    // If you change the database schema, you must increment the database version.
    public static final int DATABASE_VERSION = 1;
    public static final String DATABASE_NAME = "FeedReader.db";

    public FeedReaderDbHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(SQL_CREATE_ENTRIES);
    }
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // This database is only a cache for online data, so its upgrade policy is
        // to simply to discard the data and start over
        db.execSQL(SQL_DELETE_ENTRIES);
        onCreate(db);
    }
    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        onUpgrade(db, oldVersion, newVersion);
    }
}

Aby uzyskać dostęp do bazy danych, utwórz instancję podklasy SQLiteOpenHelper:

Kotlin

val dbHelper = FeedReaderDbHelper(context)

Java

FeedReaderDbHelper dbHelper = new FeedReaderDbHelper(getContext());

umieszczanie informacji w bazie danych,

Wstaw dane do bazy danych, przekazując obiekt ContentValues do metody insert():

Kotlin

// Gets the data repository in write mode
val db = dbHelper.writableDatabase

// Create a new map of values, where column names are the keys
val values = ContentValues().apply {
    put(FeedEntry.COLUMN_NAME_TITLE, title)
    put(FeedEntry.COLUMN_NAME_SUBTITLE, subtitle)
}

// Insert the new row, returning the primary key value of the new row
val newRowId = db?.insert(FeedEntry.TABLE_NAME, null, values)

Java

// Gets the data repository in write mode
SQLiteDatabase db = dbHelper.getWritableDatabase();

// Create a new map of values, where column names are the keys
ContentValues values = new ContentValues();
values.put(FeedEntry.COLUMN_NAME_TITLE, title);
values.put(FeedEntry.COLUMN_NAME_SUBTITLE, subtitle);

// Insert the new row, returning the primary key value of the new row
long newRowId = db.insert(FeedEntry.TABLE_NAME, null, values);

Pierwszym argumentem funkcji insert() jest nazwa tabeli.

Drugi argument informuje platformę, co ma zrobić, gdy ContentValues jest puste (czyli nie put żadnych wartości). Jeśli podasz nazwę kolumny, platforma wstawi wiersz i ustawi wartość tej kolumny na null. Jeśli określisz null, jak w tym przykładowym kodzie, platforma nie wstawi wiersza, gdy nie będzie żadnych wartości.

Metoda insert() zwraca identyfikator nowo utworzonego wiersza lub –1, jeśli podczas wstawiania danych wystąpił błąd. Może się tak zdarzyć, jeśli występuje konflikt z danymi, które już znajdują się w bazie danych.

odczytywanie informacji z bazy danych,

Aby odczytać dane z bazy danych, użyj metody query(), przekazując jej kryteria wyboru i wybrane kolumny. Metoda ta łączy elementy insert() i update(), ale lista kolumn definiuje dane, które chcesz pobrać („projekcja”), a nie dane do wstawienia. Wyniki zapytania są zwracane w obiekcie Cursor.

Kotlin

val db = dbHelper.readableDatabase

// Define a projection that specifies which columns from the database
// you will actually use after this query.
val projection = arrayOf(BaseColumns._ID, FeedEntry.COLUMN_NAME_TITLE, FeedEntry.COLUMN_NAME_SUBTITLE)

// Filter results WHERE "title" = 'My Title'
val selection = "${FeedEntry.COLUMN_NAME_TITLE} = ?"
val selectionArgs = arrayOf("My Title")

// How you want the results sorted in the resulting Cursor
val sortOrder = "${FeedEntry.COLUMN_NAME_SUBTITLE} DESC"

val cursor = db.query(
        FeedEntry.TABLE_NAME,   // The table to query
        projection,             // The array of columns to return (pass null to get all)
        selection,              // The columns for the WHERE clause
        selectionArgs,          // The values for the WHERE clause
        null,                   // don't group the rows
        null,                   // don't filter by row groups
        sortOrder               // The sort order
)

Java

SQLiteDatabase db = dbHelper.getReadableDatabase();

// Define a projection that specifies which columns from the database
// you will actually use after this query.
String[] projection = {
    BaseColumns._ID,
    FeedEntry.COLUMN_NAME_TITLE,
    FeedEntry.COLUMN_NAME_SUBTITLE
    };

// Filter results WHERE "title" = 'My Title'
String selection = FeedEntry.COLUMN_NAME_TITLE + " = ?";
String[] selectionArgs = { "My Title" };

// How you want the results sorted in the resulting Cursor
String sortOrder =
    FeedEntry.COLUMN_NAME_SUBTITLE + " DESC";

Cursor cursor = db.query(
    FeedEntry.TABLE_NAME,   // The table to query
    projection,             // The array of columns to return (pass null to get all)
    selection,              // The columns for the WHERE clause
    selectionArgs,          // The values for the WHERE clause
    null,                   // don't group the rows
    null,                   // don't filter by row groups
    sortOrder               // The sort order
    );

Trzeci i czwarty argument (selection i selectionArgs) są łączone w celu utworzenia klauzuli WHERE. Argumenty są podawane oddzielnie od zapytania wyboru, więc przed połączeniem są one uciekane. Dzięki temu instrukcje wyboru są odporne na wstrzyknięcie kodu SQL. Więcej informacji o wszystkich argumentach znajdziesz w dokumentacji query().

Aby wyświetlić wiersz w kursorze, użyj jednej z metod przenoszenia Cursor, którą musisz zawsze wywołać przed rozpoczęciem odczytywania wartości. Kursor zaczyna się od pozycji -1, więc wywołanie moveToNext() ustawia „pozycję odczytu” na pierwszym wpisie w wynikach i zwraca informację, czy kursor przekroczył już ostatni wpis w zbiorze wyników. Wartość kolumny w każdym wierszu możesz odczytać, wywołując jedną z metod get Cursor, np. getString() lub getLong(). W przypadku każdej metody get musisz przekazać pozycję indeksu kolumny, którą chcesz uzyskać. Możesz ją uzyskać, wywołując metodę getColumnIndex() lub getColumnIndexOrThrow(). Po zakończeniu iteracji wyników wywołaj close() na kursorze, aby zwolnić jego zasoby. Na przykład poniżej pokazano, jak pobrać wszystkie identyfikatory produktów przechowywane w kursorze i dodać je do listy:

Kotlin

val itemIds = mutableListOf<Long>()
with(cursor) {
    while (moveToNext()) {
        val itemId = getLong(getColumnIndexOrThrow(BaseColumns._ID))
        itemIds.add(itemId)
    }
}
cursor.close()

Java

List itemIds = new ArrayList<>();
while(cursor.moveToNext()) {
  long itemId = cursor.getLong(
      cursor.getColumnIndexOrThrow(FeedEntry._ID));
  itemIds.add(itemId);
}
cursor.close();

Usuwanie informacji z bazy danych

Aby usunąć wiersze z tabeli, musisz podać kryteria wyboru, które identyfikują wiersze dla metody delete(). Mechanizm działa tak samo jak argumenty wyboru metody query(). Dzieli specyfikację wyboru na klauzulę wyboru i argumenty wyboru. Klauzula definiuje kolumny, które mają być sprawdzane, i umożliwia łączenie testów kolumn. Argumenty to wartości, które są sprawdzane i powiązane z klauzulą. Wynik nie jest traktowany tak samo jak zwykła instrukcja SQL, więc jest odporny na wstrzykiwanie kodu SQL.

Kotlin

// Define 'where' part of query.
val selection = "${FeedEntry.COLUMN_NAME_TITLE} LIKE ?"
// Specify arguments in placeholder order.
val selectionArgs = arrayOf("MyTitle")
// Issue SQL statement.
val deletedRows = db.delete(FeedEntry.TABLE_NAME, selection, selectionArgs)

Java

// Define 'where' part of query.
String selection = FeedEntry.COLUMN_NAME_TITLE + " LIKE ?";
// Specify arguments in placeholder order.
String[] selectionArgs = { "MyTitle" };
// Issue SQL statement.
int deletedRows = db.delete(FeedEntry.TABLE_NAME, selection, selectionArgs);

Wartość zwracana przez metodę delete() wskazuje liczbę wierszy usuniętych z bazy danych.

Aktualizowanie bazy danych

Jeśli chcesz zmodyfikować podzbiór wartości bazy danych, użyj metody update().

Aktualizacja tabeli łączy składnię ContentValues instrukcji insert() ze składnią WHERE instrukcji delete().

Kotlin

val db = dbHelper.writableDatabase

// New value for one column
val title = "MyNewTitle"
val values = ContentValues().apply {
    put(FeedEntry.COLUMN_NAME_TITLE, title)
}

// Which row to update, based on the title
val selection = "${FeedEntry.COLUMN_NAME_TITLE} LIKE ?"
val selectionArgs = arrayOf("MyOldTitle")
val count = db.update(
        FeedEntry.TABLE_NAME,
        values,
        selection,
        selectionArgs)

Java

SQLiteDatabase db = dbHelper.getWritableDatabase();

// New value for one column
String title = "MyNewTitle";
ContentValues values = new ContentValues();
values.put(FeedEntry.COLUMN_NAME_TITLE, title);

// Which row to update, based on the title
String selection = FeedEntry.COLUMN_NAME_TITLE + " LIKE ?";
String[] selectionArgs = { "MyOldTitle" };

int count = db.update(
    FeedReaderDbHelper.FeedEntry.TABLE_NAME,
    values,
    selection,
    selectionArgs);

Wartość zwracana przez metodę update() to liczba wierszy, których dotyczy zmiana w bazie danych.

Utrzymywanie połączenia z bazą danych

Ponieważ wywoływanie metod getWritableDatabase() i getReadableDatabase() przy zamkniętej bazie danych jest kosztowne, połączenie z bazą danych powinno być otwarte tak długo, jak długo potrzebujesz do niej dostępu. Zwykle optymalnym rozwiązaniem jest zamknięcie bazy danych w metodzie onDestroy() wywołującej aktywności.

Kotlin

override fun onDestroy() {
    dbHelper.close()
    super.onDestroy()
}

Java

@Override
protected void onDestroy() {
    dbHelper.close();
    super.onDestroy();
}

Debugowanie bazy danych

Pakiet Android SDK zawiera narzędzie powłoki sqlite3, które umożliwia przeglądanie zawartości tabel, uruchamianie poleceń SQL i wykonywanie innych przydatnych funkcji w bazach danych SQLite. Więcej informacji znajdziesz w artykule o wydawaniu poleceń powłoki.