GreenDAO模式更新和数据迁移？

Question

我正在评估GreenDAO，考虑在商业Android应用程序中使用，并想确定模式更新的迁移路径。

我的理解是否正确，即我需要编写自定义OpenHelper，提供onUpdate()方法，并根据新模式提取转换和存储数据？这个假设引发了一些有趣的问题，涉及调用顺序和责任的划分。

我找不到有关GreenDAO的模式更新和数据迁移的任何文档。

以下是我撰写的有关此主题的一系列博客文章：

1. GreenDAO 评测
2. 第1部分 - 模式生成
3. 第2部分 - 模式迁移
4. 第3部分 - 测试模式迁移

- Syntax

---

我遇到了同样的问题。你写了这个帮助程序吗？ - user987723

我确实做了，但是这些辅助程序的结构非常紧密地耦合到您的解决方案（直接在您的数据库表和列上工作，涉及版本更改），因此它不可重用；抱歉。 - Syntax

@Syntax 你能告诉我们你把OpenHelper放在哪里了吗？目前DaoMaster对象扩展了SQLiteOpenHelper，但是这个文件是自动生成的，不应该被编辑。或者你只是扩展了DaoMaster？谢谢。 - Tim

@Tim 我的自定义 UpgradeHelper 继承了 DaoMaster.OpenHelper，然后我像这样使用它。"OpenHelper helper = new UpgradeHelper(application, Constants.DB_NAME, null);" - Syntax

抱歉@MahdiAlkhatib，托管我的解决方案的博客已关闭，并且托管的说明和文件已被删除。好消息是，web.archive仍然有副本；我已更新上面的链接，它们应该可以使用 :) 享受！ - Syntax

Answer 1

考虑到pleonasmik的方法（顺便说一下，谢谢，它真的很有用），我创建了一个MigrationHelper类。

它是如何工作的：

1. 该类捕获所有获得的Daos
2. 根据旧版本模式创建临时表（generateTempTables方法）
3. 将所有数据导入到这个新表中（generateTempTables方法）
4. 删除旧版本的所有表格（DaoMaster.dropAllTables方法）
5. 创建新版本的表格（DaoMaster.createAllTables方法）
6. 从临时表更新新版本的表格（restoreData方法）
7. 删除所有临时表格（restoreData方法）

迁移助手类：

import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.text.TextUtils;
import android.util.Log;

import com.crashlytics.android.Crashlytics;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import de.greenrobot.dao.AbstractDao;
import de.greenrobot.dao.internal.DaoConfig;
import greendao.DaoMaster;


/**
 * Created by pokawa on 18/05/15.
 */
public class MigrationHelper {

    private static final String CONVERSION_CLASS_NOT_FOUND_EXCEPTION = "MIGRATION HELPER - CLASS DOESN'T MATCH WITH THE CURRENT PARAMETERS";
    private static MigrationHelper instance;

    public static MigrationHelper getInstance() {
        if(instance == null) {
            instance = new MigrationHelper();
        }
        return instance;
    }

    public void migrate(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        generateTempTables(db, daoClasses);
        DaoMaster.dropAllTables(db, true);
        DaoMaster.createAllTables(db, false);
        restoreData(db, daoClasses);
    }

    private void generateTempTables(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for(int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);

            String divider = "";
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            ArrayList<String> properties = new ArrayList<>();

            StringBuilder createTableStringBuilder = new StringBuilder();

            createTableStringBuilder.append("CREATE TABLE ").append(tempTableName).append(" (");

            for(int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;

                if(getColumns(db, tableName).contains(columnName)) {
                    properties.add(columnName);

                    String type = null;

                    try {
                        type = getTypeByClass(daoConfig.properties[j].type);
                    } catch (Exception exception) {
                        Crashlytics.logException(exception);
                    }

                    createTableStringBuilder.append(divider).append(columnName).append(" ").append(type);

                    if(daoConfig.properties[j].primaryKey) {
                        createTableStringBuilder.append(" PRIMARY KEY");
                    }

                    divider = ",";
                }
            }
            createTableStringBuilder.append(");");

            db.execSQL(createTableStringBuilder.toString());

            StringBuilder insertTableStringBuilder = new StringBuilder();

            insertTableStringBuilder.append("INSERT INTO ").append(tempTableName).append(" (");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(") SELECT ");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(" FROM ").append(tableName).append(";");

            db.execSQL(insertTableStringBuilder.toString());
        }
    }

    private void restoreData(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for(int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);

            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            ArrayList<String> properties = new ArrayList();

            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;

                if(getColumns(db, tempTableName).contains(columnName)) {
                    properties.add(columnName);
                }
            }

            StringBuilder insertTableStringBuilder = new StringBuilder();

            insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(") SELECT ");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");

            StringBuilder dropTableStringBuilder = new StringBuilder();

            dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);

            db.execSQL(insertTableStringBuilder.toString());
            db.execSQL(dropTableStringBuilder.toString());
        }
    }

    private String getTypeByClass(Class<?> type) throws Exception {
        if(type.equals(String.class)) {
            return "TEXT";
        }
        if(type.equals(Long.class) || type.equals(Integer.class) || type.equals(long.class)) {
            return "INTEGER";
        }
        if(type.equals(Boolean.class)) {
            return "BOOLEAN";
        }

        Exception exception = new Exception(CONVERSION_CLASS_NOT_FOUND_EXCEPTION.concat(" - Class: ").concat(type.toString()));
        Crashlytics.logException(exception);
        throw exception;
    }

    private static List<String> getColumns(SQLiteDatabase db, String tableName) {
        List<String> columns = new ArrayList<>();
        Cursor cursor = null;
        try {
            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 1", null);
            if (cursor != null) {
                columns = new ArrayList<>(Arrays.asList(cursor.getColumnNames()));
            }
        } catch (Exception e) {
            Log.v(tableName, e.getMessage(), e);
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return columns;
    }
}

这里有一个例子，说明在DaoMaster.java类中应该如何调用它：

@Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by migrating all tables data");

        MigrationHelper.getInstance().migrate(db,
                UserDao.class,
                ItemDao.class);
    }

- Pedro Okawa

---

现在这是一段很棒的代码！谢谢你分享 :) - Hardik4560

我非常喜欢这个解决方案，它简短而强大。但是我有一个问题，似乎它无法处理添加必填字段的情况。由于迁移代码是通用的，所以似乎没有任何地方可以提供默认值等来填充必填字段的值，除非我错了，否则这个解决方案可能会限制您对数据库进行的更改类型。 - Syntax

我知道在Stack Overflow上发布的代码是根据创作共用许可协议发布的。但这个人把代码复制到了他自己的GitHub库中，完全没有给出这个线程的来源：https://github.com/yuweiguocn/GreenDaoUpgradeHelper/blob/master/library/src/main/java/com/github/yuweiguocn/library/greendao/MigrationHelper.java - Enrico Susatyo

大家好，@EnricoSusatyo非常感谢你提醒我这件事，但没关系，我不会要回它，我真的希望它是免费的，也不需要任何功劳。别担心，我希望我能帮到你们，再次感谢你，伙计们。 :D - Pedro Okawa

@PedroOkawa，我需要将所有的DAOs（包括旧的和新的）都设置到迁移方法调用中才能正确迁移我的数据库吗？ - Khalid ElSayed

https://medium.com/@kidusmamuye/migration-with-greendao-android-8f940b5ef58d - Kidus Tekeste

Answer 2

你的猜测是正确的。目前不存在不同模式版本之间的更改跟踪，因此在进行模式升级时需要自己编写SQL。

- Markus Junginger

---

我认为以下提出的解决方案非常棒，如果您决定将它们添加到GreenDAO中，那将更加完美。 - MoxGeek

Answer 3

如果你想在greenDAO 3上更新数据库模式版本，请将以下代码添加到你的应用程序的build.gradle文件中的dependencies之前：

apply plugin: 'org.greenrobot.greendao'

greendao {
    schemaVersion 1
}

- Codelicious

---

值得记住的是，这种技术不幸地会删除本地数据库并重新创建它。谢谢。 - Hiago Souza

Answer 4

这是与GreenDao 3.+兼容且修复错误的@PedroOkawa的相同代码：

import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.support.annotation.NonNull;
import android.text.TextUtils;

import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.database.StandardDatabase;
import org.greenrobot.greendao.internal.DaoConfig;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Createdby PedroOkawa and modified by MBH on 16/08/16.
 */
public final class MigrationHelper {

    public static void migrate(SQLiteDatabase sqliteDatabase, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        StandardDatabase db = new StandardDatabase(sqliteDatabase);
        generateNewTablesIfNotExists(db, daoClasses);
        generateTempTables(db, daoClasses);
        dropAllTables(db, true, daoClasses);
        createAllTables(db, false, daoClasses);
        restoreData(db, daoClasses);
    }

    public static void migrate(StandardDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        generateNewTablesIfNotExists(db, daoClasses);
        generateTempTables(db, daoClasses);
        dropAllTables(db, true, daoClasses);
        createAllTables(db, false, daoClasses);
        restoreData(db, daoClasses);
    }

    private static void generateNewTablesIfNotExists(StandardDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "createTable", true, daoClasses);
    }

    private static void generateTempTables(StandardDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            StringBuilder insertTableStringBuilder = new StringBuilder();
            insertTableStringBuilder.append("CREATE TEMP TABLE ").append(tempTableName);
            insertTableStringBuilder.append(" AS SELECT * FROM ").append(tableName).append(";");
            db.execSQL(insertTableStringBuilder.toString());
        }
    }

    private static void dropAllTables(StandardDatabase db, boolean ifExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "dropTable", ifExists, daoClasses);
    }

    private static void createAllTables(StandardDatabase db, boolean ifNotExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "createTable", ifNotExists, daoClasses);
    }

    /**
     * dao class already define the sql exec method, so just invoke it
     */
    private static void reflectMethod(StandardDatabase db, String methodName, boolean isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        if (daoClasses.length < 1) {
            return;
        }
        try {
            for (Class cls : daoClasses) {
                Method method = cls.getDeclaredMethod(methodName, Database.class, boolean.class);
                method.invoke(null, db, isExists);
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    private static void restoreData(StandardDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            // get all columns from tempTable, take careful to use the columns list
            List<String> columns = getColumns(db, tempTableName);
            ArrayList<String> properties = new ArrayList<>(columns.size());
            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;
                if (columns.contains(columnName)) {
                    properties.add(columnName);
                }
            }
            if (properties.size() > 0) {
                final String columnSQL = TextUtils.join(",", properties);

                StringBuilder insertTableStringBuilder = new StringBuilder();
                insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
                insertTableStringBuilder.append(columnSQL);
                insertTableStringBuilder.append(") SELECT ");
                insertTableStringBuilder.append(columnSQL);
                insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
                db.execSQL(insertTableStringBuilder.toString());
            }
            StringBuilder dropTableStringBuilder = new StringBuilder();
            dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
            db.execSQL(dropTableStringBuilder.toString());
        }
    }

    private static List<String> getColumns(StandardDatabase db, String tableName) {
        List<String> columns = null;
        Cursor cursor = null;
        try {
            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 0", null);
            if (null != cursor && cursor.getColumnCount() > 0) {
                columns = Arrays.asList(cursor.getColumnNames());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
            if (null == columns)
                columns = new ArrayList<>();
        }
        return columns;
    }

}

用法如下：

@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
    MigrationHelper.migrate(new StandardDatabase(sqLiteDatabase),
                UserDao.class,
                ItemDao.class);
    // OR you can use it like this (Dont use both it is example of 2 different usages)
    MigrationHelper.migrate(sqLiteDatabase,
                UserDao.class,
                ItemDao.class);
}

StandardDatabase 可以在 greendao 中找到，这是导入方式：

import org.greenrobot.greendao.database.StandardDatabase;

再次感谢 @PedroOkawa :)

- MBH

Answer 5

我认为我对一个类似问题的回答可以帮助你解决这个问题。如果你真的需要迁移数据，我建议你自己编写迁移代码，例如处理一些约束变化或在SQLite中不支持的事情。例如，根据我在链接响应中采取的方法，迁移辅助工具的示例可能是：

public class DBMigrationHelper6 extends AbstractMigratorHelper {

/* Upgrade from DB schema 6 to schema 7 , version numbers are just examples*/

public void onUpgrade(SQLiteDatabase db) {

    /* Create a temporal table where you will copy all the data from the previous table that you need to modify with a non supported sqlite operation */
    db.execSQL("CREATE TABLE " + "'post2' (" + //
            "'_id' INTEGER PRIMARY KEY ," + // 0: id
            "'POST_ID' INTEGER UNIQUE ," + // 1: postId
            "'USER_ID' INTEGER," + // 2: userId
            "'VERSION' INTEGER," + // 3: version
            "'TYPE' TEXT," + // 4: type
            "'MAGAZINE_ID' TEXT NOT NULL ," + // 5: magazineId
            "'SERVER_TIMESTAMP' INTEGER," + // 6: serverTimestamp
            "'CLIENT_TIMESTAMP' INTEGER," + // 7: clientTimestamp
            "'MAGAZINE_REFERENCE' TEXT NOT NULL ," + // 8: magazineReference
            "'POST_CONTENT' TEXT);"); // 9: postContent

    /* Copy the data from one table to the new one */
    db.execSQL("INSERT INTO post2 (_id, POST_ID, USER_ID, VERSION, TYPE,  MAGAZINE_ID, SERVER_TIMESTAMP, CLIENT_TIMESTAMP, MAGAZINE_REFERENCE, POST_CONTENT)" +
            "   SELECT _id, POST_ID, USER_ID, VERSION, TYPE,  MAGAZINE_ID, SERVER_TIMESTAMP, CLIENT_TIMESTAMP, MAGAZINE_REFERENCE, POST_CONTENT FROM post;");

    /* Delete the previous table */
    db.execSQL("DROP TABLE post");
    /* Rename the just created table to the one that I have just deleted */
    db.execSQL("ALTER TABLE post2 RENAME TO post");

    /* Add Index/es if you want them */
    db.execSQL("CREATE INDEX " + "IDX_post_USER_ID ON post" +
            " (USER_ID);");

   }
}

- pleonasmik

Answer 6

Pedro Okawa的解决方案是正确的，但你需要编写自己的“UpgradeHelper”来扩展“OpenHelper”，因为每次重新生成DAO代码时都会覆盖DaoMaster。

示例：

public class UpgradeHelper extends DaoMaster.OpenHelper {

public UpgradeHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
    super(context, name, factory);
}

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

    Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by migrating all tables data");

    MigrationHelper.getInstance().migrate(db,
            UserDao.class,
            ItemDao.class,
            AnotherClassToGenerateDao.class);
}

}

- oskarko

---

我该如何调用这个 upgradeHelper？ - Khalid ElSayed

你需要创建一个名为“UpgradedHelper”的新类，并覆盖该方法。 - oskarko

Answer 7

如果您只是想在不删除用户数据的情况下向模式中添加新表，并且不需要转换任何现有数据，请查看我的答案this question，其中提供了使用greenDao完成此操作的离散示例。

- DiscDev

---

嗨，感谢您的评论。如果您阅读我在问题上方添加的博客文章编辑，您应该会发现比提供的链接更全面的迁移等问题解决方案。干杯 - Syntax

在我提问之前，我已经阅读了你的四篇博客文章。因为我要找的信息被深深地埋藏在你使用的模式中，所以我想提供一个离散的例子，因为似乎在SO上没有任何与greenDao相关的例子。实际上，在我的真实应用程序中，我正在使用与你非常相似的模式，但我提出的问题只是如何添加一个新表，而不是在升级模式时使用什么模式。我很感激你的文章，只是想提供一个更简洁的答案，正如我回答中的免责声明所述。 - DiscDev