micro - ormlite android github

Actualización de ORMLite de la base de datos

Question

De hecho, estoy desarrollando una aplicación que utiliza la biblioteca ORMLite (lo cual es maravilloso por cierto) pero soy un principiante que la usa.

Tengo una pregunta sobre la actualización de la base de datos dentro del dispositivo.

Digamos que alguien descarga mi aplicación en Google Play. Pocos meses después, seguramente llenaré algunas tablas con nuevas entradas.

Cuando esta persona está realizando una actualización de la aplicación, ¿cómo puedo actualizar la base de datos con mis nuevas entradas y mantener las antiguas en su interior?

Para ser más claros, imagine que el usuario respondió preguntas en mi aplicación. Cuando presente nuevas preguntas, ¿cómo puedo insertarlas en la base de datos cuando él actualiza mi aplicación y mantener las preguntas que ya han sido respondidas?

Answer 1

Cuando esta persona está realizando una actualización de la aplicación, ¿cómo puedo actualizar la base de datos con mis nuevas entradas y mantener las antiguas en su interior?

La idea es usar el número de versión que se pasa al método onUpgrade(...) . Con ORMLite , el OrmLiteSqliteOpenHelper.onUpgrade(...) toma un número de oldVersion y newVersion . Luego puede escribir un código de conversión en su aplicación que pueda convertir los datos del formato antiguo y actualizar el esquema.

Para obtener más información, consulte la documentación de ORMLite sobre el tema:

http://ormlite.com/docs/upgrade-schema

Para citar, podrías hacer algo como lo siguiente:

if (oldVersion < 2) {
  // we added the age column in version 2
  dao.executeRaw("ALTER TABLE `account` ADD COLUMN age INTEGER;");
}
if (oldVersion < 3) {
  // we added the weight column in version 3
  dao.executeRaw("ALTER TABLE `account` ADD COLUMN weight INTEGER;");
}

Si tiene datos existentes que necesita convertir, debe hacer las conversiones en SQL si es posible.

Otra alternativa sería tener una entidad de Account y una entidad de Account OldAccount que apunten al mismo nombre de tabla. Luego, puede leer en OldAccount entidades OldAccount usando la cuenta oldAccountDao , convertirlas en entidades de la Account y luego actualizarlas usando la accountDao nuevo a la misma tabla. Debes tener cuidado con los cachés de objetos aquí.

Answer 2

Lo hago de esta manera:

@Override
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {

    switch (oldVersion) {
    case 1:
        updateFromVersion1(database, connectionSource, oldVersion, newVersion);
        break;
    case 2:
        updateFromVersion2(database, connectionSource, oldVersion, newVersion);
        break;
    default:
        // no updates needed
        break;
    }

}

private void updateFromVersion1(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
    // do some stuff here
    onUpgrade(database, connectionSource, oldVersion + 1, newVersion);
}

private void updateFromVersion2(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
    // do some stuff here
    onUpgrade(database, connectionSource, oldVersion + 1, newVersion);
}

Esto actualizará de forma incremental la db de los usuarios, independientemente de la versión de db que venga.

Answer 3

No me gusta eliminar la base de datos en cada actualización, o escribir un código de actualización después de agregar cada campo, así que ...

Estoy tratando de hacerlo así:

@Override
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
    ArrayList<String> tableNames = getTableNames(database);
    for (Class clazz : daoClasses) {
        try {
            Annotation annotation = clazz.getAnnotation(DatabaseTable.class);
            if (annotation != null && annotation instanceof DatabaseTable) {
                String tableName = ((DatabaseTable) annotation).tableName();
                if (tableName.isEmpty()) {
                    tableName = clazz.getSimpleName().substring(0, 1).toLowerCase() + clazz.getSimpleName().substring(1);
                }
                if(!tableNames.contains(tableName)){
                    TableUtils.createTable(connectionSource, clazz);
                } else {
                    addColumns(database, tableName, clazz);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

private ArrayList<String> getTableNames(SQLiteDatabase database){
    ArrayList<String> tableNames = new ArrayList<>();
    Cursor cursor = database.rawQuery("SELECT name FROM sqlite_master WHERE type=''table''", null);
    if (cursor.moveToFirst()) {
        while ( !cursor.isAfterLast() ) {
            tableNames.add(cursor.getString(0));
            cursor.moveToNext();
        }
    }
    cursor.close();
    return tableNames;
}

private void addColumns(SQLiteDatabase database, String tableName, Class clazz){
    Cursor mCursor = database.rawQuery("SELECT * FROM " + tableName + " LIMIT 0", null);
    for (Field field : clazz.getDeclaredFields()) {
        try {
            DatabaseField annotationField = field.getAnnotation(DatabaseField.class);
            if (annotationField != null && !annotationField.foreign()){
                String columnName = field.getName();
                boolean hasColumn = mCursor.getColumnIndex(columnName) != -1;
                if (!hasColumn) {
                    String columnType = field.getType().getSimpleName();
                    if(columnType.equals(String.class.getSimpleName())){
                        columnType = "TEXT";
                    } else {
                        columnType = columnType.toUpperCase();
                    }
                    database.execSQL(MessageFormat.format("ALTER TABLE `{0}` ADD COLUMN {1} {2};", tableName, columnName, columnType));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    mCursor.close();
}

Espero que este código pueda ser mejor.

Aquí, no borro las tablas y columnas antiguas que se eliminaron de dao''s, y no creo campos foráneos (no estoy seguro si lo necesito).

Answer 4

Poca información, no está claro si los cambios que tiene estructura de tabla.

a) Si no cambia la estructura de la base de datos.

1 En la nueva versión de su programa cuando comience a verificar una versión previamente guardada (por ejemplo, en las preferencias) con la actual (consulte PackageManager.getPackageInfo)

guardado = 0 - El usuario acaba de instalar la nueva versión

guardado <actual - El usuario actualiza su programa

2 Agregar nuevos datos a la base

3 Guardar la versión actual en las preferencias

b) Si la estructura de la tabla ha cambiado (campos agregados o eliminados)

1 Aumente el número de versión de su base de datos (vea su clase de OrmLiteSqliteOpenHelper ampliada)

2 Cuando el usuario se ejecute por primera vez en su programa, se llamará al método ''onUpgrade'' (en su clase de OrmLiteSqliteOpenHelper se extiende) que se transferirá a los números de versión antiguos y nuevos.

• Lea los datos existentes en el caché (temp)
• recrear tabla
• Agregue los datos del caché + sus nuevos datos