Android数据库一些源码分析

对于批量数据插入这种最常见的情况来说，我们来看两种实现方式（两种都用了事务）。

下面这种应该是最多人使用的插入数据的方法：

public long addByExec(List<Person> persons) {

long start = System.currentTimeMillis();
db.beginTransaction();

for (Person person : persons) {
db.execSQL(" INSERT INTO person(name,age,info) VALUES(?, ?, ?) ",
new Object[] { person.name, person.age, person.info });
}

db.setTransactionSuccessful();
long end = System.currentTimeMillis();
db.endTransaction();
return end - start;

}

再看一种比较少用的插入方法

public long addByStatement(List<Person> persons) {
long start = System.currentTimeMillis();
db.beginTransaction();
SQLiteStatement sqLiteStatement = db.compileStatement(sql);

for (Person person : persons) {
sqLiteStatement.bindString(1, person.name);
sqLiteStatement.bindString(2, person.age);
sqLiteStatement.bindString(3, person.info);
sqLiteStatement.executeInsert();
}
db.setTransactionSuccessful();
long end = System.currentTimeMillis();
db.endTransaction();
return end - start;
}

然后我们分别用这两个方法 来向数据库里面插入一万条数据 看看耗时多少。为了演示效果更加突出一点，我录制了一个GIF，同时，

这2个方法我也没有用子线程来操作他，直接在ui线程上操作 所以看起来效果会比较突出一些（但是自己写代码的时候千万别这么写小心ANR）。



可以看出来后者耗时几乎只有前者的 一半（所以以后大家在做大批量数据插入的时候可以考虑后者的实现方式）。我们来看看源代码为啥会这样。

首先看前者的实现方法源码

public void execSQL(String sql, Object[] bindArgs) throws SQLException {
if (bindArgs == null) {
throw new IllegalArgumentException("Empty bindArgs");
}
executeSql(sql, bindArgs);
}

private int executeSql(String sql, Object[] bindArgs) throws SQLException {
if (DatabaseUtils.getSqlStatementType(sql) == DatabaseUtils.STATEMENT_ATTACH) {
disableWriteAheadLogging();
mHasAttachedDbs = true;
}
SQLiteStatement statement = new SQLiteStatement(this, sql, bindArgs);
try {
return statement.executeUpdateDelete();
} catch (SQLiteDatabaseCorruptException e) {
onCorruption();
throw e;
} finally {
statement.close();
}
}

我们发现 前者的实现 实际上最后也是通过SQLiteStatement 这个类是操作的。

而后者不过是

public SQLiteStatement compileStatement(String sql) throws SQLException {
verifyDbIsOpen();
return new SQLiteStatement(this, sql, null);
}

所以实际上前者之所以比后者耗时 应该是下面这段代码的原因：

if (DatabaseUtils.getSqlStatementType(sql) == DatabaseUtils.STATEMENT_ATTACH) {
disableWriteAheadLogging();
mHasAttachedDbs = true;
}

public static int getSqlStatementType(String sql) {
sql = sql.trim();
if (sql.length() < 3) {
return STATEMENT_OTHER;
}
String prefixSql = sql.substring(0, 3).toUpperCase();
if (prefixSql.equals("SEL")) {
return STATEMENT_SELECT;
} else if (prefixSql.equals("INS") ||
prefixSql.equals("UPD") ||
prefixSql.equals("REP") ||
prefixSql.equals("DEL")) {
return STATEMENT_UPDATE;
} else if (prefixSql.equals("ATT")) {
return STATEMENT_ATTACH;
} else if (prefixSql.equals("COM")) {
return STATEMENT_COMMIT;
} else if (prefixSql.equals("END")) {
return STATEMENT_COMMIT;
} else if (prefixSql.equals("ROL")) {
return STATEMENT_ABORT;
} else if (prefixSql.equals("BEG")) {
return STATEMENT_BEGIN;
} else if (prefixSql.equals("PRA")) {
return STATEMENT_PRAGMA;
} else if (prefixSql.equals("CRE") || prefixSql.equals("DRO") ||
prefixSql.equals("ALT")) {
return STATEMENT_DDL;
} else if (prefixSql.equals("ANA") || prefixSql.equals("DET")) {
return STATEMENT_UNPREPARED;
}
return STATEMENT_OTHER;
}

实际上就是多了一个字符串处理的函数。这就是为什么前者耗时要比后者多。因为实际上直接调用executeSql的时候

他里面是先做字符串处理然后再调用SQLiteStatement来执行，这个过程当然是比我们直接调用SQLiteStatement

来执行速度慢的。

我们首先来看一下下面这个函数

public Cursor queryTest1() {
long start1 = System.currentTimeMillis();
Cursor c = db.rawQuery("select * from t1,t3 where t1.num>t3.num", null);
long end1 = System.currentTimeMillis();
Log.v("DBManager", "time1 need " + (end1 - start1));
long start2 = System.currentTimeMillis();
c.moveToNext();
long end2 = System.currentTimeMillis();
Log.v("DBManager", "time2 need" + (end2 - start2));
long start3 = System.currentTimeMillis();
c.moveToNext();
long end3 = System.currentTimeMillis();
Log.v("DBManager", "time3 need" + (end3 - start3));
return c;
}

一个很常见的，多表查询的函数，有些人可能会奇怪为啥在这个地方我要加那么多日志。实际上如果你t1和t3的数据都很多的话，这个查询是可以预料到的会非常耗时。

很多人都会以为这个耗时是在下面这条语句做的：

Cursor c = db.rawQuery("select * from t1,t3 where t1.num>t3.num", null);

但是实际上这个查询耗时是在你第一调用

c.moveToNext();

来做的，有兴趣的同学可以自己试一下，我们这里就不帮大家来演示这个效果了，但是可以帮助大家分析一下源代码为什么会是这样奇怪的结果？

我们首先来分析一下rawQuery 这个函数

public Cursor rawQuery(String sql, String[] selectionArgs) {
return rawQueryWithFactory(null, sql, selectionArgs, null);
}

/**
* Runs the provided SQL and returns a cursor over the result set.
*
* @param cursorFactory the cursor factory to use, or null for the default factory
* @param sql the SQL query. The SQL string must not be ; terminated
* @param selectionArgs You may include ?s in where clause in the query,
*     which will be replaced by the values from selectionArgs. The
*     values will be bound as Strings.
* @param editTable the name of the first table, which is editable
* @return A {@link Cursor} object, which is positioned before the first entry. Note that
* {@link Cursor}s are not synchronized, see the documentation for more details.
*/
public Cursor rawQueryWithFactory(
CursorFactory cursorFactory, String sql, String[] selectionArgs,
String editTable) {
verifyDbIsOpen();
BlockGuard.getThreadPolicy().onReadFromDisk();

SQLiteDatabase db = getDbConnection(sql);
SQLiteCursorDriver driver = new SQLiteDirectCursorDriver(db, sql, editTable);

Cursor cursor = null;
try {
cursor = driver.query(
cursorFactory != null ? cursorFactory : mFactory,
selectionArgs);
} finally {
releaseDbConnection(db);
}
return cursor;
}

看一下24行，发现是构造了一个driver对象 然后调用这个driver对象的query方法

我们继续跟踪源代码

public SQLiteDirectCursorDriver(SQLiteDatabase db, String sql, String editTable,
CancellationSignal cancellationSignal) {
mDatabase = db;
mEditTable = editTable;
mSql = sql;
mCancellationSignal = cancellationSignal;
}

public Cursor query(CursorFactory factory, String[] selectionArgs) {
final SQLiteQuery query = new SQLiteQuery(mDatabase, mSql, mCancellationSignal);
final Cursor cursor;
try {
query.bindAllArgsAsStrings(selectionArgs);

if (factory == null) {
cursor = new SQLiteCursor(this, mEditTable, query);
} else {
cursor = factory.newCursor(mDatabase, this, mEditTable, query);
}
} catch (RuntimeException ex) {
query.close();
throw ex;
}

mQuery = query;
return cursor;
}

发现这个返回的cursor实际上就是直接new出来的一个对象

public SQLiteCursor(SQLiteCursorDriver driver, String editTable, SQLiteQuery query) {
if (query == null) {
throw new IllegalArgumentException("query object cannot be null");
}
if (query.mDatabase == null) {
throw new IllegalArgumentException("query.mDatabase cannot be null");
}
mStackTrace = new DatabaseObjectNotClosedException().fillInStackTrace();
mDriver = driver;
mEditTable = editTable;
mColumnNameMap = null;
mQuery = query;

query.mDatabase.lock(query.mSql);
try {
// Setup the list of columns
int columnCount = mQuery.columnCountLocked();
mColumns = new String[columnCount];

// Read in all column names
for (int i = 0; i < columnCount; i++) {
String columnName = mQuery.columnNameLocked(i);
mColumns[i] = columnName;
if (false) {
Log.v("DatabaseWindow", "mColumns[" + i + "] is "
+ mColumns[i]);
}

// Make note of the row ID column index for quick access to it
if ("_id".equals(columnName)) {
mRowIdColumnIndex = i;
}
}
} finally {
query.mDatabase.unlock();
}
}

所以看到这里我们就能确定的是rawquery这个方法 返回的cursor实际上就是一个对象，并没有任何真正调用sql的地方。

然后我们来看看我们怀疑的moveToNext这个方法因为从日志上看耗时的地方在第一次调用他的时候，所以我们怀疑真正调用查询sql的地方

在这个函数里面被触发。

public final boolean moveToNext() {
return moveToPosition(mPos + 1);
}

public final boolean moveToPosition(int position) {
// Make sure position isn't past the end of the cursor
final int count = getCount();
if (position >= count) {
mPos = count;
return false;
}

// Make sure position isn't before the beginning of the cursor
if (position < 0) {
mPos = -1;
return false;
}

// Check for no-op moves, and skip the rest of the work for them
if (position == mPos) {
return true;
}

boolean result = onMove(mPos, position);
if (result == false) {
mPos = -1;
} else {
mPos = position;
if (mRowIdColumnIndex != -1) {
mCurrentRowID = Long.valueOf(getLong(mRowIdColumnIndex));
}
}

return result;
}

看一下那个getcount方法

@Override
public int getCount() {
if (mCount == NO_COUNT) {
fillWindow(0);
}
return mCount;
}

private void fillWindow(int startPos) {
clearOrCreateLocalWindow(getDatabase().getPath());
mWindow.setStartPosition(startPos);
int count = getQuery().fillWindow(mWindow);
if (startPos == 0) { // fillWindow returns count(*) only for startPos = 0
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "received count(*) from native_fill_window: " + count);
}
mCount = count;
} else if (mCount <= 0) {
throw new IllegalStateException("Row count should never be zero or negative "
+ "when the start position is non-zero");
}
}

发现如果满足某个条件的话 就调用fillwindow这个方法，我们来看看是什么条件

/** The number of rows in the cursor */
private volatile int mCount = NO_COUNT;
static final int NO_COUNT = -1;

看到这就明白了，如果你默认的mCount为-1的话就代表你这个cursor里面还没有查过吗，所以必须要调用fillwindow方法

private synchronized SQLiteQuery getQuery() {
return mQuery;
}

我们来看看这个query是什么

/** The query object for the cursor */
private SQLiteQuery mQuery;

看看他的fillwindow方法

/**
* Reads rows into a buffer. This method acquires the database lock.
*
* @param window The window to fill into
* @return number of total rows in the query
*/
/* package */ int fillWindow(CursorWindow window) {
mDatabase.lock(mSql);
long timeStart = SystemClock.uptimeMillis();
try {
acquireReference();
try {
window.acquireReference();
int startPos = window.getStartPosition();
int numRows = nativeFillWindow(nHandle, nStatement, window.mWindowPtr,
startPos, mOffsetIndex);
if (SQLiteDebug.DEBUG_LOG_SLOW_QUERIES) {
long elapsed = SystemClock.uptimeMillis() - timeStart;
if (SQLiteDebug.shouldLogSlowQuery(elapsed)) {
Log.d(TAG, "fillWindow took " + elapsed
+ " ms: window=\"" + window
+ "\", startPos=" + startPos
+ ", offset=" + mOffsetIndex
+ ", filledRows=" + window.getNumRows()
+ ", countedRows=" + numRows
+ ", query=\"" + mSql + "\""
+ ", args=[" + (mBindArgs != null ?
TextUtils.join(", ", mBindArgs.values()) : "")
+ "]");
}
}
mDatabase.logTimeStat(mSql, timeStart);
return numRows;
} catch (IllegalStateException e){
// simply ignore it
return 0;
} catch (SQLiteDatabaseCorruptException e) {
mDatabase.onCorruption();
throw e;
} catch (SQLiteException e) {
Log.e(TAG, "exception: " + e.getMessage() + "; query: " + mSql);
throw e;
} finally {
window.releaseReference();
}
} finally {
releaseReference();
mDatabase.unlock();
}
}

一目了然，其实就是rawquery返回的是一个没有意义的cursor对象里面什么都没有，当你调用movetonext之类的方法的时候，

会判断是否里面没有数据 如果有数据就返回你要的数据，如果没有的话，实际上最终调用的就是SQLiteQuery这个类的fillwindow方法

来最终执行你写的sql语句~~耗时也就是在这里耗时！！！！！切记！不是在rawquery里耗时的！