Android: aktualizacja wersji DB i dodanie nowej tabeli

Twój kod wygląda poprawnie. Sugeruję, że baza myśli, że jest ulepszona. Jeśli wykonałeś projekt po zwiększeniu numeru wersji, ale przed dodaniem wywołania execSQL, baza danych na Twoim urządzeniu testowym / emulatorze może już wierzyć, że jest w wersji 2.

Szybkim sposobem, aby to zweryfikować, byłaby zmiana numeru wersji na 3-Jeśli uaktualni się po tym, wiesz, że było to tylko dlatego, że Twoje urządzenie wierzyło, że zostało już zaktualizowane.

Możesz użyć metody sqliteopenhelper onUpgrade. W metodzie onUpgrade otrzymujesz oldVersion jako jeden z parametrów.

W onUpgrade Użyj switch, a w każdym z case Użyj numeru wersji, aby śledzić bieżącą wersję bazy danych.

Najlepiej jest przełączyć się z oldVersion do newVersion, zwiększając version o 1 na raz, a następnie krok po kroku aktualizować bazę danych. Jest to bardzo pomocne, gdy ktoś z bazy danych w wersji 1 aktualizuje aplikację po długim czasie, do wersja korzystająca z bazy danych w wersji 7 i aplikacja zaczyna się zawieszać z powodu pewnych niekompatybilnych zmian.

Następnie aktualizacje w bazie danych będą wykonywane krok po kroku, obejmując wszystkie możliwe przypadki, tj. włączając zmiany w bazie danych wykonane dla każdej nowej wersji i tym samym zapobiegając awarii aplikacji.

Na przykład:

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    switch (oldVersion) {
    case 1:
        String sql = "ALTER TABLE " + TABLE_SECRET + " ADD COLUMN " + "name_of_column_to_be_added" + " INTEGER";
        db.execSQL(sql);
        break;

    case 2:
        String sql = "SOME_QUERY";
        db.execSQL(sql);
        break;
    }

}

@ Jkschneider ' s answer is right. Istnieje jednak lepsze podejście.

Zapisz potrzebne zmiany w pliku sql dla każdej aktualizacji, jak opisano w linku https://riggaroo.co.za/android-sqlite-database-use-onupgrade-correctly/

From_1_to_2.sql

ALTER TABLE books ADD COLUMN book_rating INTEGER;

From_2_to_3.sql

ALTER TABLE books RENAME TO book_information;

From_3_to_4.sql

ALTER TABLE book_information ADD COLUMN calculated_pages_times_rating INTEGER;
UPDATE book_information SET calculated_pages_times_rating = (book_pages * book_rating) ;

DatabaseHelper.java

public class DatabaseHelper extends SQLiteOpenHelper {

    private static final int DATABASE_VERSION = 4;

    private static final String DATABASE_NAME = "database.db";
    private static final String TAG = DatabaseHelper.class.getName();

    private static DatabaseHelper mInstance = null;
    private final Context context;

    private DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        this.context = context;
    }

    public static synchronized DatabaseHelper getInstance(Context ctx) {
        if (mInstance == null) {
            mInstance = new DatabaseHelper(ctx.getApplicationContext());
        }
        return mInstance;
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(BookEntry.SQL_CREATE_BOOK_ENTRY_TABLE);
        // The rest of your create scripts go here.

    }


    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.e(TAG, "Updating table from " + oldVersion + " to " + newVersion);
        // You will not need to modify this unless you need to do some android specific things.
        // When upgrading the database, all you need to do is add a file to the assets folder and name it:
        // from_1_to_2.sql with the version that you are upgrading to as the last version.
        try {
            for (int i = oldVersion; i < newVersion; ++i) {
                String migrationName = String.format("from_%d_to_%d.sql", i, (i + 1));
                Log.d(TAG, "Looking for migration file: " + migrationName);
                readAndExecuteSQLScript(db, context, migrationName);
            }
        } catch (Exception exception) {
            Log.e(TAG, "Exception running upgrade script:", exception);
        }

    }

    @Override
    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    private void readAndExecuteSQLScript(SQLiteDatabase db, Context ctx, String fileName) {
        if (TextUtils.isEmpty(fileName)) {
            Log.d(TAG, "SQL script file name is empty");
            return;
        }

        Log.d(TAG, "Script found. Executing...");
        AssetManager assetManager = ctx.getAssets();
        BufferedReader reader = null;

        try {
            InputStream is = assetManager.open(fileName);
            InputStreamReader isr = new InputStreamReader(is);
            reader = new BufferedReader(isr);
            executeSQLScript(db, reader);
        } catch (IOException e) {
            Log.e(TAG, "IOException:", e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    Log.e(TAG, "IOException:", e);
                }
            }
        }

    }

    private void executeSQLScript(SQLiteDatabase db, BufferedReader reader) throws IOException {
        String line;
        StringBuilder statement = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            statement.append(line);
            statement.append("\n");
            if (line.endsWith(";")) {
                db.execSQL(statement.toString());
                statement = new StringBuilder();
            }
        }
    }
}

Przykładowy projekt znajduje się również w tym samym linku: https://github.com/riggaroo/AndroidDatabaseUpgrades

Obsługa wersji baz danych jest bardzo ważną częścią tworzenia aplikacji. Zakładam, że masz już klasę AppDbHelper rozszerzającą SQLiteOpenHelper. Po jej rozszerzeniu należy zaimplementować metodę onCreate i onUpgrade.

1. Gdy onCreate i onUpgrade metody nazywane

   • onCreate wywołane po ponownym zainstalowaniu aplikacji.
   • onUpgrade wywołane po aktualizacji aplikacji.

2. Organizowanie wersji baz danych Zarządzam wersjami metodami klasowymi. Utwórz implementacja migracji interfejsu. Np. dla pierwszej wersji create MigrationV1 Klasa, drugiej wersji create MigrationV1ToV2 (są to moje nazewnictwo)

    public interface Migration {
        void run(SQLiteDatabase db);//create tables, alter tables
    }

Przykład migracji:

public class MigrationV1ToV2 implements Migration{
      public void run(SQLiteDatabase db){
        //create new tables
        //alter existing tables(add column, add/remove constraint)
        //etc.
     }
   }

1. używanie klas migracji

onCreate: ponieważ onCreate zostanie wywołana podczas świeżo zainstalowanej aplikacji, musimy również wykonać wszystkie migracje (aktualizacje wersji bazy danych). Więc onCreate will wygląda tak:

public void onCreate(SQLiteDatabase db){
        Migration mV1=new MigrationV1();
       //put your first database schema in this class
        mV1.run(db);
        Migration mV1ToV2=new MigrationV1ToV2();
        mV1ToV2.run(db);
        //other migration if any
  }

onUpgrade: metoda ta zostanie wywołana, gdy aplikacja jest już zainstalowana i jest aktualizowana do nowej wersji aplikacji. Jeśli aplikacja zawiera jakiekolwiek zmiany w bazie danych, to wszystkie zmiany w bazie danych należy umieścić w nowej klasie migracji i wersji bazy danych increment.

Na przykład, powiedzmy, że użytkownik ma zainstalowaną aplikację, która ma bazę danych w wersji 1, a teraz Wersja bazy danych jest aktualizowana do wersji 2(wszystkie aktualizacje schematu przechowywane w MigrationV1ToV2). Teraz po aktualizacji aplikacji, musimy uaktualnić bazę danych, stosując zmiany schematu bazy danych w MigrationV1ToV2, Jak to:

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    if (oldVersion < 2) {
        //means old version is 1
        Migration migration = new MigrationV1ToV2();
        migration.run(db);
    }
    if (oldVersion < 3) {
        //means old version is 2
    }
}

Uwaga: wszystkie uaktualnienia (wymienione w onUpgrade) w schemacie bazy danych powinny być wykonywane w onCreate