android的辅助代码,android中使用SQLiteOpenHelper这个辅助

Android使用

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

getReadableDatabase()并不是以只读方式打开数据库，而是先执行getWritableDatabase()，失败的情况下才以只读方式打开数据库.。

但getWritableDatabase()方法以读写方式打开数据库，一旦数据库的磁盘空间满了，数据库就只能读而不能写，

getWritableDatabase()打开数据库就会出错。getReadableDatabase()方法先以读写方式打开数据库，

倘若使用如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库.

/**

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

* Once opened successfully, the database is ***d, 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.

*

*

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.

*

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

}

}