Android - SQLite

一 、数据库的创建

事实上，android的SQLite技术主要就是两个东西：

一个是 用create table语句创建出来的那张（些）表 ,里边存着我们需要的数据(先不管它到底是怎样存储数据的),另一个就是 封装了对这张（些）表进行添加(Create)、查询(Retrieve)、更新(Update)和删除(Delete)（这些操作简称为CRUD）等操作的方法的SQLiteDatabase类 ， 因为创建表的语句也是由SQLiteDatabase类的实例来执行的,所以我们先来关注SQLiteDatabase类及其实例的创建.

 

Android提供了一个名为SQLiteDatabase的类，该类封装了一些操作数据库的API，使用该类可以对数据进行添加(Create)、查询(Retrieve)、更新(Update)和删除(Delete)操作（这些操作简称为CRUD）。

首先看一下SQLiteDatabase类的概要：

 /**
  * Exposes methods to manage a SQLite database.
  *
  * SQLiteDatabase has methods to create, delete, execute SQL commands, and
  * perform other common database management tasks.
  *
  * See the Notepad sample application in the SDK for an example of creating
  * and managing a database.
  *
  * Database names must be unique within an application, not across all applications.
  *
  */
 //提供管理一个SQLite database的方法，包括创建、删除、执行SQL语句和其他的任务
 public final class SQLiteDatabase extends SQLiteClosable { }

在SQLiteDatabase.java中,我们可以看到构造函数是私有的：

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

这意味着我们不能直接使用new的方式来创建SQLiteDatabase对象,那么在SQLiteDatabase类中就应该有一个供我们获取它的对象的方法,该方法就是

public static SQLiteDatabase openDatabase( String pat h, ... ...)

该方法的注释如下：

 /**
  * Open the database according to the flags {@link #OPEN_READWRITE}
  * {@link #OPEN_READONLY} {@link #CREATE_IF_NECESSARY} and/or {@link #NO_LOCALIZED_COLLATORS}.
  */
 //按照接收的flags参数打开一个数据库,这些参数包括OPEN_READWRITE、OPEN_READONLY等
 public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
         DatabaseErrorHandler errorHandler) {
     SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler);
     db.open();
     return db;
 }

在该方法中通过new SQLiteDatabase获得一个SQLiteDatabase对象并返回,并且在SQLiteDatabase.java中我们可以看到,

public static SQLiteDatabase openOrCreateDatabase(String path, CursorFactory factory)

public static SQLiteDatabase openOrCreateDatabase(String path, CursorFactory factory,DatabaseErrorHandler errorHandler)

public static SQLiteDatabase create(CursorFactory factory)

public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags)

这些方法最终都是在调用

public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,DatabaseErrorHandler errorHandler)方法来创建SQLiteDatabase实例.

而我们使用数据库的常见写法为:

 public class MySQLiteHelper extends SQLiteOpenHelper{
     ... ...
     @Override
     public void onCreate(SQLiteDatabase db) {
     db.execSQL("create table... ...}

     @Override
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
         ... ...
     }
 }
 ... ...
 public class myActivity extends Activity {
     ... ...
     myHelper = new MySQLiteHelper(this, "my.db", null, 1);
     SQLiteDatabase db = myHelper.getWritableDatabase();
     db.execSQL("insert ... ...
 }

于是问题就来了,既然我们最终会通过调用openDatabase()方法来获得一个SQLiteDatabase 实例,那么,

1、getWritableDatabase和getReadableDatabase方法最终是不是也会去调用openDatabase方法呢?

2、SQLiteOpenHelper类存在的目的是什么?

直接来看 SQLiteOpenHelper中的getWritableDatabase和getReadableDatabase方法:

 public SQLiteDatabase getWritableDatabase() {
     synchronized (this) {
         return getDatabaseLocked(true);
     }
 }

 public SQLiteDatabase getReadableDatabase() {
     synchronized (this) {
         return getDatabaseLocked(false);
     }
 }

两个方法里边都调用了getDatabaseLocked方法,只是传入的参数不同,一个为true,一个为false,该方法大致逻辑为:

 private SQLiteDatabase getDatabaseLocked(boolean writable) {
     //mDatabase是SQLiteOpenHelper的成员变量private SQLiteDatabase mDatabase
     if (mDatabase != null) {
         //在mDatabase != null的情况下,先判断mDatabase是否为open状态
         if (!mDatabase.isOpen()) {
             // Darn!  The user closed the database by calling mDatabase.close().
             //如果处于关闭状态,将mDatabase 置为null
             mDatabase = null;
         } else if (!writable || !mDatabase.isReadOnly()) {
             // The database is already open for business.
             //如果mDatabase为open状态并且是可读或者可写的,则将它返回,不会重新创建
             return mDatabase;
         }
     }

     //在mDatabase != null但是mDatabase处于关闭状态 和 mDatabase == null这两种情况下,
     //执行以下逻辑:
     if (mIsInitializing) {
         //如果正在执行初始化操作,则抛出异常
         throw new IllegalStateException("getDatabase called recursively");
     }

     //先将mDatabase赋给一个临时定义的SQLiteDatabase db
     SQLiteDatabase db = mDatabase;
     try {
         //更改db的初始化操作对应的标示mIsInitializing 的值为true
         mIsInitializing = true;
         if (db != null) {
             //如果db != null并且db处于关闭状态,那么
             if (writable && db.isReadOnly()) {
                  //重新以读写的方式打开db
                 db.reopenReadWrite();
             }
         } else if (mName == null) {
             //mName 是SQLiteOpenHelper的成员变量 private final String mName;
             //在我们执行myHelper = new MySQLiteHelper()时,在SQLiteOpenHelper的
             //构造函数中完成赋值,如果db == null并且mName == null 则
             //Create a memory backed SQLite database
             db = SQLiteDatabase.create(null);
         } else {
             //如果db == null但是mName != null 则执行下边的逻辑:
             try {
                 if (DEBUG_STRICT_READONLY && !writable) {
                     //调用getReadableDatabase方法将会执行到这里,接着调用openDatabase方法
                     //并最终执行SQLiteDatabase 中的openDatabase()方法
                     final String path = mContext.getDatabasePath(mName).getPath();
                     db = SQLiteDatabase.openDatabase(path, mFactory,
                             SQLiteDatabase.OPEN_READONLY, mErrorHandler);
                 } else {
                     //调用getWritableDatabase方法将会执行到这里,调用openOrCreateDatabase方法
                     //并最终执行SQLiteDatabase 中的openDatabase()方法
                     db = mContext.openOrCreateDatabase(mName, mEnableWriteAheadLogging ?
                             Context.MODE_ENABLE_WRITE_AHEAD_LOGGING : 0,
                             mFactory, mErrorHandler);
                 }
             } catch (SQLiteException ex) {
                 if (writable) {
                     throw ex;
                 }
                 Log.e(TAG, "Couldn't open " + mName
                         + " for writing (will try read-only):", ex);
                 final String path = mContext.getDatabasePath(mName).getPath();
                 db = SQLiteDatabase.openDatabase(path, mFactory,
                         SQLiteDatabase.OPEN_READONLY, mErrorHandler);
             }
         }
         //该方法在onCreate,onUpgrade,onDowngrade,onOpen等方法之前被调用,
         //主要是用来配置数据库的链接(翻译可能不准确,但不影响主要逻辑的理解)
         onConfigure(db);

         //到此为止,SQLiteDatabase的实例db的创建已经完成,
         //下边是关于version（版本升级和降级）的操作,来看一下具体逻辑:
         //获得db的版本:version
         final int version = db.getVersion();
         if (version != mNewVersion) {
             //如果version != mNewVersion,则执行这里的逻辑
             //mNewVersion是SQLiteOpenHelper的成员变量private final int mNewVersion;在我们
             //执行myHelper = new MySQLiteHelper()时,在SQLiteOpenHelper的构造函数中完成赋值
             if (db.isReadOnly()) {
                 //因为升级和降级需要对数据库进行写操作,所以如果db是只读的,那么就抛出异常
                 throw new SQLiteException("Can't upgrade read-only database from version " +
                         db.getVersion() + " to " + mNewVersion + ": " + mName);
             }

             db.beginTransaction();
             try {
                 if (version == 0) {
                     //第一次创建的SQLiteDatabase实例,其version的值应该是0
                     //(没有深入看db.getVersion()的逻辑)
                     //如果version == 0的话就执行onCreate(db)方法:
                     onCreate(db);
                     //于是我们自定义的MySQLiteHelper 类中复写的onCreate()方法就被调用了,
                     //接着用已经创建出来的SQLiteDatabase实例db去执行创建表的语句
                 } else {
                     //如果version != 0,则执行下边的逻辑:
                     if (version > mNewVersion) {
                         //如果version > mNewVersion(其值为new MySQLiteHelper()时传入)，则:
                         onDowngrade(db, version, mNewVersion);
                     } else {
                         //如果version < mNewVersion(其值为new MySQLiteHelper()时传入)，则:
                         onUpgrade(db, version, mNewVersion);
                     }
                 }
                 //执行完再将mNewVersion的值赋给db
                 db.setVersion(mNewVersion);
                 db.setTransactionSuccessful();
             } finally {
                 db.endTransaction();
             }
         }
         //执行onOpen()方法
         onOpen(db);

         if (db.isReadOnly()) {
             Log.w(TAG, "Opened " + mName + " in read-only mode");
         }
         //然后将db赋值给SQLiteOpenHelper的成员变量private SQLiteDatabase mDatabase
         //以便下次调用getDatabaseLocked()方法时,通过判断mDatabase 是否为null以及是否isOpen等
         //来确定怎么创建一个SQLiteDatabase实例
         mDatabase = db;
         //将db返回
         return db;
     } finally {
         //最后将mIsInitializing 的值设为false,表示SQLiteDatabase实例的初始化已经完成
         mIsInitializing = false;
         if (db != null && db != mDatabase) {
             db.close();
         }
     }
 }

上边第 91 行代码onCreate()方法的定义及注释 :

 /**
  * Called when the database is created for the first time. This is where the
  * creation of tables and the initial population of the tables should happen.
  *
  * @param db The database.
  */
 //该方法是在SQLiteDatabase第一次被创建的时候调用,表的创建和初始化操作在这里定义
 public abstract void onCreate(SQLiteDatabase db);

在分析了SQLiteOpenHelper中的getWritableDatabase和getReadableDatabase方法的大致逻辑之后.我们在上文中提出的两个问题也就好回答了.

1、SQLiteOpenHelper类中的getWritableDatabase和getReadableDatabase方法最终会调用SQLiteDatabase类中的openDatabase方法

2、SQLiteOpenHelper类存在的目的主要是以下两个方面：

A、对SQLiteDatabase类中的openDatabase方法进行封装,优化SQLiteDatabase的实例的创建

现在来看一下SQLiteOpenHelper中的getWritableDatabase和getReadableDatabase方法的注释吧：

getWritableDatabase()：

 /**
  * Create and/or open a database that will be used for reading and writing.
  * The first time this is called, the database will be opened and
  * {@link #onCreate}, {@link #onUpgrade} and/or {@link #onOpen} will be
  * called.
  *
  * <p>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 the database.)
  * Errors such as bad permissions or a full disk may cause this method
  * to fail, but future attempts may succeed if the problem is fixed.</p>
  *
  * <p class="caution">Database upgrade may take a long time, you
  * should not call this method from the application main thread, including
  * from {@link android.content.ContentProvider#onCreate ContentProvider.onCreate()}.
  *
  * @throws SQLiteException if the database cannot be opened for writing
  * @return a read/write database object valid until {@link #close} is called
  */
 //创建或打开一个可读写的database，第一次调用这个方法，database 将被打开和创建
 //onUpgrade和onOpen方法会被调用
 //一旦创建成功，database将被缓存，当你不再需要它时，记得调用close方法
 //错误的权限或者磁盘空间已满都会导致这个方法失败，但当这些问题被修复后该方法也可能执行成功
 //如果database不能被打开会抛出SQLiteException
 //返回的可读写的database对象将会一直有效直到close方法被调用
 public SQLiteDatabase getWritableDatabase() {
     synchronized (this) {
         return getDatabaseLocked(true);
     }
 }

getReadableDatabase()：

 /**
  * 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.
  *
  * <p class="caution">Like {@link #getWritableDatabase}, this method may
  * take a long time to return, so you should not call it from the
  * application main thread, including from
  * {@link android.content.ContentProvider#onCreate ContentProvider.onCreate()}.
  *
  * @throws SQLiteException if the database cannot be opened
  * @return a database object valid until {@link #getWritableDatabase}
  *     or {@link #close} is called.
  */
 //创建或打开一个database，这将和调用getWritableDatabase方法返回的对象是一样的
 //除非出现某些问题，比如磁盘空间已满
 //需要将此数据库以只读的方式打开，在这种情况下，一个只读的数据库对象将会被返回。
 //如果这些问题被解决了，继续调用getWritableDatabase方法可能成功，
 //这时，只读的database对象将被关闭而返回一个可读写的database对象
 //如果database不能被打开会抛出SQLiteException
 //返回的可读写的database对象将会一直有效直到close方法被调用
 public SQLiteDatabase getReadableDatabase() {
     synchronized (this) {
         return getDatabaseLocked(false);
     }
 }

结合它们的注释和上边对getDatabaseLocked方法逻辑的分析,将会更有利于我们理解SQLiteOpenHelper对SQLiteDatabase的实例创建的优化

B、方便对数据库进行升级和降级

在开发中,数据库升级和降级是比较常见的操作,如果没有SQLiteOpenHelper,我们应该也会采用和SQLiteOpenHelper类似的方法用一个标示来判断是否要对数据库进行升级或降级,而SQLiteOpenHelper已经为我们做了这个工作.(参考getDatabaseLocked方法中的分析)，让我们能够更加容易的管理数据库的版本。

再来看一下SQLiteOpenHelper类的注释:

 /**
  * A helper class to manage database creation and version management.
  *
  * <p>You create a subclass implementing {@link #onCreate}, {@link #onUpgrade} and
  * optionally {@link #onOpen}, and this class takes care of opening the database
  * if it exists, creating it if it does not, and upgrading it as necessary.
  * Transactions are used to make sure the database is always in a sensible state.
  */
 //这是一个管理数据库的创建和版本的帮助类，创建一个子类实现onCreate()、onUpdate()和可选的onOpen()
 //方法此类负责打开一个数据库（如果存在）或者创建一个数据库（如果不存在），并在需要时进行更新... ...
 //事务被用来确保数据库处于一个正确的状态
 public abstract class SQLiteOpenHelper { }

到此为止，SQLiteOpenHelper类的注释中的 "A helper class to manage database creation and version management."这句话也就好理解了

还需要关注一下SQLiteOpenHelper的构造函数：

 /**
  * Create a helper object to create, open, and/or manage a database.
  * This method always returns very quickly.  The database is not actually
  * created or opened until one of {@link #getWritableDatabase} or
  * {@link #getReadableDatabase} is called.
  *
  * @param context to use to open or create the database
  * @param name of the database file, or null for an in-memory database
  * @param factory to use for creating cursor objects, or null for the default
  * @param version number of the database (starting at 1); if the database is older,
  *     {@link #onUpgrade} will be used to upgrade the database; if the database is
  *     newer, {@link #onDowngrade} will be used to downgrade the database
  */
 //创建一个helper来创建、打开和管理数据库，数据库并不会真正的被创建直到getWritableDatabase()和
 //getReadableDatabase()方法被调用.接收的四个参数分别是：
 //context  上下文
 //name     数据库的名称，或者为null for an in-memory database
 //factory  一个用于创建游标的工厂，默认是null
 //version  数据库版本号，从1开始，这将是调用onUpgrade更新或是调用onDowngrade降级数据库的根据
 public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version) {
     this(context, name, factory, version, null);
 }

这个构造函数内部调用了下边的构造函数：

 /**
  * @param errorHandler the {@link DatabaseErrorHandler} to be used when sqlite reports database
  * corruption, or null to use the default error handler.
  */
 //和上边的构造函数不同的是多了一个DatabaseErrorHandler errorHandler，当sqlite报告了错误,
 //由errorHandler来处理，如果errorHandler为null，就由默认处理
 public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version,
         DatabaseErrorHandler errorHandler) {
     if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);

     mContext = context;
     mName = name;
     mFactory = factory;
     mNewVersion = version;
     mErrorHandler = errorHandler;
 }

这两个构造函数的注释再结合上边对getDatabaseLocked方法逻辑的分析,我们就更容易理解在创建SQLiteOpenHelper的子类对象时传入的name和version参数了.

以上我们对  SQLiteOpenHelper在 SQLiteDatabase的实例创建上的优化  和 对数据库表的升级和降级功能的封装 两方面做了详细的分析,下边我们来看SQLiteDatabase类定义的方法的使用,即数据库的操作.

二、数据库的操作


关于数据库的使用，有不少好文章可以参考，暂不详细写了

ContentValues类的注释：

 /**
  * This class is used to store a set of values that the {@link ContentResolver}
  * can process.
  */
 //该类用来存储键值对值
 public final class ContentValues implements Parcelable { }

查看ContentValues.java文件，可以发现，该类就一个主要的成员变量：private HashMap<String, Object> mValues;在ContentValues的各个构造函数中，主要的操作就是根据不同的需求对mValues进行初始化，并且在该类中定义了诸如put(String key, String value)和getAsString(String key)等方法：

put类方法，以put(String key, String value)为例：

 /**
  * Adds a value to the set.
  *
  * @param key the name of the value to put
  * @param value the data for the value to put
  */
 public void put(String key, String value) {
     mValues.put(key, value);
 }

get类方法，以getAsString(String key)为例:

 /**
  * Gets a value and converts it to a String.
  *
  * @param key the value to get
  * @return the String for the value
  */
 public String getAsString(String key) {
     Object value = mValues.get(key);
     return value != null ? value.toString() : null;
 }

另外，还有public int size()、public boolean containsKey(String key)、public void clear()、public Set<String> keySet()等，可以认为ContentValues类就是对HashMap的一个封装。

三、数据库的升级

未完待续 ... ...