点滴：Android SQLite

最新推荐文章于 2024-03-28 17:49:39 发布

ningjia2013

最新推荐文章于 2024-03-28 17:49:39 发布

阅读量485

点赞数

分类专栏：点滴

点滴专栏收录该内容

16 篇文章 0 订阅

订阅专栏

public class MyDBHelper extends SQLiteOpenHelper {

	public MyDBHelper(Context context, String name, CursorFactory factory, int version) {
		super(context, name, factory, version);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		// TODO Auto-generated method stub

	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		// TODO Auto-generated method stub

	}

}

SQLiteOpenHelper类，在该类的构造器中，调用Context中的方法创建并打开一个指定名称的数据库对象。继承和扩展SQLiteOpenHelper类主要做的工作就是重写以下两个方法。
onCreate(SQLiteDatabase db) : 当数据库被首次创建时执行该方法，一般将创建表等初始化操作在该方法中执行。
onUpgrade(SQLiteDatabse dv, int oldVersion,int new Version)：当打开数据库时传入的版本号与当前的版本号不同时会调用该方法。
除了上述两个必须要实现的方法外，还可以选择性地实现onOpen 方法，该方法会在每次打开数据库时被调用。

String NAME_DB = "db_test";
String NAME_TABLE = "table_test";

1，数据库的打开

SQLiteOpenHelper helper = new MyDBHelper(this, NAME_DB, null, DB_VERSION);
SQLiteDatabase db = helper.getWritableDatabase();

2，删除表

db.execSQL("DROP TABLE IF EXISTS "+NAME_TABLE);

3，建表

db.execSQL("CREATE TABLE "+NAME_TABLE +" (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age SMALLINT, coin INTEGER)");

4，增

db.execSQL("INSERT INTO "+NAME_TABLE+" VALUES (NULL, ?, ?, ?)", new Object[]{"zhangsan", 20, 1000});

或者

ContentValues cv = new ContentValues();
cv.put("name", "lisi");
cv.put("age", 30);
cv.put("coin", 2000);
db.insert(NAME_TABLE, null, cv);

5，删

db.delete(NAME_TABLE, "age < ?", new String[]{"25"});

6，改

cv = new ContentValues();
cv.put("name", "zhangsan1");
db.update(NAME_TABLE, cv, "name = ?", new String[]{"zhangsan"});

7，查

cursor = db.rawQuery("SELECT * FROM "+NAME_TABLE+" WHERE age >= ?", new String[]{"1"});
while(cursor.moveToNext()){
int id = cursor.getInt(cursor.getColumnIndex("_id"));
String name = cursor.getString(cursor.getColumnIndex("name"));
int age = cursor.getInt(cursor.getColumnIndex("age"));
int coin = cursor.getInt(cursor.getColumnIndex("coin"));
}

8，增加表字段

db.execSQL("ALTER TABLE "+NAME_TABLE+" ADD weight INTEGER");

9，修改表字段名或者删除字段
只能先重命名原来的表，之后新建一张表，把原来的数据复制到新表中，最后删除掉旧的表就可以了。

String TABLE_TEMP = "temp";
			String rename_sql = "ALTER TABLE " + NAME_TABLE + " RENAME TO " + TABLE_TEMP;

			String createnew_sql = "CREATE TABLE " + NAME_TABLE + " AS SELECT _id, name, age, weight FROM "
					+ TABLE_TEMP;

			String drop_sql = "DROP TABLE " + TABLE_TEMP;

			db.execSQL(rename_sql);

			db.execSQL(createnew_sql);

			db.execSQL(drop_sql);

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

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

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

源码如下：

[java]view plaincopy 
   
 /** 
      * 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();  
         }  
     }  