getReadableDatabase() 和 getWritableDatabase()

原文地址：http://blog.csdn.net/alex_zhuang/article/details/7342840

Android使用getWritableDatabase()和getReadableDatabase()方法都可以获取一个用于操作数据库的SQLiteDatabase实例。(getReadableDatabase()方法中会调用getWritableDatabase()方法)

其中getWritableDatabase() 方法以读写方式打开数据库，一旦数据库的磁盘空间满了，数据库就只能读而不能写，倘若使用的是getWritableDatabase() 方法就会出错。

getReadableDatabase()方法则是先以读写方式打开数据库，如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库。如果该问题成功解决，则只读数据库对象就会关闭，然后返回一个可读写的数据库对象。

源码如下：

[java] view
plain copy

/**

* Create and/or open a database that will be used for reading and writing.

* Once opened successfully, the database is cached, so you can call this

* method every time you need to write to the database. Make sure to call

* {@link #close} when you no longer need it.

*

* <p>Errors such as bad permissions or a full disk may cause this operation

* to fail, but future attempts may succeed if the problem is fixed.</p>

*

* @throws SQLiteException if the database cannot be opened for writing

* @return a read/write database object valid until {@link #close} is called

*/

public synchronized SQLiteDatabase getWritableDatabase() {

if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {

return mDatabase; // The database is already open for business

}

if (mIsInitializing) {

throw new IllegalStateException("getWritableDatabase called recursively");

}

// If we have a read-only database open, someone could be using it

// (though they shouldn't), which would cause a lock to be held on

// the file, and our attempts to open the database read-write would

// fail waiting for the file lock. To prevent that, we acquire the

// lock on the read-only database, which shuts out other users.

boolean success = false;

SQLiteDatabase db = null;

if (mDatabase != null) mDatabase.lock();

try {

mIsInitializing = true;

if (mName == null) {

db = SQLiteDatabase.create(null);

} else {

db = mContext.openOrCreateDatabase(mName, 0, mFactory);

}

int version = db.getVersion();

if (version != mNewVersion) {

db.beginTransaction();

try {

if (version == 0) {

onCreate(db);

} else {

onUpgrade(db, version, mNewVersion);

}

db.setVersion(mNewVersion);

db.setTransactionSuccessful();

} finally {

db.endTransaction();

}

}

onOpen(db);

success = true;

return db;

} finally {

mIsInitializing = false;

if (success) {

if (mDatabase != null) {

try { mDatabase.close(); } catch (Exception e) { }

mDatabase.unlock();

}

mDatabase = db;

} else {

if (mDatabase != null) mDatabase.unlock();

if (db != null) db.close();

}

}

}

/**

* Create and/or open a database. This will be the same object returned by

* {@link #getWritableDatabase} unless some problem, such as a full disk,

* requires the database to be opened read-only. In that case, a read-only

* database object will be returned. If the problem is fixed, a future call

* to {@link #getWritableDatabase} may succeed, in which case the read-only

* database object will be closed and the read/write object will be returned

* in the future.

*

* @throws SQLiteException if the database cannot be opened

* @return a database object valid until {@link #getWritableDatabase}

* or {@link #close} is called.

*/

public synchronized SQLiteDatabase getReadableDatabase() {

if (mDatabase != null && mDatabase.isOpen()) {

return mDatabase; // The database is already open for business

}

if (mIsInitializing) {

throw new IllegalStateException("getReadableDatabase called recursively");

}

try {

return getWritableDatabase();

} catch (SQLiteException e) {

if (mName == null) throw e; // Can't open a temp database read-only!

Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);

}

SQLiteDatabase db = null;

try {

mIsInitializing = true;

String path = mContext.getDatabasePath(mName).getPath();

db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);

if (db.getVersion() != mNewVersion) {

throw new SQLiteException("Can't upgrade read-only database from version " +

db.getVersion() + " to " + mNewVersion + ": " + path);

}

onOpen(db);

Log.w(TAG, "Opened " + mName + " in read-only mode");

mDatabase = db;

return mDatabase;

} finally {

mIsInitializing = false;

if (db != null && db != mDatabase) db.close();

}

}