Mise à jour ORMLite de la base de données

Je suis en train de développer une application qui utilise ORMLite de la bibliothèque (qui est magnifique d'ailleurs) mais je suis un débutant en l'utilisant.

J'ai une question à propos de la mise à jour de la base de données à l'intérieur de l'appareil.

Disons que quelqu'un téléchargez mon application sur le Google Play. Quelques mois plus tard, je vais certainement remplir certaines tables avec de nouvelles entrées.

Lorsque cette personne est en train de faire une mise à jour de l'application, comment puis-je mettre à jour la base de données avec mes nouvelles entrées et de garder les anciens à l'intérieur.

Pour être plus clair, imaginons que l'utilisateur a répondu à des questions dans mon application. Quand je vais introduire de nouvelles questions, comment puis-je les insérer dans la base de données quand il les mises à jour de mon application et de garder les questions qui ont déjà obtenu une réponse ?

source d'informationauteur Alexis C.

  1. 31

    Lorsque cette personne est en train de faire une mise à jour de l'application, comment puis-je mettre à jour la base de données avec mes nouvelles entrées et de garder les anciens à l'intérieur.

    L'idée est d'utiliser le numéro de version qui est passée à la onUpgrade(...) méthode. Avec ORMLitele OrmLiteSqliteOpenHelper.onUpgrade(...) méthode prend un oldVersion et newVersion nombre. Ensuite, vous pouvez écrire le code de conversion dans votre application qui est capable de convertir les données de l'ancien format et de mettre à jour le schéma.

    Pour plus d'informations, voir la ORMLite docs sur le sujet:

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

    De devis, vous pourriez faire quelque chose comme ce qui suit:

    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 vous avez des données que vous avez besoin de convertir ensuite, vous devez effectuer les conversions en SQL si possible.

    Une autre solution serait d'avoir un Account entité et une OldAccount entité qui pointent vers la même table-nom. Ensuite, vous pouvez le lire dans OldAccount entités à l'aide de la oldAccountDaoconvertir Account entités, puis de les mettre à jour à l'aide de la accountDao retour à la même table. Vous devez être prudent au sujet de l'objet caches ici.

  2. 6

    Je faire de cette façon:

    @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);
}

    Cela permettra de mettre à jour les utilisateurs db indépendant à partir de laquelle db version, il est à venir.

  3. 3

    Peu d'informations, n'est pas clair si les modifications de structure de table.

    a) Si vous ne modifiez pas la structure de base de données.

    1 Dans la nouvelle version de votre programme lorsque vous commencez à regarder une version précédemment enregistrée (par exemple dans les préférences)
    avec le courant (voir PackageManager.getPackageInfo)

    enregistré = 0 Utilisateur viens d'installer la nouvelle version

    sauvé < courant de l'Utilisateur des mises à jour de votre programme

    2 Ajouter de nouvelles données à la base de

    3 Enregistrer la version actuelle sur les préférences

    b) Si la structure de la table a été modifié (ajout ou suppression de champs)

    1 incrémenter le numéro de version de votre base de données (voir votre étend OrmLiteSqliteOpenHelper classe)

    2 Lorsque l'utilisateur exécute tout d'abord dans votre programme, la méthode 'onUpgrade' sera appelée (dans votre étend OrmLiteSqliteOpenHelper classe) qui sera transféré à l'ancien et le nouveau numéro de version.

    • Lire les données dans le cache (temp)
    • recréer la table
    • Ajouter les données de la mémoire cache + vos nouvelles données
  4. 0

    Je n'aime pas à déposer de la base de données à chaque mise à niveau, ou d'écrire un code de mise à jour après l'ajout de chaque champ, donc ...

    Je suis en train de faire comme ceci:

    @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(!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();
}

    J'espère que ce code peut être mieux.

    Ici, je n'ai pas supprimer les anciennes tables et les colonnes qui ont été retirés de dao, et je n'ai pas créer étrangers champs (je ne sais pas si j'en ai besoin).