SQLite 数据库打开异常时删除DB文件

SQLite 在打开DB文件时，如果遇到打不开的情况，会删除DB 文件，有点凶残。

我们来查看源码

• 1、android.database.sqlite.SQLiteDatabase

private SQLiteDatabase(String path, int openFlags, CursorFactory cursorFactory,
		DatabaseErrorHandler errorHandler) {
	mCursorFactory = cursorFactory;
	mErrorHandler = errorHandler != null ? errorHandler : new DefaultDatabaseErrorHandler();
	mConfigurationLocked = new SQLiteDatabaseConfiguration(path, openFlags);
}

我们需要看一下SQLite 在Database 出错时候的处理 ，打开 DefaultDatabaseErrorHandler

• 2、android.database.DefaultDatabaseErrorHandler

public final class DefaultDatabaseErrorHandler implements DatabaseErrorHandler {

    private static final String TAG = "DefaultDatabaseErrorHandler";

    /**
     * defines the default method to be invoked when database corruption is detected.
     * @param dbObj the {@link SQLiteDatabase} object representing the database on which corruption
     * is detected.
     */
    public void onCorruption(SQLiteDatabase dbObj) {
        Log.e(TAG, "Corruption reported by sqlite on database: " + dbObj.getPath());

        // is the corruption detected even before database could be 'opened'?
        if (!dbObj.isOpen()) {
            // database files are not even openable. delete this database file.
            // NOTE if the database has attached databases, then any of them could be corrupt.
            // and not deleting all of them could cause corrupted database file to remain and 
            // make the application crash on database open operation. To avoid this problem,
            // the application should provide its own {@link DatabaseErrorHandler} impl class
            // to delete ALL files of the database (including the attached databases).
            deleteDatabaseFile(dbObj.getPath());
            return;
        }

        List<Pair<String, String>> attachedDbs = null;
        try {
            // Close the database, which will cause subsequent operations to fail.
            // before that, get the attached database list first.
            try {
                attachedDbs = dbObj.getAttachedDbs();
            } catch (SQLiteException e) {
                /* ignore */
            }
            try {
                dbObj.close();
            } catch (SQLiteException e) {
                /* ignore */
            }
        } finally {
            // Delete all files of this corrupt database and/or attached databases
            if (attachedDbs != null) {
                for (Pair<String, String> p : attachedDbs) {
                    deleteDatabaseFile(p.second);
                }
            } else {
                // attachedDbs = null is possible when the database is so corrupt that even
                // "PRAGMA database_list;" also fails. delete the main database file
                deleteDatabaseFile(dbObj.getPath());
            }
        }
    }

    private void deleteDatabaseFile(String fileName) {
        if (fileName.equalsIgnoreCase(":memory:") || fileName.trim().length() == 0) {
            return;
        }
        Log.e(TAG, "deleting the database file: " + fileName);
        try {
            SQLiteDatabase.deleteDatabase(new File(fileName));
        } catch (Exception e) {
            /* print warning and ignore exception */
            Log.w(TAG, "delete failed: " + e.getMessage());
        }
    }
}

我们可以看到 DefaultDatabaseErrorHandler 的处理方式，如果这个数据库打不开就会删除这个DB文件，如果当前DB 有 attach 其他数据库的话，也有可能会被删除，所以开发者应该提供自己的DatabaseErrorHandler

• 3、SQLiteOpenHelper

我们通过继承SQLiteOpenHelper 来使用SQLite 数据库 【详见：SQLite学习一、基础使用】；
我们提供自己的DatabaseErrorHandler

public class WyhcjgOpenHelper extends SQLiteOpenHelper {

public WyhcjgOpenHelper(Context context, String path) {
	super(context, path, null, VERSION, null, new DatabaseErrorHandler() {
		@Override
		public void onCorruption(SQLiteDatabase sqLiteDatabase) {
			Logger.t(TAG).i("WyhcjgOpenHelper sqlite onCorruption " + sqLiteDatabase.getPath());
		}
	});
	this.mContext = context;
}
}

---

使用sqlcipher 时的修改

• 1、net.sqlcipher.database.SQLiteDatabase

...
public static SQLiteDatabase openOrCreateDatabase(File file, String password, SQLiteDatabase.CursorFactory factory, SQLiteDatabaseHook databaseHook, DatabaseErrorHandler errorHandler) {
	return openOrCreateDatabase(file == null?null:file.getPath(), password, factory, databaseHook, errorHandler);
}
...

• 2、net.sqlcipher.DefaultDatabaseErrorHandler

public void onCorruption(SQLiteDatabase dbObj) {
	Log.e(this.TAG, "Corruption reported by sqlite on database, deleting: " + dbObj.getPath());
	if(dbObj.isOpen()) {
		Log.e(this.TAG, "Database object for corrupted database is already open, closing");

		try {
			dbObj.close();
		} catch (Exception var3) {
			Log.e(this.TAG, "Exception closing Database object for corrupted database, ignored", var3);
		}
	}

	this.deleteDatabaseFile(dbObj.getPath());
}

同样的，如果这个数据库打不开就会删除这个DB文件。

• 3、net.sqlcipher.database.SQLiteOpenHelper

public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version, SQLiteDatabaseHook hook, DatabaseErrorHandler errorHandler) {
	this.mDatabase = null;
	this.mIsInitializing = false;
	if(version < 1) {
		throw new IllegalArgumentException("Version must be >= 1, was " + version);
	} else if(errorHandler == null) {
		throw new IllegalArgumentException("DatabaseErrorHandler param value can't be null.");
	} else {
		this.mContext = context;
		this.mName = name;
		this.mFactory = factory;
		this.mNewVersion = version;
		this.mHook = hook;
		this.mErrorHandler = errorHandler;
	}
}

• 4、SQLiteOpenHelper

我们通过继承SQLiteOpenHelper 来使用SQLite 数据库 【详见：SQLite学习一、基础使用】；
我们提供自己的DatabaseErrorHandler

public class WyhcjgOpenHelper extends SQLiteOpenHelper {

public WyhcjgOpenHelper(Context context, String path) {
	super(context, path, null, VERSION, null, new DatabaseErrorHandler() {
		@Override
		public void onCorruption(SQLiteDatabase sqLiteDatabase) {
			Logger.t(TAG).i("WyhcjgOpenHelper sqlite onCorruption " + sqLiteDatabase.getPath());
		}
	});
	this.mContext = context;
}
}

---

使用Room 时的修改

• 获取 *Database 的实例时

TaskDatabase extends RoomDatabase
...
public synchronized static TaskDatabase getInstance(byte[] passphrase) {
	if (INSTANCE == null) {
		synchronized (TaskDatabase.class) {
			if (INSTANCE == null) {
				INSTANCE = Room
						.databaseBuilder(mContext.getApplicationContext(), TaskDatabase.class, sDbPath)
						.openHelperFactory(new HelperFactory(passphrase))
						.allowMainThreadQueries()
						.addMigrations(migration_1_2)
						.build();
			}

		}
	}
	return (INSTANCE);
}

• new HelperFactory(passphrase)

public class HelperFactory implements SupportSQLiteOpenHelper.Factory {

    private byte[] passphrase;

    public HelperFactory(byte[] passphrase) {
        this.passphrase = passphrase;
    }

    @Override
    public SupportSQLiteOpenHelper create(SupportSQLiteOpenHelper.Configuration configuration) {
        return (new Helper(configuration.context, configuration.name, configuration.callback, passphrase));
    }
}

• android.arch.persistence.db.framework.Helper

OpenHelper(Context context, String name, final Database[] dbRef,
		   final Callback callback, byte[] passphrase) {
	super(context, name, passphrase, CIPHER_SPEC, null, callback.version,
			new DatabaseErrorHandler() {

				@Override
				public void onCorruption(SQLiteDatabase dbObj) {
					/*Database db = dbRef[0];
					if (db != null) {
						callback.onCorruption(db);
					}*/
				}
			});
	mCallback = callback;
	mDbRef = dbRef;
}