Merge "Rewrite SQLite database wrappers."

40 files changed, 5224 insertions, 5827 deletions

diff --git a/api/current.txt b/api/current.txt
index fa2a475..8e93499 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -7204,7 +7204,7 @@ package android.database.sqlite {
     method public long insertWithOnConflict(java.lang.String, java.lang.String, android.content.ContentValues, int);
     method public boolean isDatabaseIntegrityOk();
     method public boolean isDbLockedByCurrentThread();
-    method public boolean isDbLockedByOtherThreads();
+    method public deprecated boolean isDbLockedByOtherThreads();
     method public boolean isOpen();
     method public boolean isReadOnly();
     method public deprecated void markTableSyncable(java.lang.String, java.lang.String);
@@ -7226,7 +7226,7 @@ package android.database.sqlite {
     method public long replace(java.lang.String, java.lang.String, android.content.ContentValues);
     method public long replaceOrThrow(java.lang.String, java.lang.String, android.content.ContentValues) throws android.database.SQLException;
     method public void setLocale(java.util.Locale);
-    method public void setLockingEnabled(boolean);
+    method public deprecated void setLockingEnabled(boolean);
     method public void setMaxSqlCacheSize(int);
     method public long setMaximumSize(long);
     method public void setPageSize(long);
diff --git a/core/java/android/database/sqlite/DatabaseConnectionPool.java b/core/java/android/database/sqlite/DatabaseConnectionPool.java
deleted file mode 100644
index 39a9d23..0000000
--- a/core/java/android/database/sqlite/DatabaseConnectionPool.java
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- * Copyright (C) 20010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.database.sqlite;
-
-import android.content.res.Resources;
-import android.os.SystemClock;
-import android.util.Log;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Random;
-
-/**
- * A connection pool to be used by readers.
- * Note that each connection can be used by only one reader at a time.
- */
-/* package */ class DatabaseConnectionPool {
-
-    private static final String TAG = "DatabaseConnectionPool";
-
-    /** The default connection pool size. */
-    private volatile int mMaxPoolSize =
-        Resources.getSystem().getInteger(com.android.internal.R.integer.db_connection_pool_size);
-
-    /** The connection pool objects are stored in this member.
-     * TODO: revisit this data struct as the number of pooled connections increase beyond
-     * single-digit values.
-     */
-    private final ArrayList<PoolObj> mPool = new ArrayList<PoolObj>(mMaxPoolSize);
-
-    /** the main database connection to which this connection pool is attached */
-    private final SQLiteDatabase mParentDbObj;
-
-    /** Random number generator used to pick a free connection out of the pool */
-    private Random rand; // lazily initialized
-
-    /* package */ DatabaseConnectionPool(SQLiteDatabase db) {
-        this.mParentDbObj = db;
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.d(TAG, "Max Pool Size: " + mMaxPoolSize);
-        }
-    }
-
-    /**
-     * close all database connections in the pool - even if they are in use!
-     */
-    /* package */ synchronized void close() {
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.d(TAG, "Closing the connection pool on " + mParentDbObj.getPath() + toString());
-        }
-        for (int i = mPool.size() - 1; i >= 0; i--) {
-            mPool.get(i).mDb.close();
-        }
-        mPool.clear();
-    }
-
-    /**
-     * get a free connection from the pool
-     *
-     * @param sql if not null, try to find a connection inthe pool which already has cached
-     * the compiled statement for this sql.
-     * @return the Database connection that the caller can use
-     */
-    /* package */ synchronized SQLiteDatabase get(String sql) {
-        SQLiteDatabase db = null;
-        PoolObj poolObj = null;
-        int poolSize = mPool.size();
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            assert sql != null;
-            doAsserts();
-        }
-        if (getFreePoolSize() == 0) {
-            // no free ( = available) connections
-            if (mMaxPoolSize == poolSize) {
-                // maxed out. can't open any more connections.
-                // let the caller wait on one of the pooled connections
-                // preferably a connection caching the pre-compiled statement of the given SQL
-                if (mMaxPoolSize == 1) {
-                    poolObj = mPool.get(0);
-                } else {
-                    for (int i = 0; i < mMaxPoolSize; i++) {
-                        if (mPool.get(i).mDb.isInStatementCache(sql)) {
-                            poolObj = mPool.get(i);
-                            break;
-                        }
-                    }
-                    if (poolObj == null) {
-                        // there are no database connections with the given SQL pre-compiled.
-                        // ok to return any of the connections.
-                        if (rand == null) {
-                            rand = new Random(SystemClock.elapsedRealtime());
-                        }
-                        poolObj = mPool.get(rand.nextInt(mMaxPoolSize));
-                    }
-                }
-                db = poolObj.mDb;
-            } else {
-                // create a new connection and add it to the pool, since we haven't reached
-                // max pool size allowed
-                db = mParentDbObj.createPoolConnection((short)(poolSize + 1));
-                poolObj = new PoolObj(db);
-                mPool.add(poolSize, poolObj);
-            }
-        } else {
-            // there are free connections available. pick one
-            // preferably a connection caching the pre-compiled statement of the given SQL
-            for (int i = 0; i < poolSize; i++) {
-                if (mPool.get(i).isFree() && mPool.get(i).mDb.isInStatementCache(sql)) {
-                    poolObj = mPool.get(i);
-                    break;
-                }
-            }
-            if (poolObj == null) {
-                // didn't find a free database connection with the given SQL already
-                // pre-compiled. return a free connection (this means, the same SQL could be
-                // pre-compiled on more than one database connection. potential wasted memory.)
-                for (int i = 0; i < poolSize; i++) {
-                    if (mPool.get(i).isFree()) {
-                        poolObj = mPool.get(i);
-                        break;
-                    }
-                }
-            }
-            db = poolObj.mDb;
-        }
-
-        assert poolObj != null;
-        assert poolObj.mDb == db;
-
-        poolObj.acquire();
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.d(TAG, "END get-connection: " + toString() + poolObj.toString());
-        }
-        return db;
-        // TODO if a thread acquires a connection and dies without releasing the connection, then
-        // there could be a connection leak.
-    }
-
-    /**
-     * release the given database connection back to the pool.
-     * @param db the connection to be released
-     */
-    /* package */ synchronized void release(SQLiteDatabase db) {
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            assert db.mConnectionNum > 0;
-            doAsserts();
-            assert mPool.get(db.mConnectionNum - 1).mDb == db;
-        }
-
-        PoolObj poolObj = mPool.get(db.mConnectionNum - 1);
-
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.d(TAG, "BEGIN release-conn: " + toString() + poolObj.toString());
-        }
-
-        if (poolObj.isFree()) {
-            throw new IllegalStateException("Releasing object already freed: " +
-                    db.mConnectionNum);
-        }
-
-        poolObj.release();
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.d(TAG, "END release-conn: " + toString() + poolObj.toString());
-        }
-    }
-
-    /**
-     * Returns a list of all database connections in the pool (both free and busy connections).
-     * This method is used when "adb bugreport" is done.
-     */
-    /* package */ synchronized ArrayList<SQLiteDatabase> getConnectionList() {
-        ArrayList<SQLiteDatabase> list = new ArrayList<SQLiteDatabase>();
-        for (int i = mPool.size() - 1; i >= 0; i--) {
-            list.add(mPool.get(i).mDb);
-        }
-        return list;
-    }
-
-    /**
-     * package level access for testing purposes only. otherwise, private should be sufficient.
-     */
-    /* package */ int getFreePoolSize() {
-        int count = 0;
-        for (int i = mPool.size() - 1; i >= 0; i--) {
-            if (mPool.get(i).isFree()) {
-                count++;
-            }
-        }
-        return count++;
-    }
-
-    /**
-     * only for testing purposes
-     */
-    /* package */ ArrayList<PoolObj> getPool() {
-        return mPool;
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder buff = new StringBuilder();
-        buff.append("db: ");
-        buff.append(mParentDbObj.getPath());
-        buff.append(", totalsize = ");
-        buff.append(mPool.size());
-        buff.append(", #free = ");
-        buff.append(getFreePoolSize());
-        buff.append(", maxpoolsize = ");
-        buff.append(mMaxPoolSize);
-        for (PoolObj p : mPool) {
-            buff.append("\n");
-            buff.append(p.toString());
-        }
-        return buff.toString();
-    }
-
-    private void doAsserts() {
-        for (int i = 0; i < mPool.size(); i++) {
-            mPool.get(i).verify();
-            assert mPool.get(i).mDb.mConnectionNum == (i + 1);
-        }
-    }
-
-    /** only used for testing purposes. */
-    /* package */ synchronized void setMaxPoolSize(int size) {
-        mMaxPoolSize = size;
-    }
-
-    /** only used for testing purposes. */
-    /* package */ synchronized int getMaxPoolSize() {
-        return mMaxPoolSize;
-    }
-
-    /** only used for testing purposes. */
-    /* package */ boolean isDatabaseObjFree(SQLiteDatabase db) {
-        return mPool.get(db.mConnectionNum - 1).isFree();
-    }
-
-    /** only used for testing purposes. */
-    /* package */ int getSize() {
-        return mPool.size();
-    }
-
-    /**
-     * represents objects in the connection pool.
-     * package-level access for testing purposes only.
-     */
-    /* package */ static class PoolObj {
-
-        private final SQLiteDatabase mDb;
-        private boolean mFreeBusyFlag = FREE;
-        private static final boolean FREE = true;
-        private static final boolean BUSY = false;
-
-        /** the number of threads holding this connection */
-        // @GuardedBy("this")
-        private int mNumHolders = 0;
-
-        /** contains the threadIds of the threads holding this connection.
-         * used for debugging purposes only.
-         */
-        // @GuardedBy("this")
-        private HashSet<Long> mHolderIds = new HashSet<Long>();
-
-        public PoolObj(SQLiteDatabase db) {
-            mDb = db;
-        }
-
-        private synchronized void acquire() {
-            if (Log.isLoggable(TAG, Log.DEBUG)) {
-                assert isFree();
-                long id = Thread.currentThread().getId();
-                assert !mHolderIds.contains(id);
-                mHolderIds.add(id);
-            }
-
-            mNumHolders++;
-            mFreeBusyFlag = BUSY;
-        }
-
-        private synchronized void release() {
-            if (Log.isLoggable(TAG, Log.DEBUG)) {
-                long id = Thread.currentThread().getId();
-                assert mHolderIds.size() == mNumHolders;
-                assert mHolderIds.contains(id);
-                mHolderIds.remove(id);
-            }
-
-            mNumHolders--;
-            if (mNumHolders == 0) {
-                mFreeBusyFlag = FREE;
-            }
-        }
-
-        private synchronized boolean isFree() {
-            if (Log.isLoggable(TAG, Log.DEBUG)) {
-                verify();
-            }
-            return (mFreeBusyFlag == FREE);
-        }
-
-        private synchronized void verify() {
-            if (mFreeBusyFlag == FREE) {
-                assert mNumHolders == 0;
-            } else {
-                assert mNumHolders > 0;
-            }
-        }
-
-        /**
-         * only for testing purposes
-         */
-        /* package */ synchronized int getNumHolders() {
-            return mNumHolders;
-        }
-
-        @Override
-        public String toString() {
-            StringBuilder buff = new StringBuilder();
-            buff.append(", conn # ");
-            buff.append(mDb.mConnectionNum);
-            buff.append(", mCountHolders = ");
-            synchronized(this) {
-                buff.append(mNumHolders);
-                buff.append(", freeBusyFlag = ");
-                buff.append(mFreeBusyFlag);
-                for (Long l : mHolderIds) {
-                    buff.append(", id = " + l);
-                }
-            }
-            return buff.toString();
-        }
-    }
-}
diff --git a/core/java/android/database/sqlite/SQLiteClosable.java b/core/java/android/database/sqlite/SQLiteClosable.java
index 01e9fb3..7e91a7b 100644
--- a/core/java/android/database/sqlite/SQLiteClosable.java
+++ b/core/java/android/database/sqlite/SQLiteClosable.java
@@ -16,8 +16,6 @@
 
 package android.database.sqlite;
 
-import android.database.CursorWindow;
-
 /**
  * An object created from a SQLiteDatabase that can be closed.
  */
@@ -31,7 +29,7 @@ public abstract class SQLiteClosable {
         synchronized(this) {
             if (mReferenceCount <= 0) {
                 throw new IllegalStateException(
-                        "attempt to re-open an already-closed object: " + getObjInfo());
+                        "attempt to re-open an already-closed object: " + this);
             }
             mReferenceCount++;
         }
@@ -56,22 +54,4 @@ public abstract class SQLiteClosable {
             onAllReferencesReleasedFromContainer();
         }
     }
-
-    private String getObjInfo() {
-        StringBuilder buff = new StringBuilder();
-        buff.append(this.getClass().getName());
-        buff.append(" (");
-        if (this instanceof SQLiteDatabase) {
-            buff.append("database = ");
-            buff.append(((SQLiteDatabase)this).getPath());
-        } else if (this instanceof SQLiteProgram) {
-            buff.append("mSql = ");
-            buff.append(((SQLiteProgram)this).mSql);
-        } else if (this instanceof CursorWindow) {
-            buff.append("mStartPos = ");
-            buff.append(((CursorWindow)this).getStartPosition());
-        }
-        buff.append(") ");
-        return buff.toString();
-    }
 }
diff --git a/core/java/android/database/sqlite/SQLiteCompiledSql.java b/core/java/android/database/sqlite/SQLiteCompiledSql.java
deleted file mode 100644
index dafbc79..0000000
--- a/core/java/android/database/sqlite/SQLiteCompiledSql.java
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.database.sqlite;
-
-import android.os.StrictMode;
-import android.util.Log;
-
-/**
- * This class encapsulates compilation of sql statement and release of the compiled statement obj.
- * Once a sql statement is compiled, it is cached in {@link SQLiteDatabase}
- * and it is released in one of the 2 following ways
- * 1. when {@link SQLiteDatabase} object is closed.
- * 2. if this is not cached in {@link SQLiteDatabase}, {@link android.database.Cursor#close()}
- * releaases this obj.
- */
-/* package */ class SQLiteCompiledSql {
-
-    private static final String TAG = "SQLiteCompiledSql";
-
-    /** The database this program is compiled against. */
-    /* package */ final SQLiteDatabase mDatabase;
-
-    /**
-     * Native linkage, do not modify. This comes from the database.
-     */
-    /* package */ final int nHandle;
-
-    /**
-     * Native linkage, do not modify. When non-0 this holds a reference to a valid
-     * sqlite3_statement object. It is only updated by the native code, but may be
-     * checked in this class when the database lock is held to determine if there
-     * is a valid native-side program or not.
-     */
-    /* package */ int nStatement = 0;
-
-    /** the following are for debugging purposes */
-    private String mSqlStmt = null;
-    private final Throwable mStackTrace;
-
-    /** when in cache and is in use, this member is set */
-    private boolean mInUse = false;
-
-    /* package */ SQLiteCompiledSql(SQLiteDatabase db, String sql) {
-        db.verifyDbIsOpen();
-        db.verifyLockOwner();
-        mDatabase = db;
-        mSqlStmt = sql;
-        if (StrictMode.vmSqliteObjectLeaksEnabled()) {
-            mStackTrace = new DatabaseObjectNotClosedException().fillInStackTrace();
-        } else {
-            mStackTrace = null;
-        }
-        nHandle = db.mNativeHandle;
-        native_compile(sql);
-    }
-
-    /* package */ void releaseSqlStatement() {
-        // Note that native_finalize() checks to make sure that nStatement is
-        // non-null before destroying it.
-        if (nStatement != 0) {
-            mDatabase.finalizeStatementLater(nStatement);
-            nStatement = 0;
-        }
-    }
-
-    /**
-     * returns true if acquire() succeeds. false otherwise.
-     */
-    /* package */ synchronized boolean acquire() {
-        if (mInUse) {
-            // it is already in use.
-            return false;
-        }
-        mInUse = true;
-        return true;
-    }
-
-    /* package */ synchronized void release() {
-        mInUse = false;
-    }
-
-    /* package */ synchronized void releaseIfNotInUse() {
-        // if it is not in use, release its memory from the database
-        if (!mInUse) {
-            releaseSqlStatement();
-        }
-    }
-
-    /**
-     * Make sure that the native resource is cleaned up.
-     */
-    @Override
-    protected void finalize() throws Throwable {
-        try {
-            if (nStatement == 0) return;
-            // don't worry about finalizing this object if it is ALREADY in the
-            // queue of statements to be finalized later
-            if (mDatabase.isInQueueOfStatementsToBeFinalized(nStatement)) {
-                return;
-            }
-            // finalizer should NEVER get called
-            // but if the database itself is not closed and is GC'ed, then
-            // all sub-objects attached to the database could end up getting GC'ed too.
-            // in that case, don't print any warning.
-            if (mInUse && mStackTrace != null) {
-                int len = mSqlStmt.length();
-                StrictMode.onSqliteObjectLeaked(
-                    "Releasing statement in a finalizer. Please ensure " +
-                    "that you explicitly call close() on your cursor: " +
-                    mSqlStmt.substring(0, (len > 1000) ? 1000 : len),
-                    mStackTrace);
-            }
-            releaseSqlStatement();
-        } finally {
-            super.finalize();
-        }
-    }
-
-    @Override public String toString() {
-        synchronized(this) {
-            StringBuilder buff = new StringBuilder();
-            buff.append(" nStatement=");
-            buff.append(nStatement);
-            buff.append(", mInUse=");
-            buff.append(mInUse);
-            buff.append(", db=");
-            buff.append(mDatabase.getPath());
-            buff.append(", db_connectionNum=");
-            buff.append(mDatabase.mConnectionNum);
-            buff.append(", sql=");
-            int len = mSqlStmt.length();
-            buff.append(mSqlStmt.substring(0, (len > 100) ? 100 : len));
-            return buff.toString();
-        }
-    }
-
-    /**
-     * Compiles SQL into a SQLite program.
-     *
-     * <P>The database lock must be held when calling this method.
-     * @param sql The SQL to compile.
-     */
-    private final native void native_compile(String sql);
-}
diff --git a/core/java/android/database/sqlite/SQLiteConnection.java b/core/java/android/database/sqlite/SQLiteConnection.java
new file mode 100644
index 0000000..e45d66d
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteConnection.java
@@ -0,0 +1,1149 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+import dalvik.system.BlockGuard;
+import dalvik.system.CloseGuard;
+
+import android.database.Cursor;
+import android.database.CursorWindow;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDebug.DbStats;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+import android.util.LruCache;
+import android.util.Printer;
+
+import java.sql.Date;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Represents a SQLite database connection.
+ * Each connection wraps an instance of a native <code>sqlite3</code> object.
+ * <p>
+ * When database connection pooling is enabled, there can be multiple active
+ * connections to the same database.  Otherwise there is typically only one
+ * connection per database.
+ * </p><p>
+ * When the SQLite WAL feature is enabled, multiple readers and one writer
+ * can concurrently access the database.  Without WAL, readers and writers
+ * are mutually exclusive.
+ * </p>
+ *
+ * <h2>Ownership and concurrency guarantees</h2>
+ * <p>
+ * Connection objects are not thread-safe.  They are acquired as needed to
+ * perform a database operation and are then returned to the pool.  At any
+ * given time, a connection is either owned and used by a {@link SQLiteSession}
+ * object or the {@link SQLiteConnectionPool}.  Those classes are
+ * responsible for serializing operations to guard against concurrent
+ * use of a connection.
+ * </p><p>
+ * The guarantee of having a single owner allows this class to be implemented
+ * without locks and greatly simplifies resource management.
+ * </p>
+ *
+ * <h2>Encapsulation guarantees</h2>
+ * <p>
+ * The connection object object owns *all* of the SQLite related native
+ * objects that are associated with the connection.  What's more, there are
+ * no other objects in the system that are capable of obtaining handles to
+ * those native objects.  Consequently, when the connection is closed, we do
+ * not have to worry about what other components might have references to
+ * its associated SQLite state -- there are none.
+ * </p><p>
+ * Encapsulation is what ensures that the connection object's
+ * lifecycle does not become a tortured mess of finalizers and reference
+ * queues.
+ * </p>
+ *
+ * @hide
+ */
+public final class SQLiteConnection {
+    private static final String TAG = "SQLiteConnection";
+
+    private static final String[] EMPTY_STRING_ARRAY = new String[0];
+    private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
+
+    private static final Pattern TRIM_SQL_PATTERN = Pattern.compile("[\\s]*\\n+[\\s]*");
+
+    private final CloseGuard mCloseGuard = CloseGuard.get();
+
+    private final SQLiteConnectionPool mPool;
+    private final SQLiteDatabaseConfiguration mConfiguration;
+    private final int mConnectionId;
+    private final boolean mIsPrimaryConnection;
+    private final PreparedStatementCache mPreparedStatementCache;
+    private PreparedStatement mPreparedStatementPool;
+
+    // The recent operations log.
+    private final OperationLog mRecentOperations = new OperationLog();
+
+    // The native SQLiteConnection pointer.  (FOR INTERNAL USE ONLY)
+    private int mConnectionPtr;
+
+    private boolean mOnlyAllowReadOnlyOperations;
+
+    private static native int nativeOpen(String path, int openFlags, String label,
+            boolean enableTrace, boolean enableProfile);
+    private static native void nativeClose(int connectionPtr);
+    private static native void nativeRegisterCustomFunction(int connectionPtr,
+            SQLiteCustomFunction function);
+    private static native void nativeSetLocale(int connectionPtr, String locale);
+    private static native int nativePrepareStatement(int connectionPtr, String sql);
+    private static native void nativeFinalizeStatement(int connectionPtr, int statementPtr);
+    private static native int nativeGetParameterCount(int connectionPtr, int statementPtr);
+    private static native boolean nativeIsReadOnly(int connectionPtr, int statementPtr);
+    private static native int nativeGetColumnCount(int connectionPtr, int statementPtr);
+    private static native String nativeGetColumnName(int connectionPtr, int statementPtr,
+            int index);
+    private static native void nativeBindNull(int connectionPtr, int statementPtr,
+            int index);
+    private static native void nativeBindLong(int connectionPtr, int statementPtr,
+            int index, long value);
+    private static native void nativeBindDouble(int connectionPtr, int statementPtr,
+            int index, double value);
+    private static native void nativeBindString(int connectionPtr, int statementPtr,
+            int index, String value);
+    private static native void nativeBindBlob(int connectionPtr, int statementPtr,
+            int index, byte[] value);
+    private static native void nativeResetStatementAndClearBindings(
+            int connectionPtr, int statementPtr);
+    private static native void nativeExecute(int connectionPtr, int statementPtr);
+    private static native long nativeExecuteForLong(int connectionPtr, int statementPtr);
+    private static native String nativeExecuteForString(int connectionPtr, int statementPtr);
+    private static native int nativeExecuteForBlobFileDescriptor(
+            int connectionPtr, int statementPtr);
+    private static native int nativeExecuteForChangedRowCount(int connectionPtr, int statementPtr);
+    private static native long nativeExecuteForLastInsertedRowId(
+            int connectionPtr, int statementPtr);
+    private static native long nativeExecuteForCursorWindow(
+            int connectionPtr, int statementPtr, int windowPtr,
+            int startPos, int requiredPos, boolean countAllRows);
+    private static native int nativeGetDbLookaside(int connectionPtr);
+
+    private SQLiteConnection(SQLiteConnectionPool pool,
+            SQLiteDatabaseConfiguration configuration,
+            int connectionId, boolean primaryConnection) {
+        mPool = pool;
+        mConfiguration = new SQLiteDatabaseConfiguration(configuration);
+        mConnectionId = connectionId;
+        mIsPrimaryConnection = primaryConnection;
+        mPreparedStatementCache = new PreparedStatementCache(
+                mConfiguration.maxSqlCacheSize);
+        mCloseGuard.open("close");
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            if (mPool != null && mConnectionPtr != 0) {
+                mPool.onConnectionLeaked();
+            }
+
+            dispose(true);
+        } finally {
+            super.finalize();
+        }
+    }
+
+    // Called by SQLiteConnectionPool only.
+    static SQLiteConnection open(SQLiteConnectionPool pool,
+            SQLiteDatabaseConfiguration configuration,
+            int connectionId, boolean primaryConnection) {
+        SQLiteConnection connection = new SQLiteConnection(pool, configuration,
+                connectionId, primaryConnection);
+        try {
+            connection.open();
+            return connection;
+        } catch (SQLiteException ex) {
+            connection.dispose(false);
+            throw ex;
+        }
+    }
+
+    // Called by SQLiteConnectionPool only.
+    // Closes the database closes and releases all of its associated resources.
+    // Do not call methods on the connection after it is closed.  It will probably crash.
+    void close() {
+        dispose(false);
+    }
+
+    private void open() {
+        SQLiteGlobal.initializeOnce();
+
+        mConnectionPtr = nativeOpen(mConfiguration.path, mConfiguration.openFlags,
+                mConfiguration.label,
+                SQLiteDebug.DEBUG_SQL_STATEMENTS, SQLiteDebug.DEBUG_SQL_TIME);
+
+        setLocaleFromConfiguration();
+    }
+
+    private void dispose(boolean finalized) {
+        if (mCloseGuard != null) {
+            if (finalized) {
+                mCloseGuard.warnIfOpen();
+            }
+            mCloseGuard.close();
+        }
+
+        if (mConnectionPtr != 0) {
+            mRecentOperations.beginOperation("close", null, null);
+            try {
+                mPreparedStatementCache.evictAll();
+                nativeClose(mConnectionPtr);
+                mConnectionPtr = 0;
+            } finally {
+                mRecentOperations.endOperation();
+            }
+        }
+    }
+
+    private void setLocaleFromConfiguration() {
+        nativeSetLocale(mConnectionPtr, mConfiguration.locale.toString());
+    }
+
+    // Called by SQLiteConnectionPool only.
+    void reconfigure(SQLiteDatabaseConfiguration configuration) {
+        // Register custom functions.
+        final int functionCount = configuration.customFunctions.size();
+        for (int i = 0; i < functionCount; i++) {
+            SQLiteCustomFunction function = configuration.customFunctions.get(i);
+            if (!mConfiguration.customFunctions.contains(function)) {
+                nativeRegisterCustomFunction(mConnectionPtr, function);
+            }
+        }
+
+        // Remember whether locale has changed.
+        boolean localeChanged = !configuration.locale.equals(mConfiguration.locale);
+
+        // Update configuration parameters.
+        mConfiguration.updateParametersFrom(configuration);
+
+        // Update prepared statement cache size.
+        mPreparedStatementCache.resize(configuration.maxSqlCacheSize);
+
+        // Update locale.
+        if (localeChanged) {
+            setLocaleFromConfiguration();
+        }
+    }
+
+    // Called by SQLiteConnectionPool only.
+    // When set to true, executing write operations will throw SQLiteException.
+    // Preparing statements that might write is ok, just don't execute them.
+    void setOnlyAllowReadOnlyOperations(boolean readOnly) {
+        mOnlyAllowReadOnlyOperations = readOnly;
+    }
+
+    // Called by SQLiteConnectionPool only.
+    // Returns true if the prepared statement cache contains the specified SQL.
+    boolean isPreparedStatementInCache(String sql) {
+        return mPreparedStatementCache.get(sql) != null;
+    }
+
+    /**
+     * Gets the unique id of this connection.
+     * @return The connection id.
+     */
+    public int getConnectionId() {
+        return mConnectionId;
+    }
+
+    /**
+     * Returns true if this is the primary database connection.
+     * @return True if this is the primary database connection.
+     */
+    public boolean isPrimaryConnection() {
+        return mIsPrimaryConnection;
+    }
+
+    /**
+     * Prepares a statement for execution but does not bind its parameters or execute it.
+     * <p>
+     * This method can be used to check for syntax errors during compilation
+     * prior to execution of the statement.  If the {@code outStatementInfo} argument
+     * is not null, the provided {@link SQLiteStatementInfo} object is populated
+     * with information about the statement.
+     * </p><p>
+     * A prepared statement makes no reference to the arguments that may eventually
+     * be bound to it, consequently it it possible to cache certain prepared statements
+     * such as SELECT or INSERT/UPDATE statements.  If the statement is cacheable,
+     * then it will be stored in the cache for later.
+     * </p><p>
+     * To take advantage of this behavior as an optimization, the connection pool
+     * provides a method to acquire a connection that already has a given SQL statement
+     * in its prepared statement cache so that it is ready for execution.
+     * </p>
+     *
+     * @param sql The SQL statement to prepare.
+     * @param outStatementInfo The {@link SQLiteStatementInfo} object to populate
+     * with information about the statement, or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error.
+     */
+    public void prepare(String sql, SQLiteStatementInfo outStatementInfo) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("prepare", sql, null);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                if (outStatementInfo != null) {
+                    outStatementInfo.numParameters = statement.mNumParameters;
+                    outStatementInfo.readOnly = statement.mReadOnly;
+
+                    final int columnCount = nativeGetColumnCount(
+                            mConnectionPtr, statement.mStatementPtr);
+                    if (columnCount == 0) {
+                        outStatementInfo.columnNames = EMPTY_STRING_ARRAY;
+                    } else {
+                        outStatementInfo.columnNames = new String[columnCount];
+                        for (int i = 0; i < columnCount; i++) {
+                            outStatementInfo.columnNames[i] = nativeGetColumnName(
+                                    mConnectionPtr, statement.mStatementPtr, i);
+                        }
+                    }
+                }
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement that does not return a result.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public void execute(String sql, Object[] bindArgs) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("execute", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                nativeExecute(mConnectionPtr, statement.mStatementPtr);
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement that returns a single <code>long</code> result.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @return The value of the first column in the first row of the result set
+     * as a <code>long</code>, or zero if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public long executeForLong(String sql, Object[] bindArgs) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("executeForLong", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                return nativeExecuteForLong(mConnectionPtr, statement.mStatementPtr);
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement that returns a single {@link String} result.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @return The value of the first column in the first row of the result set
+     * as a <code>String</code>, or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public String executeForString(String sql, Object[] bindArgs) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("executeForString", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                return nativeExecuteForString(mConnectionPtr, statement.mStatementPtr);
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement that returns a single BLOB result as a
+     * file descriptor to a shared memory region.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @return The file descriptor for a shared memory region that contains
+     * the value of the first column in the first row of the result set as a BLOB,
+     * or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public ParcelFileDescriptor executeForBlobFileDescriptor(String sql, Object[] bindArgs) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("executeForBlobFileDescriptor", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                int fd = nativeExecuteForBlobFileDescriptor(
+                        mConnectionPtr, statement.mStatementPtr);
+                return fd >= 0 ? ParcelFileDescriptor.adoptFd(fd) : null;
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement that returns a count of the number of rows
+     * that were changed.  Use for UPDATE or DELETE SQL statements.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @return The number of rows that were changed.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public int executeForChangedRowCount(String sql, Object[] bindArgs) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("executeForChangedRowCount", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                return nativeExecuteForChangedRowCount(
+                        mConnectionPtr, statement.mStatementPtr);
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement that returns the row id of the last row inserted
+     * by the statement.  Use for INSERT SQL statements.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @return The row id of the last row that was inserted, or 0 if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public long executeForLastInsertedRowId(String sql, Object[] bindArgs) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        mRecentOperations.beginOperation("executeForLastInsertedRowId", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                return nativeExecuteForLastInsertedRowId(
+                        mConnectionPtr, statement.mStatementPtr);
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            mRecentOperations.endOperation();
+        }
+    }
+
+    /**
+     * Executes a statement and populates the specified {@link CursorWindow}
+     * with a range of results.  Returns the number of rows that were counted
+     * during query execution.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param window The cursor window to clear and fill.
+     * @param startPos The start position for filling the window.
+     * @param requiredPos The position of a row that MUST be in the window.
+     * If it won't fit, then the query should discard part of what it filled
+     * so that it does.  Must be greater than or equal to <code>startPos</code>.
+     * @param countAllRows True to count all rows that the query would return
+     * regagless of whether they fit in the window.
+     * @return The number of rows that were counted during query execution.  Might
+     * not be all rows in the result set unless <code>countAllRows</code> is true.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public int executeForCursorWindow(String sql, Object[] bindArgs,
+            CursorWindow window, int startPos, int requiredPos, boolean countAllRows) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+        if (window == null) {
+            throw new IllegalArgumentException("window must not be null.");
+        }
+
+        int actualPos = -1;
+        int countedRows = -1;
+        int filledRows = -1;
+        mRecentOperations.beginOperation("executeForCursorWindow", sql, bindArgs);
+        try {
+            PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                final long result = nativeExecuteForCursorWindow(
+                        mConnectionPtr, statement.mStatementPtr, window.mWindowPtr,
+                        startPos, requiredPos, countAllRows);
+                actualPos = (int)(result >> 32);
+                countedRows = (int)result;
+                filledRows = window.getNumRows();
+                window.setStartPosition(actualPos);
+                return countedRows;
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(ex);
+            throw ex;
+        } finally {
+            if (mRecentOperations.endOperationDeferLog()) {
+                mRecentOperations.logOperation("window='" + window
+                        + "', startPos=" + startPos
+                        + ", actualPos=" + actualPos
+                        + ", filledRows=" + filledRows
+                        + ", countedRows=" + countedRows);
+            }
+        }
+    }
+
+    private PreparedStatement acquirePreparedStatement(String sql) {
+        PreparedStatement statement = mPreparedStatementCache.get(sql);
+        if (statement != null) {
+            return statement;
+        }
+
+        final int statementPtr = nativePrepareStatement(mConnectionPtr, sql);
+        try {
+            final int numParameters = nativeGetParameterCount(mConnectionPtr, statementPtr);
+            final int type = DatabaseUtils.getSqlStatementType(sql);
+            final boolean readOnly = nativeIsReadOnly(mConnectionPtr, statementPtr);
+            statement = obtainPreparedStatement(sql, statementPtr, numParameters, type, readOnly);
+            if (isCacheable(type)) {
+                mPreparedStatementCache.put(sql, statement);
+                statement.mInCache = true;
+            }
+        } catch (RuntimeException ex) {
+            // Finalize the statement if an exception occurred and we did not add
+            // it to the cache.  If it is already in the cache, then leave it there.
+            if (statement == null || !statement.mInCache) {
+                nativeFinalizeStatement(mConnectionPtr, statementPtr);
+            }
+            throw ex;
+        }
+        return statement;
+    }
+
+    private void releasePreparedStatement(PreparedStatement statement) {
+        if (statement.mInCache) {
+            try {
+                nativeResetStatementAndClearBindings(mConnectionPtr, statement.mStatementPtr);
+            } catch (SQLiteException ex) {
+                // The statement could not be reset due to an error.
+                // The entryRemoved() callback for the cache will recursively call
+                // releasePreparedStatement() again, but this time mInCache will be false
+                // so the statement will be finalized and recycled.
+                if (SQLiteDebug.DEBUG_SQL_CACHE) {
+                    Log.v(TAG, "Could not reset prepared statement due to an exception.  "
+                            + "Removing it from the cache.  SQL: "
+                            + trimSqlForDisplay(statement.mSql), ex);
+                }
+                mPreparedStatementCache.remove(statement.mSql);
+            }
+        } else {
+            nativeFinalizeStatement(mConnectionPtr, statement.mStatementPtr);
+            recyclePreparedStatement(statement);
+        }
+    }
+
+    private void bindArguments(PreparedStatement statement, Object[] bindArgs) {
+        final int count = bindArgs != null ? bindArgs.length : 0;
+        if (count != statement.mNumParameters) {
+            throw new SQLiteBindOrColumnIndexOutOfRangeException(
+                    "Expected " + statement.mNumParameters + " bind arguments but "
+                    + bindArgs.length + " were provided.");
+        }
+        if (count == 0) {
+            return;
+        }
+
+        final int statementPtr = statement.mStatementPtr;
+        for (int i = 0; i < count; i++) {
+            final Object arg = bindArgs[i];
+            switch (DatabaseUtils.getTypeOfObject(arg)) {
+                case Cursor.FIELD_TYPE_NULL:
+                    nativeBindNull(mConnectionPtr, statementPtr, i + 1);
+                    break;
+                case Cursor.FIELD_TYPE_INTEGER:
+                    nativeBindLong(mConnectionPtr, statementPtr, i + 1,
+                            ((Number)arg).longValue());
+                    break;
+                case Cursor.FIELD_TYPE_FLOAT:
+                    nativeBindDouble(mConnectionPtr, statementPtr, i + 1,
+                            ((Number)arg).doubleValue());
+                    break;
+                case Cursor.FIELD_TYPE_BLOB:
+                    nativeBindBlob(mConnectionPtr, statementPtr, i + 1, (byte[])arg);
+                    break;
+                case Cursor.FIELD_TYPE_STRING:
+                default:
+                    if (arg instanceof Boolean) {
+                        // Provide compatibility with legacy applications which may pass
+                        // Boolean values in bind args.
+                        nativeBindLong(mConnectionPtr, statementPtr, i + 1,
+                                ((Boolean)arg).booleanValue() ? 1 : 0);
+                    } else {
+                        nativeBindString(mConnectionPtr, statementPtr, i + 1, arg.toString());
+                    }
+                    break;
+            }
+        }
+    }
+
+    private void throwIfStatementForbidden(PreparedStatement statement) {
+        if (mOnlyAllowReadOnlyOperations && !statement.mReadOnly) {
+            throw new SQLiteException("Cannot execute this statement because it "
+                    + "might modify the database but the connection is read-only.");
+        }
+    }
+
+    private static boolean isCacheable(int statementType) {
+        if (statementType == DatabaseUtils.STATEMENT_UPDATE
+                || statementType == DatabaseUtils.STATEMENT_SELECT) {
+            return true;
+        }
+        return false;
+    }
+
+    private void applyBlockGuardPolicy(PreparedStatement statement) {
+        if (!mConfiguration.isInMemoryDb()) {
+            if (statement.mReadOnly) {
+                BlockGuard.getThreadPolicy().onReadFromDisk();
+            } else {
+                BlockGuard.getThreadPolicy().onWriteToDisk();
+            }
+        }
+    }
+
+    /**
+     * Dumps debugging information about this connection.
+     *
+     * @param printer The printer to receive the dump, not null.
+     */
+    public void dump(Printer printer) {
+        dumpUnsafe(printer);
+    }
+
+    /**
+     * Dumps debugging information about this connection, in the case where the
+     * caller might not actually own the connection.
+     *
+     * This function is written so that it may be called by a thread that does not
+     * own the connection.  We need to be very careful because the connection state is
+     * not synchronized.
+     *
+     * At worst, the method may return stale or slightly wrong data, however
+     * it should not crash.  This is ok as it is only used for diagnostic purposes.
+     *
+     * @param printer The printer to receive the dump, not null.
+     */
+    void dumpUnsafe(Printer printer) {
+        printer.println("Connection #" + mConnectionId + ":");
+        printer.println("  isPrimaryConnection: " + mIsPrimaryConnection);
+        printer.println("  connectionPtr: 0x" + Integer.toHexString(mConnectionPtr));
+        printer.println("  onlyAllowReadOnlyOperations: " + mOnlyAllowReadOnlyOperations);
+
+        mRecentOperations.dump(printer);
+        mPreparedStatementCache.dump(printer);
+    }
+
+    /**
+     * Describes the currently executing operation, in the case where the
+     * caller might not actually own the connection.
+     *
+     * This function is written so that it may be called by a thread that does not
+     * own the connection.  We need to be very careful because the connection state is
+     * not synchronized.
+     *
+     * At worst, the method may return stale or slightly wrong data, however
+     * it should not crash.  This is ok as it is only used for diagnostic purposes.
+     *
+     * @return A description of the current operation including how long it has been running,
+     * or null if none.
+     */
+    String describeCurrentOperationUnsafe() {
+        return mRecentOperations.describeCurrentOperation();
+    }
+
+    /**
+     * Collects statistics about database connection memory usage.
+     *
+     * @param dbStatsList The list to populate.
+     */
+    void collectDbStats(ArrayList<DbStats> dbStatsList) {
+        // Get information about the main database.
+        int lookaside = nativeGetDbLookaside(mConnectionPtr);
+        long pageCount = 0;
+        long pageSize = 0;
+        try {
+            pageCount = executeForLong("PRAGMA page_count;", null);
+            pageSize = executeForLong("PRAGMA page_size;", null);
+        } catch (SQLiteException ex) {
+            // Ignore.
+        }
+        dbStatsList.add(getMainDbStatsUnsafe(lookaside, pageCount, pageSize));
+
+        // Get information about attached databases.
+        // We ignore the first row in the database list because it corresponds to
+        // the main database which we have already described.
+        CursorWindow window = new CursorWindow("collectDbStats");
+        try {
+            executeForCursorWindow("PRAGMA database_list;", null, window, 0, 0, false);
+            for (int i = 1; i < window.getNumRows(); i++) {
+                String name = window.getString(i, 1);
+                String path = window.getString(i, 2);
+                pageCount = 0;
+                pageSize = 0;
+                try {
+                    pageCount = executeForLong("PRAGMA " + name + ".page_count;", null);
+                    pageSize = executeForLong("PRAGMA " + name + ".page_size;", null);
+                } catch (SQLiteException ex) {
+                    // Ignore.
+                }
+                String label = "  (attached) " + name;
+                if (!path.isEmpty()) {
+                    label += ": " + path;
+                }
+                dbStatsList.add(new DbStats(label, pageCount, pageSize, 0, 0, 0, 0));
+            }
+        } catch (SQLiteException ex) {
+            // Ignore.
+        } finally {
+            window.close();
+        }
+    }
+
+    /**
+     * Collects statistics about database connection memory usage, in the case where the
+     * caller might not actually own the connection.
+     *
+     * @return The statistics object, never null.
+     */
+    void collectDbStatsUnsafe(ArrayList<DbStats> dbStatsList) {
+        dbStatsList.add(getMainDbStatsUnsafe(0, 0, 0));
+    }
+
+    private DbStats getMainDbStatsUnsafe(int lookaside, long pageCount, long pageSize) {
+        // The prepared statement cache is thread-safe so we can access its statistics
+        // even if we do not own the database connection.
+        String label = mConfiguration.path;
+        if (!mIsPrimaryConnection) {
+            label += " (" + mConnectionId + ")";
+        }
+        return new DbStats(label, pageCount, pageSize, lookaside,
+                mPreparedStatementCache.hitCount(),
+                mPreparedStatementCache.missCount(),
+                mPreparedStatementCache.size());
+    }
+
+    @Override
+    public String toString() {
+        return "SQLiteConnection: " + mConfiguration.path + " (" + mConnectionId + ")";
+    }
+
+    private PreparedStatement obtainPreparedStatement(String sql, int statementPtr,
+            int numParameters, int type, boolean readOnly) {
+        PreparedStatement statement = mPreparedStatementPool;
+        if (statement != null) {
+            mPreparedStatementPool = statement.mPoolNext;
+            statement.mPoolNext = null;
+            statement.mInCache = false;
+        } else {
+            statement = new PreparedStatement();
+        }
+        statement.mSql = sql;
+        statement.mStatementPtr = statementPtr;
+        statement.mNumParameters = numParameters;
+        statement.mType = type;
+        statement.mReadOnly = readOnly;
+        return statement;
+    }
+
+    private void recyclePreparedStatement(PreparedStatement statement) {
+        statement.mSql = null;
+        statement.mPoolNext = mPreparedStatementPool;
+        mPreparedStatementPool = statement;
+    }
+
+    private static String trimSqlForDisplay(String sql) {
+        return TRIM_SQL_PATTERN.matcher(sql).replaceAll(" ");
+    }
+
+    /**
+     * Holder type for a prepared statement.
+     *
+     * Although this object holds a pointer to a native statement object, it
+     * does not have a finalizer.  This is deliberate.  The {@link SQLiteConnection}
+     * owns the statement object and will take care of freeing it when needed.
+     * In particular, closing the connection requires a guarantee of deterministic
+     * resource disposal because all native statement objects must be freed before
+     * the native database object can be closed.  So no finalizers here.
+     */
+    private static final class PreparedStatement {
+        // Next item in pool.
+        public PreparedStatement mPoolNext;
+
+        // The SQL from which the statement was prepared.
+        public String mSql;
+
+        // The native sqlite3_stmt object pointer.
+        // Lifetime is managed explicitly by the connection.
+        public int mStatementPtr;
+
+        // The number of parameters that the prepared statement has.
+        public int mNumParameters;
+
+        // The statement type.
+        public int mType;
+
+        // True if the statement is read-only.
+        public boolean mReadOnly;
+
+        // True if the statement is in the cache.
+        public boolean mInCache;
+    }
+
+    private final class PreparedStatementCache
+            extends LruCache<String, PreparedStatement> {
+        public PreparedStatementCache(int size) {
+            super(size);
+        }
+
+        @Override
+        protected void entryRemoved(boolean evicted, String key,
+                PreparedStatement oldValue, PreparedStatement newValue) {
+            oldValue.mInCache = false;
+            releasePreparedStatement(oldValue);
+        }
+
+        public void dump(Printer printer) {
+            printer.println("  Prepared statement cache:");
+            Map<String, PreparedStatement> cache = snapshot();
+            if (!cache.isEmpty()) {
+                int i = 0;
+                for (Map.Entry<String, PreparedStatement> entry : cache.entrySet()) {
+                    PreparedStatement statement = entry.getValue();
+                    if (statement.mInCache) { // might be false due to a race with entryRemoved
+                        String sql = entry.getKey();
+                        printer.println("    " + i + ": statementPtr=0x"
+                                + Integer.toHexString(statement.mStatementPtr)
+                                + ", numParameters=" + statement.mNumParameters
+                                + ", type=" + statement.mType
+                                + ", readOnly=" + statement.mReadOnly
+                                + ", sql=\"" + trimSqlForDisplay(sql) + "\"");
+                    }
+                    i += 1;
+                }
+            } else {
+                printer.println("    <none>");
+            }
+        }
+    }
+
+    private static final class OperationLog {
+        private static final int MAX_RECENT_OPERATIONS = 10;
+
+        private final Operation[] mOperations = new Operation[MAX_RECENT_OPERATIONS];
+        private int mIndex;
+
+        public void beginOperation(String kind, String sql, Object[] bindArgs) {
+            synchronized (mOperations) {
+                final int index = (mIndex + 1) % MAX_RECENT_OPERATIONS;
+                Operation operation = mOperations[index];
+                if (operation == null) {
+                    operation = new Operation();
+                    mOperations[index] = operation;
+                } else {
+                    operation.mFinished = false;
+                    operation.mException = null;
+                    if (operation.mBindArgs != null) {
+                        operation.mBindArgs.clear();
+                    }
+                }
+                operation.mStartTime = System.currentTimeMillis();
+                operation.mKind = kind;
+                operation.mSql = sql;
+                if (bindArgs != null) {
+                    if (operation.mBindArgs == null) {
+                        operation.mBindArgs = new ArrayList<Object>();
+                    } else {
+                        operation.mBindArgs.clear();
+                    }
+                    for (int i = 0; i < bindArgs.length; i++) {
+                        final Object arg = bindArgs[i];
+                        if (arg != null && arg instanceof byte[]) {
+                            // Don't hold onto the real byte array longer than necessary.
+                            operation.mBindArgs.add(EMPTY_BYTE_ARRAY);
+                        } else {
+                            operation.mBindArgs.add(arg);
+                        }
+                    }
+                }
+                mIndex = index;
+            }
+        }
+
+        public void failOperation(Exception ex) {
+            synchronized (mOperations) {
+                final Operation operation =  mOperations[mIndex];
+                operation.mException = ex;
+            }
+        }
+
+        public boolean endOperationDeferLog() {
+            synchronized (mOperations) {
+                return endOperationDeferLogLocked();
+            }
+        }
+
+        private boolean endOperationDeferLogLocked() {
+            final Operation operation =  mOperations[mIndex];
+            operation.mEndTime = System.currentTimeMillis();
+            operation.mFinished = true;
+            return SQLiteDebug.DEBUG_LOG_SLOW_QUERIES && SQLiteDebug.shouldLogSlowQuery(
+                            operation.mEndTime - operation.mStartTime);
+        }
+
+        public void endOperation() {
+            synchronized (mOperations) {
+                if (endOperationDeferLogLocked()) {
+                    logOperationLocked(null);
+                }
+            }
+        }
+
+        public void logOperation(String detail) {
+            synchronized (mOperations) {
+                logOperationLocked(detail);
+            }
+        }
+
+        private void logOperationLocked(String detail) {
+            final Operation operation =  mOperations[mIndex];
+            StringBuilder msg = new StringBuilder();
+            operation.describe(msg);
+            if (detail != null) {
+                msg.append(", ").append(detail);
+            }
+            Log.d(TAG, msg.toString());
+        }
+
+        public String describeCurrentOperation() {
+            synchronized (mOperations) {
+                final Operation operation = mOperations[mIndex];
+                if (operation != null && !operation.mFinished) {
+                    StringBuilder msg = new StringBuilder();
+                    operation.describe(msg);
+                    return msg.toString();
+                }
+                return null;
+            }
+        }
+
+        public void dump(Printer printer) {
+            synchronized (mOperations) {
+                printer.println("  Most recently executed operations:");
+                int index = mIndex;
+                Operation operation = mOperations[index];
+                if (operation != null) {
+                    int n = 0;
+                    do {
+                        StringBuilder msg = new StringBuilder();
+                        msg.append("    ").append(n).append(": [");
+                        msg.append(operation.getFormattedStartTime());
+                        msg.append("] ");
+                        operation.describe(msg);
+                        printer.println(msg.toString());
+
+                        if (index > 0) {
+                            index -= 1;
+                        } else {
+                            index = MAX_RECENT_OPERATIONS - 1;
+                        }
+                        n += 1;
+                        operation = mOperations[index];
+                    } while (operation != null && n < MAX_RECENT_OPERATIONS);
+                } else {
+                    printer.println("    <none>");
+                }
+            }
+        }
+    }
+
+    private static final class Operation {
+        private static final SimpleDateFormat sDateFormat =
+                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+
+        public long mStartTime;
+        public long mEndTime;
+        public String mKind;
+        public String mSql;
+        public ArrayList<Object> mBindArgs;
+        public boolean mFinished;
+        public Exception mException;
+
+        public void describe(StringBuilder msg) {
+            msg.append(mKind);
+            if (mFinished) {
+                msg.append(" took ").append(mEndTime - mStartTime).append("ms");
+            } else {
+                msg.append(" started ").append(System.currentTimeMillis() - mStartTime)
+                        .append("ms ago");
+            }
+            msg.append(" - ").append(getStatus());
+            if (mSql != null) {
+                msg.append(", sql=\"").append(trimSqlForDisplay(mSql)).append("\"");
+            }
+            if (mBindArgs != null && mBindArgs.size() != 0) {
+                msg.append(", bindArgs=[");
+                final int count = mBindArgs.size();
+                for (int i = 0; i < count; i++) {
+                    final Object arg = mBindArgs.get(i);
+                    if (i != 0) {
+                        msg.append(", ");
+                    }
+                    if (arg == null) {
+                        msg.append("null");
+                    } else if (arg instanceof byte[]) {
+                        msg.append("<byte[]>");
+                    } else if (arg instanceof String) {
+                        msg.append("\"").append((String)arg).append("\"");
+                    } else {
+                        msg.append(arg);
+                    }
+                }
+                msg.append("]");
+            }
+            if (mException != null) {
+                msg.append(", exception=\"").append(mException.getMessage()).append("\"");
+            }
+        }
+
+        private String getStatus() {
+            if (!mFinished) {
+                return "running";
+            }
+            return mException != null ? "failed" : "succeeded";
+        }
+
+        private String getFormattedStartTime() {
+            return sDateFormat.format(new Date(mStartTime));
+        }
+    }
+}
diff --git a/core/java/android/database/sqlite/SQLiteConnectionPool.java b/core/java/android/database/sqlite/SQLiteConnectionPool.java
new file mode 100644
index 0000000..b88bfee
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteConnectionPool.java
@@ -0,0 +1,907 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+import dalvik.system.CloseGuard;
+
+import android.database.sqlite.SQLiteDebug.DbStats;
+import android.os.SystemClock;
+import android.util.Log;
+import android.util.PrefixPrinter;
+import android.util.Printer;
+
+import java.io.Closeable;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.LockSupport;
+
+/**
+ * Maintains a pool of active SQLite database connections.
+ * <p>
+ * At any given time, a connection is either owned by the pool, or it has been
+ * acquired by a {@link SQLiteSession}.  When the {@link SQLiteSession} is
+ * finished with the connection it is using, it must return the connection
+ * back to the pool.
+ * </p><p>
+ * The pool holds strong references to the connections it owns.  However,
+ * it only holds <em>weak references</em> to the connections that sessions
+ * have acquired from it.  Using weak references in the latter case ensures
+ * that the connection pool can detect when connections have been improperly
+ * abandoned so that it can create new connections to replace them if needed.
+ * </p><p>
+ * The connection pool is thread-safe (but the connections themselves are not).
+ * </p>
+ *
+ * <h2>Exception safety</h2>
+ * <p>
+ * This code attempts to maintain the invariant that opened connections are
+ * always owned.  Unfortunately that means it needs to handle exceptions
+ * all over to ensure that broken connections get cleaned up.  Most
+ * operations invokving SQLite can throw {@link SQLiteException} or other
+ * runtime exceptions.  This is a bit of a pain to deal with because the compiler
+ * cannot help us catch missing exception handling code.
+ * </p><p>
+ * The general rule for this file: If we are making calls out to
+ * {@link SQLiteConnection} then we must be prepared to handle any
+ * runtime exceptions it might throw at us.  Note that out-of-memory
+ * is an {@link Error}, not a {@link RuntimeException}.  We don't trouble ourselves
+ * handling out of memory because it is hard to do anything at all sensible then
+ * and most likely the VM is about to crash.
+ * </p>
+ *
+ * @hide
+ */
+public final class SQLiteConnectionPool implements Closeable {
+    private static final String TAG = "SQLiteConnectionPool";
+
+    // Amount of time to wait in milliseconds before unblocking acquireConnection
+    // and logging a message about the connection pool being busy.
+    private static final long CONNECTION_POOL_BUSY_MILLIS = 30 * 1000; // 30 seconds
+
+    private final CloseGuard mCloseGuard = CloseGuard.get();
+
+    private final Object mLock = new Object();
+    private final AtomicBoolean mConnectionLeaked = new AtomicBoolean();
+    private final SQLiteDatabaseConfiguration mConfiguration;
+    private boolean mIsOpen;
+    private int mNextConnectionId;
+
+    private ConnectionWaiter mConnectionWaiterPool;
+    private ConnectionWaiter mConnectionWaiterQueue;
+
+    // Strong references to all available connections.
+    private final ArrayList<SQLiteConnection> mAvailableNonPrimaryConnections =
+            new ArrayList<SQLiteConnection>();
+    private SQLiteConnection mAvailablePrimaryConnection;
+
+    // Weak references to all acquired connections.  The associated value
+    // is a boolean that indicates whether the connection must be reconfigured
+    // before being returned to the available connection list.
+    // For example, the prepared statement cache size may have changed and
+    // need to be updated.
+    private final WeakHashMap<SQLiteConnection, Boolean> mAcquiredConnections =
+            new WeakHashMap<SQLiteConnection, Boolean>();
+
+    /**
+     * Connection flag: Read-only.
+     * <p>
+     * This flag indicates that the connection will only be used to
+     * perform read-only operations.
+     * </p>
+     */
+    public static final int CONNECTION_FLAG_READ_ONLY = 1 << 0;
+
+    /**
+     * Connection flag: Primary connection affinity.
+     * <p>
+     * This flag indicates that the primary connection is required.
+     * This flag helps support legacy applications that expect most data modifying
+     * operations to be serialized by locking the primary database connection.
+     * Setting this flag essentially implements the old "db lock" concept by preventing
+     * an operation from being performed until it can obtain exclusive access to
+     * the primary connection.
+     * </p>
+     */
+    public static final int CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY = 1 << 1;
+
+    /**
+     * Connection flag: Connection is being used interactively.
+     * <p>
+     * This flag indicates that the connection is needed by the UI thread.
+     * The connection pool can use this flag to elevate the priority
+     * of the database connection request.
+     * </p>
+     */
+    public static final int CONNECTION_FLAG_INTERACTIVE = 1 << 2;
+
+    private SQLiteConnectionPool(SQLiteDatabaseConfiguration configuration) {
+        mConfiguration = new SQLiteDatabaseConfiguration(configuration);
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            dispose(true);
+        } finally {
+            super.finalize();
+        }
+    }
+
+    /**
+     * Opens a connection pool for the specified database.
+     *
+     * @param configuration The database configuration.
+     * @return The connection pool.
+     *
+     * @throws SQLiteException if a database error occurs.
+     */
+    public static SQLiteConnectionPool open(SQLiteDatabaseConfiguration configuration) {
+        if (configuration == null) {
+            throw new IllegalArgumentException("configuration must not be null.");
+        }
+
+        // Create the pool.
+        SQLiteConnectionPool pool = new SQLiteConnectionPool(configuration);
+        pool.open(); // might throw
+        return pool;
+    }
+
+    // Might throw
+    private void open() {
+        // Open the primary connection.
+        // This might throw if the database is corrupt.
+        mAvailablePrimaryConnection = openConnectionLocked(
+                true /*primaryConnection*/); // might throw
+
+        // Mark the pool as being open for business.
+        mIsOpen = true;
+        mCloseGuard.open("close");
+    }
+
+    /**
+     * Closes the connection pool.
+     * <p>
+     * When the connection pool is closed, it will refuse all further requests
+     * to acquire connections.  All connections that are currently available in
+     * the pool are closed immediately.  Any connections that are still in use
+     * will be closed as soon as they are returned to the pool.
+     * </p>
+     *
+     * @throws IllegalStateException if the pool has been closed.
+     */
+    public void close() {
+        dispose(false);
+    }
+
+    private void dispose(boolean finalized) {
+        if (mCloseGuard != null) {
+            if (finalized) {
+                mCloseGuard.warnIfOpen();
+            }
+            mCloseGuard.close();
+        }
+
+        if (!finalized) {
+            // Close all connections.  We don't need (or want) to do this
+            // when finalized because we don't know what state the connections
+            // themselves will be in.  The finalizer is really just here for CloseGuard.
+            // The connections will take care of themselves when their own finalizers run.
+            synchronized (mLock) {
+                throwIfClosedLocked();
+
+                mIsOpen = false;
+
+                final int count = mAvailableNonPrimaryConnections.size();
+                for (int i = 0; i < count; i++) {
+                    closeConnectionAndLogExceptionsLocked(mAvailableNonPrimaryConnections.get(i));
+                }
+                mAvailableNonPrimaryConnections.clear();
+
+                if (mAvailablePrimaryConnection != null) {
+                    closeConnectionAndLogExceptionsLocked(mAvailablePrimaryConnection);
+                    mAvailablePrimaryConnection = null;
+                }
+
+                final int pendingCount = mAcquiredConnections.size();
+                if (pendingCount != 0) {
+                    Log.i(TAG, "The connection pool for " + mConfiguration.label
+                            + " has been closed but there are still "
+                            + pendingCount + " connections in use.  They will be closed "
+                            + "as they are released back to the pool.");
+                }
+
+                wakeConnectionWaitersLocked();
+            }
+        }
+    }
+
+    /**
+     * Reconfigures the database configuration of the connection pool and all of its
+     * connections.
+     * <p>
+     * Configuration changes are propagated down to connections immediately if
+     * they are available or as soon as they are released.  This includes changes
+     * that affect the size of the pool.
+     * </p>
+     *
+     * @param configuration The new configuration.
+     *
+     * @throws IllegalStateException if the pool has been closed.
+     */
+    public void reconfigure(SQLiteDatabaseConfiguration configuration) {
+        if (configuration == null) {
+            throw new IllegalArgumentException("configuration must not be null.");
+        }
+
+        synchronized (mLock) {
+            throwIfClosedLocked();
+
+            final boolean poolSizeChanged = mConfiguration.maxConnectionPoolSize
+                    != configuration.maxConnectionPoolSize;
+            mConfiguration.updateParametersFrom(configuration);
+
+            if (poolSizeChanged) {
+                int availableCount = mAvailableNonPrimaryConnections.size();
+                while (availableCount-- > mConfiguration.maxConnectionPoolSize - 1) {
+                    SQLiteConnection connection =
+                            mAvailableNonPrimaryConnections.remove(availableCount);
+                    closeConnectionAndLogExceptionsLocked(connection);
+                }
+            }
+
+            reconfigureAllConnectionsLocked();
+
+            wakeConnectionWaitersLocked();
+        }
+    }
+
+    /**
+     * Acquires a connection from the pool.
+     * <p>
+     * The caller must call {@link #releaseConnection} to release the connection
+     * back to the pool when it is finished.  Failure to do so will result
+     * in much unpleasantness.
+     * </p>
+     *
+     * @param sql If not null, try to find a connection that already has
+     * the specified SQL statement in its prepared statement cache.
+     * @param connectionFlags The connection request flags.
+     * @return The connection that was acquired, never null.
+     *
+     * @throws IllegalStateException if the pool has been closed.
+     * @throws SQLiteException if a database error occurs.
+     */
+    public SQLiteConnection acquireConnection(String sql, int connectionFlags) {
+        return waitForConnection(sql, connectionFlags);
+    }
+
+    /**
+     * Releases a connection back to the pool.
+     * <p>
+     * It is ok to call this method after the pool has closed, to release
+     * connections that were still in use at the time of closure.
+     * </p>
+     *
+     * @param connection The connection to release.  Must not be null.
+     *
+     * @throws IllegalStateException if the connection was not acquired
+     * from this pool or if it has already been released.
+     */
+    public void releaseConnection(SQLiteConnection connection) {
+        synchronized (mLock) {
+            Boolean mustReconfigure = mAcquiredConnections.remove(connection);
+            if (mustReconfigure == null) {
+                throw new IllegalStateException("Cannot perform this operation "
+                        + "because the specified connection was not acquired "
+                        + "from this pool or has already been released.");
+            }
+
+            if (!mIsOpen) {
+                closeConnectionAndLogExceptionsLocked(connection);
+            } else if (connection.isPrimaryConnection()) {
+                assert mAvailablePrimaryConnection == null;
+                try {
+                    if (mustReconfigure == Boolean.TRUE) {
+                        connection.reconfigure(mConfiguration); // might throw
+                    }
+                } catch (RuntimeException ex) {
+                    Log.e(TAG, "Failed to reconfigure released primary connection, closing it: "
+                            + connection, ex);
+                    closeConnectionAndLogExceptionsLocked(connection);
+                    connection = null;
+                }
+                if (connection != null) {
+                    mAvailablePrimaryConnection = connection;
+                }
+                wakeConnectionWaitersLocked();
+            } else if (mAvailableNonPrimaryConnections.size() >=
+                    mConfiguration.maxConnectionPoolSize - 1) {
+                closeConnectionAndLogExceptionsLocked(connection);
+            } else {
+                try {
+                    if (mustReconfigure == Boolean.TRUE) {
+                        connection.reconfigure(mConfiguration); // might throw
+                    }
+                } catch (RuntimeException ex) {
+                    Log.e(TAG, "Failed to reconfigure released non-primary connection, "
+                            + "closing it: " + connection, ex);
+                    closeConnectionAndLogExceptionsLocked(connection);
+                    connection = null;
+                }
+                if (connection != null) {
+                    mAvailableNonPrimaryConnections.add(connection);
+                }
+                wakeConnectionWaitersLocked();
+            }
+        }
+    }
+
+    /**
+     * Returns true if the session should yield the connection due to
+     * contention over available database connections.
+     *
+     * @param connection The connection owned by the session.
+     * @param connectionFlags The connection request flags.
+     * @return True if the session should yield its connection.
+     *
+     * @throws IllegalStateException if the connection was not acquired
+     * from this pool or if it has already been released.
+     */
+    public boolean shouldYieldConnection(SQLiteConnection connection, int connectionFlags) {
+        synchronized (mLock) {
+            if (!mAcquiredConnections.containsKey(connection)) {
+                throw new IllegalStateException("Cannot perform this operation "
+                        + "because the specified connection was not acquired "
+                        + "from this pool or has already been released.");
+            }
+
+            if (!mIsOpen) {
+                return false;
+            }
+
+            return isSessionBlockingImportantConnectionWaitersLocked(
+                    connection.isPrimaryConnection(), connectionFlags);
+        }
+    }
+
+    /**
+     * Collects statistics about database connection memory usage.
+     *
+     * @param dbStatsList The list to populate.
+     */
+    public void collectDbStats(ArrayList<DbStats> dbStatsList) {
+        synchronized (mLock) {
+            if (mAvailablePrimaryConnection != null) {
+                mAvailablePrimaryConnection.collectDbStats(dbStatsList);
+            }
+
+            for (SQLiteConnection connection : mAvailableNonPrimaryConnections) {
+                connection.collectDbStats(dbStatsList);
+            }
+
+            for (SQLiteConnection connection : mAcquiredConnections.keySet()) {
+                connection.collectDbStatsUnsafe(dbStatsList);
+            }
+        }
+    }
+
+    // Might throw.
+    private SQLiteConnection openConnectionLocked(boolean primaryConnection) {
+        final int connectionId = mNextConnectionId++;
+        return SQLiteConnection.open(this, mConfiguration,
+                connectionId, primaryConnection); // might throw
+    }
+
+    void onConnectionLeaked() {
+        // This code is running inside of the SQLiteConnection finalizer.
+        //
+        // We don't know whether it is just the connection that has been finalized (and leaked)
+        // or whether the connection pool has also been or is about to be finalized.
+        // Consequently, it would be a bad idea to try to grab any locks or to
+        // do any significant work here.  So we do the simplest possible thing and
+        // set a flag.  waitForConnection() periodically checks this flag (when it
+        // times out) so that it can recover from leaked connections and wake
+        // itself or other threads up if necessary.
+        //
+        // You might still wonder why we don't try to do more to wake up the waiters
+        // immediately.  First, as explained above, it would be hard to do safely
+        // unless we started an extra Thread to function as a reference queue.  Second,
+        // this is never supposed to happen in normal operation.  Third, there is no
+        // guarantee that the GC will actually detect the leak in a timely manner so
+        // it's not all that important that we recover from the leak in a timely manner
+        // either.  Fourth, if a badly behaved application finds itself hung waiting for
+        // several seconds while waiting for a leaked connection to be detected and recreated,
+        // then perhaps its authors will have added incentive to fix the problem!
+
+        Log.w(TAG, "A SQLiteConnection object for database '"
+                + mConfiguration.label + "' was leaked!  Please fix your application "
+                + "to end transactions in progress properly and to close the database "
+                + "when it is no longer needed.");
+
+        mConnectionLeaked.set(true);
+    }
+
+    // Can't throw.
+    private void closeConnectionAndLogExceptionsLocked(SQLiteConnection connection) {
+        try {
+            connection.close(); // might throw
+        } catch (RuntimeException ex) {
+            Log.e(TAG, "Failed to close connection, its fate is now in the hands "
+                    + "of the merciful GC: " + connection, ex);
+        }
+    }
+
+    // Can't throw.
+    private void reconfigureAllConnectionsLocked() {
+        boolean wake = false;
+        if (mAvailablePrimaryConnection != null) {
+            try {
+                mAvailablePrimaryConnection.reconfigure(mConfiguration); // might throw
+            } catch (RuntimeException ex) {
+                Log.e(TAG, "Failed to reconfigure available primary connection, closing it: "
+                        + mAvailablePrimaryConnection, ex);
+                closeConnectionAndLogExceptionsLocked(mAvailablePrimaryConnection);
+                mAvailablePrimaryConnection = null;
+                wake = true;
+            }
+        }
+
+        int count = mAvailableNonPrimaryConnections.size();
+        for (int i = 0; i < count; i++) {
+            final SQLiteConnection connection = mAvailableNonPrimaryConnections.get(i);
+            try {
+                connection.reconfigure(mConfiguration); // might throw
+            } catch (RuntimeException ex) {
+                Log.e(TAG, "Failed to reconfigure available non-primary connection, closing it: "
+                        + connection, ex);
+                closeConnectionAndLogExceptionsLocked(connection);
+                mAvailableNonPrimaryConnections.remove(i--);
+                count -= 1;
+                wake = true;
+            }
+        }
+
+        if (!mAcquiredConnections.isEmpty()) {
+            ArrayList<SQLiteConnection> keysToUpdate = new ArrayList<SQLiteConnection>(
+                    mAcquiredConnections.size());
+            for (Map.Entry<SQLiteConnection, Boolean> entry : mAcquiredConnections.entrySet()) {
+                if (entry.getValue() != Boolean.TRUE) {
+                    keysToUpdate.add(entry.getKey());
+                }
+            }
+            final int updateCount = keysToUpdate.size();
+            for (int i = 0; i < updateCount; i++) {
+                mAcquiredConnections.put(keysToUpdate.get(i), Boolean.TRUE);
+            }
+        }
+
+        if (wake) {
+            wakeConnectionWaitersLocked();
+        }
+    }
+
+    // Might throw.
+    private SQLiteConnection waitForConnection(String sql, int connectionFlags) {
+        final boolean wantPrimaryConnection =
+                (connectionFlags & CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY) != 0;
+
+        final ConnectionWaiter waiter;
+        synchronized (mLock) {
+            throwIfClosedLocked();
+
+            // Try to acquire a connection.
+            SQLiteConnection connection = null;
+            if (!wantPrimaryConnection) {
+                connection = tryAcquireNonPrimaryConnectionLocked(
+                        sql, connectionFlags); // might throw
+            }
+            if (connection == null) {
+                connection = tryAcquirePrimaryConnectionLocked(connectionFlags); // might throw
+            }
+            if (connection != null) {
+                return connection;
+            }
+
+            // No connections available.  Enqueue a waiter in priority order.
+            final int priority = getPriority(connectionFlags);
+            final long startTime = SystemClock.uptimeMillis();
+            waiter = obtainConnectionWaiterLocked(Thread.currentThread(), startTime,
+                    priority, wantPrimaryConnection, sql, connectionFlags);
+            ConnectionWaiter predecessor = null;
+            ConnectionWaiter successor = mConnectionWaiterQueue;
+            while (successor != null) {
+                if (priority > successor.mPriority) {
+                    waiter.mNext = successor;
+                    break;
+                }
+                predecessor = successor;
+                successor = successor.mNext;
+            }
+            if (predecessor != null) {
+                predecessor.mNext = waiter;
+            } else {
+                mConnectionWaiterQueue = waiter;
+            }
+        }
+
+        // Park the thread until a connection is assigned or the pool is closed.
+        // Rethrow an exception from the wait, if we got one.
+        long busyTimeoutMillis = CONNECTION_POOL_BUSY_MILLIS;
+        long nextBusyTimeoutTime = waiter.mStartTime + busyTimeoutMillis;
+        for (;;) {
+            // Detect and recover from connection leaks.
+            if (mConnectionLeaked.compareAndSet(true, false)) {
+                wakeConnectionWaitersLocked();
+            }
+
+            // Wait to be unparked (may already have happened), a timeout, or interruption.
+            LockSupport.parkNanos(this, busyTimeoutMillis * 1000000L);
+
+            // Clear the interrupted flag, just in case.
+            Thread.interrupted();
+
+            // Check whether we are done waiting yet.
+            synchronized (mLock) {
+                throwIfClosedLocked();
+
+                SQLiteConnection connection = waiter.mAssignedConnection;
+                if (connection != null) {
+                    recycleConnectionWaiterLocked(waiter);
+                    return connection;
+                }
+
+                RuntimeException ex = waiter.mException;
+                if (ex != null) {
+                    recycleConnectionWaiterLocked(waiter);
+                    throw ex; // rethrow!
+                }
+
+                final long now = SystemClock.uptimeMillis();
+                if (now < nextBusyTimeoutTime) {
+                    busyTimeoutMillis = now - nextBusyTimeoutTime;
+                } else {
+                    logConnectionPoolBusyLocked(now - waiter.mStartTime, connectionFlags);
+                    busyTimeoutMillis = CONNECTION_POOL_BUSY_MILLIS;
+                    nextBusyTimeoutTime = now + busyTimeoutMillis;
+                }
+            }
+        }
+    }
+
+    // Can't throw.
+    private void logConnectionPoolBusyLocked(long waitMillis, int connectionFlags) {
+        final Thread thread = Thread.currentThread();
+        StringBuilder msg = new StringBuilder();
+        msg.append("The connection pool for database '").append(mConfiguration.label);
+        msg.append("' has been unable to grant a connection to thread ");
+        msg.append(thread.getId()).append(" (").append(thread.getName()).append(") ");
+        msg.append("with flags 0x").append(Integer.toHexString(connectionFlags));
+        msg.append(" for ").append(waitMillis * 0.001f).append(" seconds.\n");
+
+        ArrayList<String> requests = new ArrayList<String>();
+        int activeConnections = 0;
+        int idleConnections = 0;
+        if (!mAcquiredConnections.isEmpty()) {
+            for (Map.Entry<SQLiteConnection, Boolean> entry : mAcquiredConnections.entrySet()) {
+                final SQLiteConnection connection = entry.getKey();
+                String description = connection.describeCurrentOperationUnsafe();
+                if (description != null) {
+                    requests.add(description);
+                    activeConnections += 1;
+                } else {
+                    idleConnections += 1;
+                }
+            }
+        }
+        int availableConnections = mAvailableNonPrimaryConnections.size();
+        if (mAvailablePrimaryConnection != null) {
+            availableConnections += 1;
+        }
+
+        msg.append("Connections: ").append(activeConnections).append(" active, ");
+        msg.append(idleConnections).append(" idle, ");
+        msg.append(availableConnections).append(" available.\n");
+
+        if (!requests.isEmpty()) {
+            msg.append("\nRequests in progress:\n");
+            for (String request : requests) {
+                msg.append("  ").append(request).append("\n");
+            }
+        }
+
+        Log.w(TAG, msg.toString());
+    }
+
+    // Can't throw.
+    private void wakeConnectionWaitersLocked() {
+        // Unpark all waiters that have requests that we can fulfill.
+        // This method is designed to not throw runtime exceptions, although we might send
+        // a waiter an exception for it to rethrow.
+        ConnectionWaiter predecessor = null;
+        ConnectionWaiter waiter = mConnectionWaiterQueue;
+        boolean primaryConnectionNotAvailable = false;
+        boolean nonPrimaryConnectionNotAvailable = false;
+        while (waiter != null) {
+            boolean unpark = false;
+            if (!mIsOpen) {
+                unpark = true;
+            } else {
+                try {
+                    SQLiteConnection connection = null;
+                    if (!waiter.mWantPrimaryConnection && !nonPrimaryConnectionNotAvailable) {
+                        connection = tryAcquireNonPrimaryConnectionLocked(
+                                waiter.mSql, waiter.mConnectionFlags); // might throw
+                        if (connection == null) {
+                            nonPrimaryConnectionNotAvailable = true;
+                        }
+                    }
+                    if (connection == null && !primaryConnectionNotAvailable) {
+                        connection = tryAcquirePrimaryConnectionLocked(
+                                waiter.mConnectionFlags); // might throw
+                        if (connection == null) {
+                            primaryConnectionNotAvailable = true;
+                        }
+                    }
+                    if (connection != null) {
+                        waiter.mAssignedConnection = connection;
+                        unpark = true;
+                    } else if (nonPrimaryConnectionNotAvailable && primaryConnectionNotAvailable) {
+                        // There are no connections available and the pool is still open.
+                        // We cannot fulfill any more connection requests, so stop here.
+                        break;
+                    }
+                } catch (RuntimeException ex) {
+                    // Let the waiter handle the exception from acquiring a connection.
+                    waiter.mException = ex;
+                    unpark = true;
+                }
+            }
+
+            final ConnectionWaiter successor = waiter.mNext;
+            if (unpark) {
+                if (predecessor != null) {
+                    predecessor.mNext = successor;
+                } else {
+                    mConnectionWaiterQueue = successor;
+                }
+                waiter.mNext = null;
+
+                LockSupport.unpark(waiter.mThread);
+            } else {
+                predecessor = waiter;
+            }
+            waiter = successor;
+        }
+    }
+
+    // Might throw.
+    private SQLiteConnection tryAcquirePrimaryConnectionLocked(int connectionFlags) {
+        // If the primary connection is available, acquire it now.
+        SQLiteConnection connection = mAvailablePrimaryConnection;
+        if (connection != null) {
+            mAvailablePrimaryConnection = null;
+            finishAcquireConnectionLocked(connection, connectionFlags); // might throw
+            return connection;
+        }
+
+        // Make sure that the primary connection actually exists and has just been acquired.
+        for (SQLiteConnection acquiredConnection : mAcquiredConnections.keySet()) {
+            if (acquiredConnection.isPrimaryConnection()) {
+                return null;
+            }
+        }
+
+        // Uhoh.  No primary connection!  Either this is the first time we asked
+        // for it, or maybe it leaked?
+        connection = openConnectionLocked(true /*primaryConnection*/); // might throw
+        finishAcquireConnectionLocked(connection, connectionFlags); // might throw
+        return connection;
+    }
+
+    // Might throw.
+    private SQLiteConnection tryAcquireNonPrimaryConnectionLocked(
+            String sql, int connectionFlags) {
+        // Try to acquire the next connection in the queue.
+        SQLiteConnection connection;
+        final int availableCount = mAvailableNonPrimaryConnections.size();
+        if (availableCount > 1 && sql != null) {
+            // If we have a choice, then prefer a connection that has the
+            // prepared statement in its cache.
+            for (int i = 0; i < availableCount; i++) {
+                connection = mAvailableNonPrimaryConnections.get(i);
+                if (connection.isPreparedStatementInCache(sql)) {
+                    mAvailableNonPrimaryConnections.remove(i);
+                    finishAcquireConnectionLocked(connection, connectionFlags); // might throw
+                    return connection;
+                }
+            }
+        }
+        if (availableCount > 0) {
+            // Otherwise, just grab the next one.
+            connection = mAvailableNonPrimaryConnections.remove(availableCount - 1);
+            finishAcquireConnectionLocked(connection, connectionFlags); // might throw
+            return connection;
+        }
+
+        // Expand the pool if needed.
+        int openConnections = mAcquiredConnections.size();
+        if (mAvailablePrimaryConnection != null) {
+            openConnections += 1;
+        }
+        if (openConnections >= mConfiguration.maxConnectionPoolSize) {
+            return null;
+        }
+        connection = openConnectionLocked(false /*primaryConnection*/); // might throw
+        finishAcquireConnectionLocked(connection, connectionFlags); // might throw
+        return connection;
+    }
+
+    // Might throw.
+    private void finishAcquireConnectionLocked(SQLiteConnection connection, int connectionFlags) {
+        try {
+            final boolean readOnly = (connectionFlags & CONNECTION_FLAG_READ_ONLY) != 0;
+            connection.setOnlyAllowReadOnlyOperations(readOnly);
+
+            mAcquiredConnections.put(connection, Boolean.FALSE);
+        } catch (RuntimeException ex) {
+            Log.e(TAG, "Failed to prepare acquired connection for session, closing it: "
+                    + connection +", connectionFlags=" + connectionFlags);
+            closeConnectionAndLogExceptionsLocked(connection);
+            throw ex; // rethrow!
+        }
+    }
+
+    private boolean isSessionBlockingImportantConnectionWaitersLocked(
+            boolean holdingPrimaryConnection, int connectionFlags) {
+        ConnectionWaiter waiter = mConnectionWaiterQueue;
+        if (waiter != null) {
+            final int priority = getPriority(connectionFlags);
+            do {
+                // Only worry about blocked connections that have same or lower priority.
+                if (priority > waiter.mPriority) {
+                    break;
+                }
+
+                // If we are holding the primary connection then we are blocking the waiter.
+                // Likewise, if we are holding a non-primary connection and the waiter
+                // would accept a non-primary connection, then we are blocking the waier.
+                if (holdingPrimaryConnection || !waiter.mWantPrimaryConnection) {
+                    return true;
+                }
+
+                waiter = waiter.mNext;
+            } while (waiter != null);
+        }
+        return false;
+    }
+
+    private static int getPriority(int connectionFlags) {
+        return (connectionFlags & CONNECTION_FLAG_INTERACTIVE) != 0 ? 1 : 0;
+    }
+
+    private void throwIfClosedLocked() {
+        if (!mIsOpen) {
+            throw new IllegalStateException("Cannot perform this operation "
+                    + "because the connection pool have been closed.");
+        }
+    }
+
+    private ConnectionWaiter obtainConnectionWaiterLocked(Thread thread, long startTime,
+            int priority, boolean wantPrimaryConnection, String sql, int connectionFlags) {
+        ConnectionWaiter waiter = mConnectionWaiterPool;
+        if (waiter != null) {
+            mConnectionWaiterPool = waiter.mNext;
+            waiter.mNext = null;
+        } else {
+            waiter = new ConnectionWaiter();
+        }
+        waiter.mThread = thread;
+        waiter.mStartTime = startTime;
+        waiter.mPriority = priority;
+        waiter.mWantPrimaryConnection = wantPrimaryConnection;
+        waiter.mSql = sql;
+        waiter.mConnectionFlags = connectionFlags;
+        return waiter;
+    }
+
+    private void recycleConnectionWaiterLocked(ConnectionWaiter waiter) {
+        waiter.mNext = mConnectionWaiterPool;
+        waiter.mThread = null;
+        waiter.mSql = null;
+        waiter.mAssignedConnection = null;
+        waiter.mException = null;
+        mConnectionWaiterPool = waiter;
+    }
+
+    /**
+     * Dumps debugging information about this connection pool.
+     *
+     * @param printer The printer to receive the dump, not null.
+     */
+    public void dump(Printer printer) {
+        Printer indentedPrinter = PrefixPrinter.create(printer, "    ");
+        synchronized (mLock) {
+            printer.println("Connection pool for " + mConfiguration.path + ":");
+            printer.println("  Open: " + mIsOpen);
+            printer.println("  Max connections: " + mConfiguration.maxConnectionPoolSize);
+
+            printer.println("  Available primary connection:");
+            if (mAvailablePrimaryConnection != null) {
+                mAvailablePrimaryConnection.dump(indentedPrinter);
+            } else {
+                indentedPrinter.println("<none>");
+            }
+
+            printer.println("  Available non-primary connections:");
+            if (!mAvailableNonPrimaryConnections.isEmpty()) {
+                final int count = mAvailableNonPrimaryConnections.size();
+                for (int i = 0; i < count; i++) {
+                    mAvailableNonPrimaryConnections.get(i).dump(indentedPrinter);
+                }
+            } else {
+                indentedPrinter.println("<none>");
+            }
+
+            printer.println("  Acquired connections:");
+            if (!mAcquiredConnections.isEmpty()) {
+                for (Map.Entry<SQLiteConnection, Boolean> entry :
+                        mAcquiredConnections.entrySet()) {
+                    final SQLiteConnection connection = entry.getKey();
+                    connection.dumpUnsafe(indentedPrinter);
+                    indentedPrinter.println("  Pending reconfiguration: " + entry.getValue());
+                }
+            } else {
+                indentedPrinter.println("<none>");
+            }
+
+            printer.println("  Connection waiters:");
+            if (mConnectionWaiterQueue != null) {
+                int i = 0;
+                final long now = SystemClock.uptimeMillis();
+                for (ConnectionWaiter waiter = mConnectionWaiterQueue; waiter != null;
+                        waiter = waiter.mNext, i++) {
+                    indentedPrinter.println(i + ": waited for "
+                            + ((now - waiter.mStartTime) * 0.001f)
+                            + " ms - thread=" + waiter.mThread
+                            + ", priority=" + waiter.mPriority
+                            + ", sql='" + waiter.mSql + "'");
+                }
+            } else {
+                indentedPrinter.println("<none>");
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "SQLiteConnectionPool: " + mConfiguration.path;
+    }
+
+    private static final class ConnectionWaiter {
+        public ConnectionWaiter mNext;
+        public Thread mThread;
+        public long mStartTime;
+        public int mPriority;
+        public boolean mWantPrimaryConnection;
+        public String mSql;
+        public int mConnectionFlags;
+        public SQLiteConnection mAssignedConnection;
+        public RuntimeException mException;
+    }
+}
diff --git a/core/java/android/database/sqlite/SQLiteCursor.java b/core/java/android/database/sqlite/SQLiteCursor.java
index 8dcedf2..9dcb498 100644
--- a/core/java/android/database/sqlite/SQLiteCursor.java
+++ b/core/java/android/database/sqlite/SQLiteCursor.java
@@ -43,7 +43,7 @@ public class SQLiteCursor extends AbstractWindowedCursor {
     private final String[] mColumns;
 
     /** The query object for the cursor */
-    private SQLiteQuery mQuery;
+    private final SQLiteQuery mQuery;
 
     /** The compiled query this cursor came from */
     private final SQLiteCursorDriver mDriver;
@@ -96,9 +96,6 @@ public class SQLiteCursor extends AbstractWindowedCursor {
         if (query == null) {
             throw new IllegalArgumentException("query object cannot be null");
         }
-        if (query.mDatabase == null) {
-            throw new IllegalArgumentException("query.mDatabase cannot be null");
-        }
         if (StrictMode.vmSqliteObjectLeaksEnabled()) {
             mStackTrace = new DatabaseObjectNotClosedException().fillInStackTrace();
         } else {
@@ -109,38 +106,21 @@ public class SQLiteCursor extends AbstractWindowedCursor {
         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;
-                }
+        mColumns = query.getColumnNames();
+        for (int i = 0; i < mColumns.length; i++) {
+            // Make note of the row ID column index for quick access to it
+            if ("_id".equals(mColumns[i])) {
+                mRowIdColumnIndex = i;
             }
-        } finally {
-            query.mDatabase.unlock();
         }
     }
 
     /**
+     * Get the database that this cursor is associated with.
      * @return the SQLiteDatabase that this cursor is associated with.
      */
     public SQLiteDatabase getDatabase() {
-        synchronized (this) {
-            return mQuery.mDatabase;
-        }
+        return mQuery.getDatabase();
     }
 
     @Override
@@ -167,7 +147,7 @@ public class SQLiteCursor extends AbstractWindowedCursor {
 
         if (mCount == NO_COUNT) {
             int startPos = DatabaseUtils.cursorPickFillWindowStartPosition(requiredPos, 0);
-            mCount = getQuery().fillWindow(mWindow, startPos, requiredPos, true);
+            mCount = mQuery.fillWindow(mWindow, startPos, requiredPos, true);
             mCursorWindowCapacity = mWindow.getNumRows();
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "received count(*) from native_fill_window: " + mCount);
@@ -175,14 +155,10 @@ public class SQLiteCursor extends AbstractWindowedCursor {
         } else {
             int startPos = DatabaseUtils.cursorPickFillWindowStartPosition(requiredPos,
                     mCursorWindowCapacity);
-            getQuery().fillWindow(mWindow, startPos, requiredPos, false);
+            mQuery.fillWindow(mWindow, startPos, requiredPos, false);
         }
     }
 
-    private synchronized SQLiteQuery getQuery() {
-        return mQuery;
-    }
-
     @Override
     public int getColumnIndex(String columnName) {
         // Create mColumnNameMap on demand
@@ -237,75 +213,28 @@ public class SQLiteCursor extends AbstractWindowedCursor {
         if (isClosed()) {
             return false;
         }
-        long timeStart = 0;
-        if (false) {
-            timeStart = System.currentTimeMillis();
-        }
 
         synchronized (this) {
+            if (!mQuery.getDatabase().isOpen()) {
+                return false;
+            }
+
             if (mWindow != null) {
                 mWindow.clear();
             }
             mPos = -1;
-            SQLiteDatabase db = null;
-            try {
-                db = mQuery.mDatabase.getDatabaseHandle(mQuery.mSql);
-            } catch (IllegalStateException e) {
-                // for backwards compatibility, just return false
-                Log.w(TAG, "requery() failed " + e.getMessage(), e);
-                return false;
-            }
-            if (!db.equals(mQuery.mDatabase)) {
-                // since we need to use a different database connection handle,
-                // re-compile the query
-                try {
-                    db.lock(mQuery.mSql);
-                } catch (IllegalStateException e) {
-                    // for backwards compatibility, just return false
-                    Log.w(TAG, "requery() failed " + e.getMessage(), e);
-                    return false;
-                }
-                try {
-                    // close the old mQuery object and open a new one
-                    mQuery.close();
-                    mQuery = new SQLiteQuery(db, mQuery);
-                } catch (IllegalStateException e) {
-                    // for backwards compatibility, just return false
-                    Log.w(TAG, "requery() failed " + e.getMessage(), e);
-                    return false;
-                } finally {
-                    db.unlock();
-                }
-            }
-            // This one will recreate the temp table, and get its count
-            mDriver.cursorRequeried(this);
             mCount = NO_COUNT;
-            try {
-                mQuery.requery();
-            } catch (IllegalStateException e) {
-                // for backwards compatibility, just return false
-                Log.w(TAG, "requery() failed " + e.getMessage(), e);
-                return false;
-            }
-        }
 
-        if (false) {
-            Log.v("DatabaseWindow", "closing window in requery()");
-            Log.v(TAG, "--- Requery()ed cursor " + this + ": " + mQuery);
+            mDriver.cursorRequeried(this);
         }
 
-        boolean result = false;
         try {
-            result = super.requery();
+            return super.requery();
         } catch (IllegalStateException e) {
             // for backwards compatibility, just return false
             Log.w(TAG, "requery() failed " + e.getMessage(), e);
+            return false;
         }
-        if (false) {
-            long timeEnd = System.currentTimeMillis();
-            Log.v(TAG, "requery (" + (timeEnd - timeStart) + " ms): " + mDriver.toString());
-        }
-        return result;
     }
 
     @Override
@@ -330,20 +259,17 @@ public class SQLiteCursor extends AbstractWindowedCursor {
             // if the cursor hasn't been closed yet, close it first
             if (mWindow != null) {
                 if (mStackTrace != null) {
-                    int len = mQuery.mSql.length();
+                    String sql = mQuery.getSql();
+                    int len = sql.length();
                     StrictMode.onSqliteObjectLeaked(
                         "Finalizing a Cursor that has not been deactivated or closed. " +
-                        "database = " + mQuery.mDatabase.getPath() + ", table = " + mEditTable +
-                        ", query = " + mQuery.mSql.substring(0, (len > 1000) ? 1000 : len),
+                        "database = " + mQuery.getDatabase().getLabel() +
+                        ", table = " + mEditTable +
+                        ", query = " + sql.substring(0, (len > 1000) ? 1000 : len),
                         mStackTrace);
                 }
                 close();
                 SQLiteDebug.notifyActiveCursorFinalized();
-            } else {
-                if (false) {
-                    Log.v(TAG, "Finalizing cursor on database = " + mQuery.mDatabase.getPath() +
-                            ", table = " + mEditTable + ", query = " + mQuery.mSql);
-                }
             }
         } finally {
             super.finalize();
diff --git a/core/java/android/database/sqlite/SQLiteCursorDriver.java b/core/java/android/database/sqlite/SQLiteCursorDriver.java
index b3963f9..ad2cdd2 100644
--- a/core/java/android/database/sqlite/SQLiteCursorDriver.java
+++ b/core/java/android/database/sqlite/SQLiteCursorDriver.java
@@ -39,7 +39,7 @@ public interface SQLiteCursorDriver {
     void cursorDeactivated();
 
     /**
-     * Called by a SQLiteCursor when it is requeryed.
+     * Called by a SQLiteCursor when it is requeried.
      */
     void cursorRequeried(Cursor cursor);
 
diff --git a/core/java/android/database/sqlite/SQLiteCustomFunction.java b/core/java/android/database/sqlite/SQLiteCustomFunction.java
new file mode 100644
index 0000000..02f3284
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteCustomFunction.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+/**
+ * Describes a custom SQL function.
+ *
+ * @hide
+ */
+public final class SQLiteCustomFunction {
+    public final String name;
+    public final int numArgs;
+    public final SQLiteDatabase.CustomFunction callback;
+
+    /**
+     * Create custom function.
+     *
+     * @param name The name of the sqlite3 function.
+     * @param numArgs The number of arguments for the function, or -1 to
+     * support any number of arguments.
+     * @param callback The callback to invoke when the function is executed.
+     */
+    public SQLiteCustomFunction(String name, int numArgs,
+            SQLiteDatabase.CustomFunction callback) {
+        if (name == null) {
+            throw new IllegalArgumentException("name must not be null.");
+        }
+
+        this.name = name;
+        this.numArgs = numArgs;
+        this.callback = callback;
+    }
+
+    // Called from native.
+    @SuppressWarnings("unused")
+    private void dispatchCallback(String[] args) {
+        callback.callback(args);
+    }
+}
diff --git a/core/java/android/database/sqlite/SQLiteDatabase.java b/core/java/android/database/sqlite/SQLiteDatabase.java
index f990be6..377a680 100644
--- a/core/java/android/database/sqlite/SQLiteDatabase.java
+++ b/core/java/android/database/sqlite/SQLiteDatabase.java
@@ -16,7 +16,6 @@
 
 package android.database.sqlite;
 
-import android.app.AppGlobals;
 import android.content.ContentValues;
 import android.content.res.Resources;
 import android.database.Cursor;
@@ -25,61 +24,117 @@ import android.database.DatabaseUtils;
 import android.database.DefaultDatabaseErrorHandler;
 import android.database.SQLException;
 import android.database.sqlite.SQLiteDebug.DbStats;
-import android.os.Debug;
-import android.os.StatFs;
-import android.os.SystemClock;
-import android.os.SystemProperties;
+import android.os.Looper;
 import android.text.TextUtils;
 import android.util.EventLog;
 import android.util.Log;
-import android.util.LruCache;
 import android.util.Pair;
-import dalvik.system.BlockGuard;
+import android.util.Printer;
+
+import dalvik.system.CloseGuard;
+
 import java.io.File;
-import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Random;
 import java.util.WeakHashMap;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.regex.Pattern;
 
 /**
  * Exposes methods to manage a SQLite database.
- * <p>SQLiteDatabase has methods to create, delete, execute SQL commands, and
+ *
+ * <p>
+ * SQLiteDatabase has methods to create, delete, execute SQL commands, and
  * perform other common database management tasks.
- * <p>See the Notepad sample application in the SDK for an example of creating
+ * </p><p>
+ * See the Notepad sample application in the SDK for an example of creating
  * and managing a database.
- * <p> Database names must be unique within an application, not across all
- * applications.
+ * </p><p>
+ * Database names must be unique within an application, not across all applications.
+ * </p>
  *
  * <h3>Localized Collation - ORDER BY</h3>
- * <p>In addition to SQLite's default <code>BINARY</code> collator, Android supplies
- * two more, <code>LOCALIZED</code>, which changes with the system's current locale
- * if you wire it up correctly (XXX a link needed!), and <code>UNICODE</code>, which
- * is the Unicode Collation Algorithm and not tailored to the current locale.
+ * <p>
+ * In addition to SQLite's default <code>BINARY</code> collator, Android supplies
+ * two more, <code>LOCALIZED</code>, which changes with the system's current locale,
+ * and <code>UNICODE</code>, which is the Unicode Collation Algorithm and not tailored
+ * to the current locale.
+ * </p>
  */
 public class SQLiteDatabase extends SQLiteClosable {
     private static final String TAG = "SQLiteDatabase";
-    private static final boolean ENABLE_DB_SAMPLE = false; // true to enable stats in event log
-    private static final int EVENT_DB_OPERATION = 52000;
+
     private static final int EVENT_DB_CORRUPT = 75004;
 
-    /**
-     * Algorithms used in ON CONFLICT clause
-     * http://www.sqlite.org/lang_conflict.html
-     */
-    /**
-     *  When a constraint violation occurs, an immediate ROLLBACK occurs,
+    // Stores reference to all databases opened in the current process.
+    // (The referent Object is not used at this time.)
+    // INVARIANT: Guarded by sActiveDatabases.
+    private static WeakHashMap<SQLiteDatabase, Object> sActiveDatabases =
+            new WeakHashMap<SQLiteDatabase, Object>();
+
+    // Thread-local for database sessions that belong to this database.
+    // Each thread has its own database session.
+    // INVARIANT: Immutable.
+    private final ThreadLocal<SQLiteSession> mThreadSession = new ThreadLocal<SQLiteSession>() {
+        @Override
+        protected SQLiteSession initialValue() {
+            return createSession();
+        }
+    };
+
+    // The optional factory to use when creating new Cursors.  May be null.
+    // INVARIANT: Immutable.
+    private final CursorFactory mCursorFactory;
+
+    // Error handler to be used when SQLite returns corruption errors.
+    // INVARIANT: Immutable.
+    private final DatabaseErrorHandler mErrorHandler;
+
+    // Shared database state lock.
+    // This lock guards all of the shared state of the database, such as its
+    // configuration, whether it is open or closed, and so on.  This lock should
+    // be held for as little time as possible.
+    //
+    // The lock MUST NOT be held while attempting to acquire database connections or
+    // while executing SQL statements on behalf of the client as it can lead to deadlock.
+    //
+    // It is ok to hold the lock while reconfiguring the connection pool or dumping
+    // statistics because those operations are non-reentrant and do not try to acquire
+    // connections that might be held by other threads.
+    //
+    // Basic rule: grab the lock, access or modify global state, release the lock, then
+    // do the required SQL work.
+    private final Object mLock = new Object();
+
+    // Warns if the database is finalized without being closed properly.
+    // INVARIANT: Guarded by mLock.
+    private final CloseGuard mCloseGuardLocked = CloseGuard.get();
+
+    // The database configuration.
+    // INVARIANT: Guarded by mLock.
+    private final SQLiteDatabaseConfiguration mConfigurationLocked;
+
+    // The connection pool for the database, null when closed.
+    // The pool itself is thread-safe, but the reference to it can only be acquired
+    // when the lock is held.
+    // INVARIANT: Guarded by mLock.
+    private SQLiteConnectionPool mConnectionPoolLocked;
+
+    // True if the database has attached databases.
+    // INVARIANT: Guarded by mLock.
+    private boolean mHasAttachedDbsLocked;
+
+    // True if the database is in WAL mode.
+    // INVARIANT: Guarded by mLock.
+    private boolean mIsWALEnabledLocked;
+
+    /**
+     * When a constraint violation occurs, an immediate ROLLBACK occurs,
      * thus ending the current transaction, and the command aborts with a
      * return code of SQLITE_CONSTRAINT. If no transaction is active
      * (other than the implied transaction that is created on every command)
-     *  then this algorithm works the same as ABORT.
+     * then this algorithm works the same as ABORT.
      */
     public static final int CONFLICT_ROLLBACK = 1;
 
@@ -118,14 +173,15 @@ public class SQLiteDatabase extends SQLiteClosable {
      * violation occurs then the IGNORE algorithm is used. When this conflict
      * resolution strategy deletes rows in order to satisfy a constraint,
      * it does not invoke delete triggers on those rows.
-     *  This behavior might change in a future release.
+     * This behavior might change in a future release.
      */
     public static final int CONFLICT_REPLACE = 5;
 
     /**
-     * use the following when no conflict action is specified.
+     * Use the following when no conflict action is specified.
      */
     public static final int CONFLICT_NONE = 0;
+
     private static final String[] CONFLICT_VALUES = new String[]
             {"", " OR ROLLBACK ", " OR ABORT ", " OR FAIL ", " OR IGNORE ", " OR REPLACE "};
 
@@ -146,7 +202,7 @@ public class SQLiteDatabase extends SQLiteClosable {
     public static final int SQLITE_MAX_LIKE_PATTERN_LENGTH = 50000;
 
     /**
-     * Flag for {@link #openDatabase} to open the database for reading and writing.
+     * Open flag: Flag for {@link #openDatabase} to open the database for reading and writing.
      * If the disk is full, this may fail even before you actually write anything.
      *
      * {@more} Note that the value of this flag is 0, so it is the default.
@@ -154,7 +210,7 @@ public class SQLiteDatabase extends SQLiteClosable {
     public static final int OPEN_READWRITE = 0x00000000;          // update native code if changing
 
     /**
-     * Flag for {@link #openDatabase} to open the database for reading only.
+     * Open flag: Flag for {@link #openDatabase} to open the database for reading only.
      * This is the only reliable way to open a database if the disk may be full.
      */
     public static final int OPEN_READONLY = 0x00000001;           // update native code if changing
@@ -162,7 +218,8 @@ public class SQLiteDatabase extends SQLiteClosable {
     private static final int OPEN_READ_MASK = 0x00000001;         // update native code if changing
 
     /**
-     * Flag for {@link #openDatabase} to open the database without support for localized collators.
+     * Open flag: Flag for {@link #openDatabase} to open the database without support for
+     * localized collators.
      *
      * {@more} This causes the collator <code>LOCALIZED</code> not to be created.
      * You must be consistent when using this flag to use the setting the database was
@@ -171,190 +228,62 @@ public class SQLiteDatabase extends SQLiteClosable {
     public static final int NO_LOCALIZED_COLLATORS = 0x00000010;  // update native code if changing
 
     /**
-     * Flag for {@link #openDatabase} to create the database file if it does not already exist.
+     * Open flag: Flag for {@link #openDatabase} to create the database file if it does not
+     * already exist.
      */
     public static final int CREATE_IF_NECESSARY = 0x10000000;     // update native code if changing
 
     /**
-     * Indicates whether the most-recently started transaction has been marked as successful.
-     */
-    private boolean mInnerTransactionIsSuccessful;
-
-    /**
-     * Valid during the life of a transaction, and indicates whether the entire transaction (the
-     * outer one and all of the inner ones) so far has been successful.
-     */
-    private boolean mTransactionIsSuccessful;
-
-    /**
-     * Valid during the life of a transaction.
-     */
-    private SQLiteTransactionListener mTransactionListener;
-
-    /**
-     * this member is set if {@link #execSQL(String)} is used to begin and end transactions.
-     */
-    private boolean mTransactionUsingExecSql;
-
-    /** Synchronize on this when accessing the database */
-    private final DatabaseReentrantLock mLock = new DatabaseReentrantLock(true);
-
-    private long mLockAcquiredWallTime = 0L;
-    private long mLockAcquiredThreadTime = 0L;
-
-    // limit the frequency of complaints about each database to one within 20 sec
-    // unless run command adb shell setprop log.tag.Database VERBOSE
-    private static final int LOCK_WARNING_WINDOW_IN_MS = 20000;
-    /** If the lock is held this long then a warning will be printed when it is released. */
-    private static final int LOCK_ACQUIRED_WARNING_TIME_IN_MS = 300;
-    private static final int LOCK_ACQUIRED_WARNING_THREAD_TIME_IN_MS = 100;
-    private static final int LOCK_ACQUIRED_WARNING_TIME_IN_MS_ALWAYS_PRINT = 2000;
-
-    private static final int SLEEP_AFTER_YIELD_QUANTUM = 1000;
-
-    // The pattern we remove from database filenames before
-    // potentially logging them.
-    private static final Pattern EMAIL_IN_DB_PATTERN = Pattern.compile("[\\w\\.\\-]+@[\\w\\.\\-]+");
-
-    private long mLastLockMessageTime = 0L;
-
-    // Things related to query logging/sampling for debugging
-    // slow/frequent queries during development.  Always log queries
-    // which take (by default) 500ms+; shorter queries are sampled
-    // accordingly.  Commit statements, which are typically slow, are
-    // logged together with the most recently executed SQL statement,
-    // for disambiguation.  The 500ms value is configurable via a
-    // SystemProperty, but developers actively debugging database I/O
-    // should probably use the regular log tunable,
-    // LOG_SLOW_QUERIES_PROPERTY, defined below.
-    private static int sQueryLogTimeInMillis = 0;  // lazily initialized
-    private static final int QUERY_LOG_SQL_LENGTH = 64;
-    private static final String COMMIT_SQL = "COMMIT;";
-    private static final String BEGIN_SQL = "BEGIN;";
-    private final Random mRandom = new Random();
-    /** the last non-commit/rollback sql statement in a transaction */
-    // guarded by 'this'
-    private String mLastSqlStatement = null;
-
-    synchronized String getLastSqlStatement() {
-        return mLastSqlStatement;
-    }
-
-    synchronized void setLastSqlStatement(String sql) {
-        mLastSqlStatement = sql;
-    }
-
-    /** guarded by {@link #mLock} */
-    private long mTransStartTime;
-
-    // String prefix for slow database query EventLog records that show
-    // lock acquistions of the database.
-    /* package */ static final String GET_LOCK_LOG_PREFIX = "GETLOCK:";
-
-    /** Used by native code, do not rename. make it volatile, so it is thread-safe. */
-    /* package */ volatile int mNativeHandle = 0;
-
-    /**
-     * The size, in bytes, of a block on "/data". This corresponds to the Unix
-     * statfs.f_bsize field. note that this field is lazily initialized.
-     */
-    private static int sBlockSize = 0;
-
-    /** The path for the database file */
-    private final String mPath;
-
-    /** The anonymized path for the database file for logging purposes */
-    private String mPathForLogs = null;  // lazily populated
-
-    /** The flags passed to open/create */
-    private final int mFlags;
-
-    /** The optional factory to use when creating new Cursors */
-    private final CursorFactory mFactory;
-
-    private final WeakHashMap<SQLiteClosable, Object> mPrograms;
-
-    /** Default statement-cache size per database connection ( = instance of this class) */
-    private static final int DEFAULT_SQL_CACHE_SIZE = 25;
-
-    /**
-     * for each instance of this class, a LRU cache is maintained to store
-     * the compiled query statement ids returned by sqlite database.
-     *     key = SQL statement with "?" for bind args
-     *     value = {@link SQLiteCompiledSql}
-     * If an application opens the database and keeps it open during its entire life, then
-     * there will not be an overhead of compilation of SQL statements by sqlite.
+     * Absolute max value that can be set by {@link #setMaxSqlCacheSize(int)}.
      *
-     * why is this cache NOT static? because sqlite attaches compiledsql statements to the
-     * struct created when {@link SQLiteDatabase#openDatabase(String, CursorFactory, int)} is
-     * invoked.
-     *
-     * this cache's max size is settable by calling the method
-     * (@link #setMaxSqlCacheSize(int)}.
-     */
-    // guarded by this
-    private LruCache<String, SQLiteCompiledSql> mCompiledQueries;
-
-    /**
-     * absolute max value that can be set by {@link #setMaxSqlCacheSize(int)}
-     * size of each prepared-statement is between 1K - 6K, depending on the complexity of the
-     * SQL statement & schema.
+     * Each prepared-statement is between 1K - 6K, depending on the complexity of the
+     * SQL statement & schema.  A large SQL cache may use a significant amount of memory.
      */
     public static final int MAX_SQL_CACHE_SIZE = 100;
-    private boolean mCacheFullWarning;
-
-    /** Used to find out where this object was created in case it never got closed. */
-    private final Throwable mStackTrace;
-
-    /** stores the list of statement ids that need to be finalized by sqlite */
-    private final ArrayList<Integer> mClosedStatementIds = new ArrayList<Integer>();
-
-    /** {@link DatabaseErrorHandler} to be used when SQLite returns any of the following errors
-     *    Corruption
-     * */
-    private final DatabaseErrorHandler mErrorHandler;
-
-    /** The Database connection pool {@link DatabaseConnectionPool}.
-     * Visibility is package-private for testing purposes. otherwise, private visibility is enough.
-     */
-    /* package */ volatile DatabaseConnectionPool mConnectionPool = null;
-
-    /** Each database connection handle in the pool is assigned a number 1..N, where N is the
-     * size of the connection pool.
-     * The main connection handle to which the pool is attached is assigned a value of 0.
-     */
-    /* package */ final short mConnectionNum;
-
-    /** on pooled database connections, this member points to the parent ( = main)
-     * database connection handle.
-     * package visibility only for testing purposes
-     */
-    /* package */ SQLiteDatabase mParentConnObj = null;
-
-    private static final String MEMORY_DB_PATH = ":memory:";
 
-    /** set to true if the database has attached databases */
-    private volatile boolean mHasAttachedDbs = false;
-
-    /** stores reference to all databases opened in the current process. */
-    private static ArrayList<WeakReference<SQLiteDatabase>> mActiveDatabases =
-            new ArrayList<WeakReference<SQLiteDatabase>>();
-
-    synchronized void addSQLiteClosable(SQLiteClosable closable) {
-        // mPrograms is per instance of SQLiteDatabase and it doesn't actually touch the database
-        // itself. so, there is no need to lock().
-        mPrograms.put(closable, null);
+    private SQLiteDatabase(String path, int openFlags, CursorFactory cursorFactory,
+            DatabaseErrorHandler errorHandler) {
+        mCursorFactory = cursorFactory;
+        mErrorHandler = errorHandler != null ? errorHandler : new DefaultDatabaseErrorHandler();
+        mConfigurationLocked = new SQLiteDatabaseConfiguration(path, openFlags);
     }
 
-    synchronized void removeSQLiteClosable(SQLiteClosable closable) {
-        mPrograms.remove(closable);
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            dispose(true);
+        } finally {
+            super.finalize();
+        }
     }
 
     @Override
     protected void onAllReferencesReleased() {
-        if (isOpen()) {
-            // close the database which will close all pending statements to be finalized also
-            close();
+        dispose(false);
+    }
+
+    private void dispose(boolean finalized) {
+        final SQLiteConnectionPool pool;
+        synchronized (mLock) {
+            if (mCloseGuardLocked != null) {
+                if (finalized) {
+                    mCloseGuardLocked.warnIfOpen();
+                }
+                mCloseGuardLocked.close();
+            }
+
+            pool = mConnectionPoolLocked;
+            mConnectionPoolLocked = null;
+        }
+
+        if (!finalized) {
+            synchronized (sActiveDatabases) {
+                sActiveDatabases.remove(this);
+            }
+
+            if (pool != null) {
+                pool.close();
+            }
         }
     }
 
@@ -364,7 +293,9 @@ public class SQLiteDatabase extends SQLiteClosable {
      *
      * @return the number of bytes actually released
      */
-    static public native int releaseMemory();
+    public static int releaseMemory() {
+        return SQLiteGlobal.releaseMemory();
+    }
 
     /**
      * Control whether or not the SQLiteDatabase is made thread-safe by using locks
@@ -372,159 +303,82 @@ public class SQLiteDatabase extends SQLiteClosable {
      * DB will only be used by a single thread then you should set this to false.
      * The default is true.
      * @param lockingEnabled set to true to enable locks, false otherwise
+     *
+     * @deprecated This method now does nothing.  Do not use.
      */
+    @Deprecated
     public void setLockingEnabled(boolean lockingEnabled) {
-        mLockingEnabled = lockingEnabled;
     }
 
     /**
-     * If set then the SQLiteDatabase is made thread-safe by using locks
-     * around critical sections
+     * Gets a label to use when describing the database in log messages.
+     * @return The label.
      */
-    private boolean mLockingEnabled = true;
-
-    /* package */ void onCorruption() {
-        EventLog.writeEvent(EVENT_DB_CORRUPT, mPath);
-        mErrorHandler.onCorruption(this);
+    String getLabel() {
+        synchronized (mLock) {
+            return mConfigurationLocked.label;
+        }
     }
 
     /**
-     * Locks the database for exclusive access. The database lock must be held when
-     * touch the native sqlite3* object since it is single threaded and uses
-     * a polling lock contention algorithm. The lock is recursive, and may be acquired
-     * multiple times by the same thread. This is a no-op if mLockingEnabled is false.
-     *
-     * @see #unlock()
+     * Sends a corruption message to the database error handler.
      */
-    /* package */ void lock(String sql) {
-        lock(sql, false);
-    }
-
-    /* pachage */ void lock() {
-        lock(null, false);
-    }
-
-    private static final long LOCK_WAIT_PERIOD = 30L;
-    private void lock(String sql, boolean forced) {
-        // make sure this method is NOT being called from a 'synchronized' method
-        if (Thread.holdsLock(this)) {
-            Log.w(TAG, "don't lock() while in a synchronized method");
-        }
-        verifyDbIsOpen();
-        if (!forced && !mLockingEnabled) return;
-        boolean done = false;
-        long timeStart = SystemClock.uptimeMillis();
-        while (!done) {
-            try {
-                // wait for 30sec to acquire the lock
-                done = mLock.tryLock(LOCK_WAIT_PERIOD, TimeUnit.SECONDS);
-                if (!done) {
-                    // lock not acquired in NSec. print a message and stacktrace saying the lock
-                    // has not been available for 30sec.
-                    Log.w(TAG, "database lock has not been available for " + LOCK_WAIT_PERIOD +
-                            " sec. Current Owner of the lock is " + mLock.getOwnerDescription() +
-                            ". Continuing to wait in thread: " + Thread.currentThread().getId());
-                }
-            } catch (InterruptedException e) {
-                // ignore the interruption
-            }
-        }
-        if (SQLiteDebug.DEBUG_LOCK_TIME_TRACKING) {
-            if (mLock.getHoldCount() == 1) {
-                // Use elapsed real-time since the CPU may sleep when waiting for IO
-                mLockAcquiredWallTime = SystemClock.elapsedRealtime();
-                mLockAcquiredThreadTime = Debug.threadCpuTimeNanos();
-            }
-        }
-        if (sql != null) {
-            if (ENABLE_DB_SAMPLE)  {
-                logTimeStat(sql, timeStart, GET_LOCK_LOG_PREFIX);
-            }
-        }
-    }
-    private static class DatabaseReentrantLock extends ReentrantLock {
-        DatabaseReentrantLock(boolean fair) {
-            super(fair);
-        }
-        @Override
-        public Thread getOwner() {
-            return super.getOwner();
-        }
-        public String getOwnerDescription() {
-            Thread t = getOwner();
-            return (t== null) ? "none" : String.valueOf(t.getId());
-        }
+    void onCorruption() {
+        EventLog.writeEvent(EVENT_DB_CORRUPT, getLabel());
+        mErrorHandler.onCorruption(this);
     }
 
     /**
-     * Locks the database for exclusive access. The database lock must be held when
-     * touch the native sqlite3* object since it is single threaded and uses
-     * a polling lock contention algorithm. The lock is recursive, and may be acquired
-     * multiple times by the same thread.
+     * Gets the {@link SQLiteSession} that belongs to this thread for this database.
+     * Once a thread has obtained a session, it will continue to obtain the same
+     * session even after the database has been closed (although the session will not
+     * be usable).  However, a thread that does not already have a session cannot
+     * obtain one after the database has been closed.
      *
-     * @see #unlockForced()
+     * The idea is that threads that have active connections to the database may still
+     * have work to complete even after the call to {@link #close}.  Active database
+     * connections are not actually disposed until they are released by the threads
+     * that own them.
+     *
+     * @return The session, never null.
+     *
+     * @throws IllegalStateException if the thread does not yet have a session and
+     * the database is not open.
      */
-    private void lockForced() {
-        lock(null, true);
-    }
-
-    private void lockForced(String sql) {
-        lock(sql, true);
+    SQLiteSession getThreadSession() {
+        return mThreadSession.get(); // initialValue() throws if database closed
     }
 
-    /**
-     * Releases the database lock. This is a no-op if mLockingEnabled is false.
-     *
-     * @see #unlock()
-     */
-    /* package */ void unlock() {
-        if (!mLockingEnabled) return;
-        if (SQLiteDebug.DEBUG_LOCK_TIME_TRACKING) {
-            if (mLock.getHoldCount() == 1) {
-                checkLockHoldTime();
-            }
+    SQLiteSession createSession() {
+        final SQLiteConnectionPool pool;
+        synchronized (mLock) {
+            throwIfNotOpenLocked();
+            pool = mConnectionPoolLocked;
         }
-        mLock.unlock();
+        return new SQLiteSession(pool);
     }
 
     /**
-     * Releases the database lock.
+     * Gets default connection flags that are appropriate for this thread, taking into
+     * account whether the thread is acting on behalf of the UI.
      *
-     * @see #unlockForced()
+     * @param readOnly True if the connection should be read-only.
+     * @return The connection flags.
      */
-    private void unlockForced() {
-        if (SQLiteDebug.DEBUG_LOCK_TIME_TRACKING) {
-            if (mLock.getHoldCount() == 1) {
-                checkLockHoldTime();
-            }
+    int getThreadDefaultConnectionFlags(boolean readOnly) {
+        int flags = readOnly ? SQLiteConnectionPool.CONNECTION_FLAG_READ_ONLY :
+                SQLiteConnectionPool.CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY;
+        if (isMainThread()) {
+            flags |= SQLiteConnectionPool.CONNECTION_FLAG_INTERACTIVE;
         }
-        mLock.unlock();
+        return flags;
     }
 
-    private void checkLockHoldTime() {
-        // Use elapsed real-time since the CPU may sleep when waiting for IO
-        long elapsedTime = SystemClock.elapsedRealtime();
-        long lockedTime = elapsedTime - mLockAcquiredWallTime;
-        if (lockedTime < LOCK_ACQUIRED_WARNING_TIME_IN_MS_ALWAYS_PRINT &&
-                !Log.isLoggable(TAG, Log.VERBOSE) &&
-                (elapsedTime - mLastLockMessageTime) < LOCK_WARNING_WINDOW_IN_MS) {
-            return;
-        }
-        if (lockedTime > LOCK_ACQUIRED_WARNING_TIME_IN_MS) {
-            int threadTime = (int)
-                    ((Debug.threadCpuTimeNanos() - mLockAcquiredThreadTime) / 1000000);
-            if (threadTime > LOCK_ACQUIRED_WARNING_THREAD_TIME_IN_MS ||
-                    lockedTime > LOCK_ACQUIRED_WARNING_TIME_IN_MS_ALWAYS_PRINT) {
-                mLastLockMessageTime = elapsedTime;
-                String msg = "lock held on " + mPath + " for " + lockedTime + "ms. Thread time was "
-                        + threadTime + "ms";
-                if (SQLiteDebug.DEBUG_LOCK_TIME_TRACKING_STACK_TRACE) {
-                    Log.d(TAG, msg, new Exception());
-                } else {
-                    Log.d(TAG, msg);
-                }
-            }
-        }
+    private static boolean isMainThread() {
+        // FIXME: There should be a better way to do this.
+        // Would also be nice to have something that would work across Binder calls.
+        Looper looper = Looper.myLooper();
+        return looper != null && looper == Looper.getMainLooper();
     }
 
     /**
@@ -636,50 +490,9 @@ public class SQLiteDatabase extends SQLiteClosable {
 
     private void beginTransaction(SQLiteTransactionListener transactionListener,
             boolean exclusive) {
-        verifyDbIsOpen();
-        lockForced(BEGIN_SQL);
-        boolean ok = false;
-        try {
-            // If this thread already had the lock then get out
-            if (mLock.getHoldCount() > 1) {
-                if (mInnerTransactionIsSuccessful) {
-                    String msg = "Cannot call beginTransaction between "
-                            + "calling setTransactionSuccessful and endTransaction";
-                    IllegalStateException e = new IllegalStateException(msg);
-                    Log.e(TAG, "beginTransaction() failed", e);
-                    throw e;
-                }
-                ok = true;
-                return;
-            }
-
-            // This thread didn't already have the lock, so begin a database
-            // transaction now.
-            if (exclusive && mConnectionPool == null) {
-                execSQL("BEGIN EXCLUSIVE;");
-            } else {
-                execSQL("BEGIN IMMEDIATE;");
-            }
-            mTransStartTime = SystemClock.uptimeMillis();
-            mTransactionListener = transactionListener;
-            mTransactionIsSuccessful = true;
-            mInnerTransactionIsSuccessful = false;
-            if (transactionListener != null) {
-                try {
-                    transactionListener.onBegin();
-                } catch (RuntimeException e) {
-                    execSQL("ROLLBACK;");
-                    throw e;
-                }
-            }
-            ok = true;
-        } finally {
-            if (!ok) {
-                // beginTransaction is called before the try block so we must release the lock in
-                // the case of failure.
-                unlockForced();
-            }
-        }
+        getThreadSession().beginTransaction(exclusive ? SQLiteSession.TRANSACTION_MODE_EXCLUSIVE :
+                SQLiteSession.TRANSACTION_MODE_IMMEDIATE, transactionListener,
+                getThreadDefaultConnectionFlags(false /*readOnly*/));
     }
 
     /**
@@ -687,68 +500,7 @@ public class SQLiteDatabase extends SQLiteClosable {
      * are committed and rolled back.
      */
     public void endTransaction() {
-        verifyLockOwner();
-        try {
-            if (mInnerTransactionIsSuccessful) {
-                mInnerTransactionIsSuccessful = false;
-            } else {
-                mTransactionIsSuccessful = false;
-            }
-            if (mLock.getHoldCount() != 1) {
-                return;
-            }
-            RuntimeException savedException = null;
-            if (mTransactionListener != null) {
-                try {
-                    if (mTransactionIsSuccessful) {
-                        mTransactionListener.onCommit();
-                    } else {
-                        mTransactionListener.onRollback();
-                    }
-                } catch (RuntimeException e) {
-                    savedException = e;
-                    mTransactionIsSuccessful = false;
-                }
-            }
-            if (mTransactionIsSuccessful) {
-                execSQL(COMMIT_SQL);
-                // if write-ahead logging is used, we have to take care of checkpoint.
-                // TODO: should applications be given the flexibility of choosing when to
-                // trigger checkpoint?
-                // for now, do checkpoint after every COMMIT because that is the fastest
-                // way to guarantee that readers will see latest data.
-                // but this is the slowest way to run sqlite with in write-ahead logging mode.
-                if (this.mConnectionPool != null) {
-                    execSQL("PRAGMA wal_checkpoint;");
-                    if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {
-                        Log.i(TAG, "PRAGMA wal_Checkpoint done");
-                    }
-                }
-                // log the transaction time to the Eventlog.
-                if (ENABLE_DB_SAMPLE) {
-                    logTimeStat(getLastSqlStatement(), mTransStartTime, COMMIT_SQL);
-                }
-            } else {
-                try {
-                    execSQL("ROLLBACK;");
-                    if (savedException != null) {
-                        throw savedException;
-                    }
-                } catch (SQLException e) {
-                    if (false) {
-                        Log.d(TAG, "exception during rollback, maybe the DB previously "
-                                + "performed an auto-rollback");
-                    }
-                }
-            }
-        } finally {
-            mTransactionListener = null;
-            unlockForced();
-            if (false) {
-                Log.v(TAG, "unlocked " + Thread.currentThread()
-                        + ", holdCount is " + mLock.getHoldCount());
-            }
-        }
+        getThreadSession().endTransaction();
     }
 
     /**
@@ -761,86 +513,46 @@ public class SQLiteDatabase extends SQLiteClosable {
      * transaction is already marked as successful.
      */
     public void setTransactionSuccessful() {
-        verifyDbIsOpen();
-        if (!mLock.isHeldByCurrentThread()) {
-            throw new IllegalStateException("no transaction pending");
-        }
-        if (mInnerTransactionIsSuccessful) {
-            throw new IllegalStateException(
-                    "setTransactionSuccessful may only be called once per call to beginTransaction");
-        }
-        mInnerTransactionIsSuccessful = true;
+        getThreadSession().setTransactionSuccessful();
     }
 
     /**
-     * return true if there is a transaction pending
+     * Returns true if the current thread has a transaction pending.
+     *
+     * @return True if the current thread is in a transaction.
      */
     public boolean inTransaction() {
-        return mLock.getHoldCount() > 0 || mTransactionUsingExecSql;
-    }
-
-    /* package */ synchronized void setTransactionUsingExecSqlFlag() {
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.i(TAG, "found execSQL('begin transaction')");
-        }
-        mTransactionUsingExecSql = true;
-    }
-
-    /* package */ synchronized void resetTransactionUsingExecSqlFlag() {
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            if (mTransactionUsingExecSql) {
-                Log.i(TAG, "found execSQL('commit or end or rollback')");
-            }
-        }
-        mTransactionUsingExecSql = false;
+        return getThreadSession().hasTransaction();
     }
 
     /**
-     * Returns true if the caller is considered part of the current transaction, if any.
+     * Returns true if the current thread is holding an active connection to the database.
      * <p>
-     * Caller is part of the current transaction if either of the following is true
-     * <ol>
-     *   <li>If transaction is started by calling beginTransaction() methods AND if the caller is
-     *   in the same thread as the thread that started the transaction.
-     *   </li>
-     *   <li>If the transaction is started by calling {@link #execSQL(String)} like this:
-     *   execSQL("BEGIN transaction"). In this case, every thread in the process is considered
-     *   part of the current transaction.</li>
-     * </ol>
-     *
-     * @return true if the caller is considered part of the current transaction, if any.
-     */
-    /* package */ synchronized boolean amIInTransaction() {
-        // always do this test on the main database connection - NOT on pooled database connection
-        // since transactions always occur on the main database connections only.
-        SQLiteDatabase db = (isPooledConnection()) ? mParentConnObj : this;
-        boolean b = (!db.inTransaction()) ? false :
-                db.mTransactionUsingExecSql || db.mLock.isHeldByCurrentThread();
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.i(TAG, "amIinTransaction: " + b);
-        }
-        return b;
-    }
-
-    /**
-     * Checks if the database lock is held by this thread.
+     * The name of this method comes from a time when having an active connection
+     * to the database meant that the thread was holding an actual lock on the
+     * database.  Nowadays, there is no longer a true "database lock" although threads
+     * may block if they cannot acquire a database connection to perform a
+     * particular operation.
+     * </p>
      *
-     * @return true, if this thread is holding the database lock.
+     * @return True if the current thread is holding an active connection to the database.
      */
     public boolean isDbLockedByCurrentThread() {
-        return mLock.isHeldByCurrentThread();
+        return getThreadSession().hasConnection();
     }
 
     /**
-     * Checks if the database is locked by another thread. This is
-     * just an estimate, since this status can change at any time,
-     * including after the call is made but before the result has
-     * been acted upon.
+     * Always returns false.
+     * <p>
+     * There is no longer the concept of a database lock, so this method always returns false.
+     * </p>
      *
-     * @return true, if the database is locked by another thread
+     * @return False.
+     * @deprecated Always returns false.  Do not use this method.
      */
+    @Deprecated
     public boolean isDbLockedByOtherThreads() {
-        return !mLock.isHeldByCurrentThread() && mLock.isLocked();
+        return false;
     }
 
     /**
@@ -884,46 +596,12 @@ public class SQLiteDatabase extends SQLiteClosable {
         return yieldIfContendedHelper(true /* check yielding */, sleepAfterYieldDelay);
     }
 
-    private boolean yieldIfContendedHelper(boolean checkFullyYielded, long sleepAfterYieldDelay) {
-        if (mLock.getQueueLength() == 0) {
-            // Reset the lock acquire time since we know that the thread was willing to yield
-            // the lock at this time.
-            mLockAcquiredWallTime = SystemClock.elapsedRealtime();
-            mLockAcquiredThreadTime = Debug.threadCpuTimeNanos();
-            return false;
-        }
-        setTransactionSuccessful();
-        SQLiteTransactionListener transactionListener = mTransactionListener;
-        endTransaction();
-        if (checkFullyYielded) {
-            if (this.isDbLockedByCurrentThread()) {
-                throw new IllegalStateException(
-                        "Db locked more than once. yielfIfContended cannot yield");
-            }
-        }
-        if (sleepAfterYieldDelay > 0) {
-            // Sleep for up to sleepAfterYieldDelay milliseconds, waking up periodically to
-            // check if anyone is using the database.  If the database is not contended,
-            // retake the lock and return.
-            long remainingDelay = sleepAfterYieldDelay;
-            while (remainingDelay > 0) {
-                try {
-                    Thread.sleep(remainingDelay < SLEEP_AFTER_YIELD_QUANTUM ?
-                            remainingDelay : SLEEP_AFTER_YIELD_QUANTUM);
-                } catch (InterruptedException e) {
-                    Thread.interrupted();
-                }
-                remainingDelay -= SLEEP_AFTER_YIELD_QUANTUM;
-                if (mLock.getQueueLength() == 0) {
-                    break;
-                }
-            }
-        }
-        beginTransactionWithListener(transactionListener);
-        return true;
+    private boolean yieldIfContendedHelper(boolean throwIfUnsafe, long sleepAfterYieldDelay) {
+        return getThreadSession().yieldTransaction(sleepAfterYieldDelay, throwIfUnsafe);
     }
 
     /**
+     * Deprecated.
      * @deprecated This method no longer serves any useful purpose and has been deprecated.
      */
     @Deprecated
@@ -932,19 +610,6 @@ public class SQLiteDatabase extends SQLiteClosable {
     }
 
     /**
-     * Used to allow returning sub-classes of {@link Cursor} when calling query.
-     */
-    public interface CursorFactory {
-        /**
-         * See
-         * {@link SQLiteCursor#SQLiteCursor(SQLiteCursorDriver, String, SQLiteQuery)}.
-         */
-        public Cursor newCursor(SQLiteDatabase db,
-                SQLiteCursorDriver masterQuery, String editTable,
-                SQLiteQuery query);
-    }
-
-    /**
      * Open the database according to the flags {@link #OPEN_READWRITE}
      * {@link #OPEN_READONLY} {@link #CREATE_IF_NECESSARY} and/or {@link #NO_LOCALIZED_COLLATORS}.
      *
@@ -983,50 +648,9 @@ public class SQLiteDatabase extends SQLiteClosable {
      */
     public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
             DatabaseErrorHandler errorHandler) {
-        SQLiteDatabase sqliteDatabase = openDatabase(path, factory, flags, errorHandler,
-                (short) 0 /* the main connection handle */);
-
-        // set sqlite pagesize to mBlockSize
-        if (sBlockSize == 0) {
-            // TODO: "/data" should be a static final String constant somewhere. it is hardcoded
-            // in several places right now.
-            sBlockSize = new StatFs("/data").getBlockSize();
-        }
-        sqliteDatabase.setPageSize(sBlockSize);
-        sqliteDatabase.setJournalMode(path, "TRUNCATE");
-
-        // add this database to the list of databases opened in this process
-        synchronized(mActiveDatabases) {
-            mActiveDatabases.add(new WeakReference<SQLiteDatabase>(sqliteDatabase));
-        }
-        return sqliteDatabase;
-    }
-
-    private static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
-            DatabaseErrorHandler errorHandler, short connectionNum) {
-        SQLiteDatabase db = new SQLiteDatabase(path, factory, flags, errorHandler, connectionNum);
-        try {
-            if (Log.isLoggable(TAG, Log.DEBUG)) {
-                Log.i(TAG, "opening the db : " + path);
-            }
-            // Open the database.
-            db.dbopen(path, flags);
-            db.setLocale(Locale.getDefault());
-            if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {
-                db.enableSqlTracing(path, connectionNum);
-            }
-            if (SQLiteDebug.DEBUG_SQL_TIME) {
-                db.enableSqlProfiling(path, connectionNum);
-            }
-            return db;
-        } catch (SQLiteDatabaseCorruptException e) {
-            db.mErrorHandler.onCorruption(db);
-            return SQLiteDatabase.openDatabase(path, factory, flags, errorHandler);
-        } catch (SQLiteException e) {
-            Log.e(TAG, "Failed to open the database. closing it.", e);
-            db.close();
-            throw e;
-        }
+        SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler);
+        db.open();
+        return db;
     }
 
     /**
@@ -1051,16 +675,46 @@ public class SQLiteDatabase extends SQLiteClosable {
         return openDatabase(path, factory, CREATE_IF_NECESSARY, errorHandler);
     }
 
-    private void setJournalMode(final String dbPath, final String mode) {
-        // journal mode can be set only for non-memory databases
+    private void open() {
+        try {
+            try {
+                openInner();
+            } catch (SQLiteDatabaseCorruptException ex) {
+                onCorruption();
+                openInner();
+            }
+
+            // Disable WAL if it was previously enabled.
+            setJournalMode("TRUNCATE");
+        } catch (SQLiteException ex) {
+            Log.e(TAG, "Failed to open database '" + getLabel() + "'.", ex);
+            close();
+            throw ex;
+        }
+    }
+
+    private void openInner() {
+        synchronized (mLock) {
+            assert mConnectionPoolLocked == null;
+            mConnectionPoolLocked = SQLiteConnectionPool.open(mConfigurationLocked);
+            mCloseGuardLocked.open("close");
+        }
+
+        synchronized (sActiveDatabases) {
+            sActiveDatabases.put(this, null);
+        }
+    }
+
+    private void setJournalMode(String mode) {
+        // Journal mode can be set only for non-memory databases
         // AND can't be set for readonly databases
-        if (dbPath.equalsIgnoreCase(MEMORY_DB_PATH) || isReadOnly()) {
+        if (isInMemoryDatabase() || isReadOnly()) {
             return;
         }
         String s = DatabaseUtils.stringForQuery(this, "PRAGMA journal_mode=" + mode, null);
         if (!s.equalsIgnoreCase(mode)) {
-            Log.e(TAG, "setting journal_mode to " + mode + " failed for db: " + dbPath +
-                    " (on pragma set journal_mode, sqlite returned:" + s);
+            Log.e(TAG, "setting journal_mode to " + mode + " failed for db: " + getLabel()
+                    + " (on pragma set journal_mode, sqlite returned:" + s);
         }
     }
 
@@ -1077,159 +731,37 @@ public class SQLiteDatabase extends SQLiteClosable {
      */
     public static SQLiteDatabase create(CursorFactory factory) {
         // This is a magic string with special meaning for SQLite.
-        return openDatabase(MEMORY_DB_PATH, factory, CREATE_IF_NECESSARY);
+        return openDatabase(SQLiteDatabaseConfiguration.MEMORY_DB_PATH,
+                factory, CREATE_IF_NECESSARY);
     }
 
     /**
      * Close the database.
      */
     public void close() {
-        if (!isOpen()) {
-            return;
-        }
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            Log.i(TAG, "closing db: " + mPath + " (connection # " + mConnectionNum);
-        }
-        lock();
-        try {
-            // some other thread could have closed this database while I was waiting for lock.
-            // check the database state
-            if (!isOpen()) {
-                return;
-            }
-            closeClosable();
-            // finalize ALL statements queued up so far
-            closePendingStatements();
-            releaseCustomFunctions();
-            // close this database instance - regardless of its reference count value
-            closeDatabase();
-            if (mConnectionPool != null) {
-                if (Log.isLoggable(TAG, Log.DEBUG)) {
-                    assert mConnectionPool != null;
-                    Log.i(TAG, mConnectionPool.toString());
-                }
-                mConnectionPool.close();
-            }
-        } finally {
-            unlock();
-        }
-    }
-
-    private void closeClosable() {
-        /* deallocate all compiled SQL statement objects from mCompiledQueries cache.
-         * this should be done before de-referencing all {@link SQLiteClosable} objects
-         * from this database object because calling
-         * {@link SQLiteClosable#onAllReferencesReleasedFromContainer()} could cause the database
-         * to be closed. sqlite doesn't let a database close if there are
-         * any unfinalized statements - such as the compiled-sql objects in mCompiledQueries.
-         */
-        deallocCachedSqlStatements();
-
-        Iterator<Map.Entry<SQLiteClosable, Object>> iter = mPrograms.entrySet().iterator();
-        while (iter.hasNext()) {
-            Map.Entry<SQLiteClosable, Object> entry = iter.next();
-            SQLiteClosable program = entry.getKey();
-            if (program != null) {
-                program.onAllReferencesReleasedFromContainer();
-            }
-        }
-    }
-
-    /**
-     * package level access for testing purposes
-     */
-    /* package */ void closeDatabase() throws SQLiteException {
-        try {
-            dbclose();
-        } catch (SQLiteUnfinalizedObjectsException e)  {
-            String msg = e.getMessage();
-            String[] tokens = msg.split(",", 2);
-            int stmtId = Integer.parseInt(tokens[0]);
-            // get extra info about this statement, if it is still to be released by closeClosable()
-            Iterator<Map.Entry<SQLiteClosable, Object>> iter = mPrograms.entrySet().iterator();
-            boolean found = false;
-            while (iter.hasNext()) {
-                Map.Entry<SQLiteClosable, Object> entry = iter.next();
-                SQLiteClosable program = entry.getKey();
-                if (program != null && program instanceof SQLiteProgram) {
-                    SQLiteCompiledSql compiledSql = ((SQLiteProgram)program).mCompiledSql;
-                    if (compiledSql.nStatement == stmtId) {
-                        msg = compiledSql.toString();
-                        found = true;
-                    }
-                }
-            }
-            if (!found) {
-                // the statement is already released by closeClosable(). is it waiting to be
-                // finalized?
-                if (mClosedStatementIds.contains(stmtId)) {
-                    Log.w(TAG, "this shouldn't happen. finalizing the statement now: ");
-                    closePendingStatements();
-                    // try to close the database again
-                    closeDatabase();
-                }
-            } else {
-                // the statement is not yet closed. most probably programming error in the app.
-                throw new SQLiteUnfinalizedObjectsException(
-                        "close() on database: " + getPath() +
-                        " failed due to un-close()d SQL statements: " + msg);
-            }
-        }
-    }
-
-    /**
-     * Native call to close the database.
-     */
-    private native void dbclose();
-
-    /**
-     * A callback interface for a custom sqlite3 function.
-     * This can be used to create a function that can be called from
-     * sqlite3 database triggers.
-     * @hide
-     */
-    public interface CustomFunction {
-        public void callback(String[] args);
+        dispose(false);
     }
 
     /**
      * Registers a CustomFunction callback as a function that can be called from
-     * sqlite3 database triggers.
+     * SQLite database triggers.
+     *
      * @param name the name of the sqlite3 function
      * @param numArgs the number of arguments for the function
      * @param function callback to call when the function is executed
      * @hide
      */
     public void addCustomFunction(String name, int numArgs, CustomFunction function) {
-        verifyDbIsOpen();
-        synchronized (mCustomFunctions) {
-            int ref = native_addCustomFunction(name, numArgs, function);
-            if (ref != 0) {
-                // save a reference to the function for cleanup later
-                mCustomFunctions.add(new Integer(ref));
-            } else {
-                throw new SQLiteException("failed to add custom function " + name);
-            }
-        }
-    }
+        // Create wrapper (also validates arguments).
+        SQLiteCustomFunction wrapper = new SQLiteCustomFunction(name, numArgs, function);
 
-    private void releaseCustomFunctions() {
-        synchronized (mCustomFunctions) {
-            for (int i = 0; i < mCustomFunctions.size(); i++) {
-                Integer function = mCustomFunctions.get(i);
-                native_releaseCustomFunction(function.intValue());
-            }
-            mCustomFunctions.clear();
+        synchronized (mLock) {
+            throwIfNotOpenLocked();
+            mConfigurationLocked.customFunctions.add(wrapper);
+            mConnectionPoolLocked.reconfigure(mConfigurationLocked);
         }
     }
 
-    // list of CustomFunction references so we can clean up when the database closes
-    private final ArrayList<Integer> mCustomFunctions =
-            new ArrayList<Integer>();
-
-    private native int native_addCustomFunction(String name, int numArgs, CustomFunction function);
-    private native void native_releaseCustomFunction(int function);
-
     /**
      * Gets the database version.
      *
@@ -1364,7 +896,7 @@ public class SQLiteDatabase extends SQLiteClosable {
      * {@link SQLiteStatement}s are not synchronized, see the documentation for more details.
      */
     public SQLiteStatement compileStatement(String sql) throws SQLException {
-        verifyDbIsOpen();
+        throwIfNotOpen(); // fail fast
         return new SQLiteStatement(this, sql, null);
     }
 
@@ -1442,7 +974,7 @@ public class SQLiteDatabase extends SQLiteClosable {
             boolean distinct, String table, String[] columns,
             String selection, String[] selectionArgs, String groupBy,
             String having, String orderBy, String limit) {
-        verifyDbIsOpen();
+        throwIfNotOpen(); // fail fast
         String sql = SQLiteQueryBuilder.buildQueryString(
                 distinct, table, columns, selection, groupBy, having, orderBy, limit);
 
@@ -1553,21 +1085,11 @@ public class SQLiteDatabase extends SQLiteClosable {
     public Cursor rawQueryWithFactory(
             CursorFactory cursorFactory, String sql, String[] selectionArgs,
             String editTable) {
-        verifyDbIsOpen();
-        BlockGuard.getThreadPolicy().onReadFromDisk();
+        throwIfNotOpen(); // fail fast
 
-        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;
+        SQLiteCursorDriver driver = new SQLiteDirectCursorDriver(this, sql, editTable);
+        return driver.query(cursorFactory != null ? cursorFactory : mCursorFactory,
+                selectionArgs);
     }
 
     /**
@@ -1716,9 +1238,6 @@ public class SQLiteDatabase extends SQLiteClosable {
         SQLiteStatement statement = new SQLiteStatement(this, sql.toString(), bindArgs);
         try {
             return statement.executeInsert();
-        } catch (SQLiteDatabaseCorruptException e) {
-            onCorruption();
-            throw e;
         } finally {
             statement.close();
         }
@@ -1739,9 +1258,6 @@ public class SQLiteDatabase extends SQLiteClosable {
                 (!TextUtils.isEmpty(whereClause) ? " WHERE " + whereClause : ""), whereArgs);
         try {
             return statement.executeUpdateDelete();
-        } catch (SQLiteDatabaseCorruptException e) {
-            onCorruption();
-            throw e;
         } finally {
             statement.close();
         }
@@ -1808,9 +1324,6 @@ public class SQLiteDatabase extends SQLiteClosable {
         SQLiteStatement statement = new SQLiteStatement(this, sql.toString(), bindArgs);
         try {
             return statement.executeUpdateDelete();
-        } catch (SQLiteDatabaseCorruptException e) {
-            onCorruption();
-            throw e;
         } finally {
             statement.close();
         }
@@ -1891,264 +1404,105 @@ public class SQLiteDatabase extends SQLiteClosable {
 
     private int executeSql(String sql, Object[] bindArgs) throws SQLException {
         if (DatabaseUtils.getSqlStatementType(sql) == DatabaseUtils.STATEMENT_ATTACH) {
-            disableWriteAheadLogging();
-            mHasAttachedDbs = true;
+            boolean disableWal = false;
+            synchronized (mLock) {
+                if (!mHasAttachedDbsLocked) {
+                    mHasAttachedDbsLocked = true;
+                    disableWal = true;
+                }
+            }
+            if (disableWal) {
+                disableWriteAheadLogging();
+            }
         }
+
         SQLiteStatement statement = new SQLiteStatement(this, sql, bindArgs);
         try {
             return statement.executeUpdateDelete();
-        } catch (SQLiteDatabaseCorruptException e) {
-            onCorruption();
-            throw e;
         } finally {
             statement.close();
         }
     }
 
-    @Override
-    protected void finalize() throws Throwable {
-        try {
-            if (isOpen()) {
-                Log.e(TAG, "close() was never explicitly called on database '" +
-                        mPath + "' ", mStackTrace);
-                closeClosable();
-                onAllReferencesReleased();
-                releaseCustomFunctions();
-            }
-        } finally {
-            super.finalize();
-        }
-    }
-
     /**
-     * Private constructor.
+     * Returns true if the database is opened as read only.
      *
-     * @param path The full path to the database
-     * @param factory The factory to use when creating cursors, may be NULL.
-     * @param flags 0 or {@link #NO_LOCALIZED_COLLATORS}.  If the database file already
-     *              exists, mFlags will be updated appropriately.
-     * @param errorHandler The {@link DatabaseErrorHandler} to be used when sqlite reports database
-     * corruption. may be NULL.
-     * @param connectionNum 0 for main database connection handle. 1..N for pooled database
-     * connection handles.
+     * @return True if database is opened as read only.
      */
-    private SQLiteDatabase(String path, CursorFactory factory, int flags,
-            DatabaseErrorHandler errorHandler, short connectionNum) {
-        if (path == null) {
-            throw new IllegalArgumentException("path should not be null");
+    public boolean isReadOnly() {
+        synchronized (mLock) {
+            return isReadOnlyLocked();
         }
-        setMaxSqlCacheSize(DEFAULT_SQL_CACHE_SIZE);
-        mFlags = flags;
-        mPath = path;
-        mStackTrace = new DatabaseObjectNotClosedException().fillInStackTrace();
-        mFactory = factory;
-        mPrograms = new WeakHashMap<SQLiteClosable,Object>();
-        // Set the DatabaseErrorHandler to be used when SQLite reports corruption.
-        // If the caller sets errorHandler = null, then use default errorhandler.
-        mErrorHandler = (errorHandler == null) ? new DefaultDatabaseErrorHandler() : errorHandler;
-        mConnectionNum = connectionNum;
-        /* sqlite soft heap limit http://www.sqlite.org/c3ref/soft_heap_limit64.html
-         * set it to 4 times the default cursor window size.
-         * TODO what is an appropriate value, considering the WAL feature which could burn
-         * a lot of memory with many connections to the database. needs testing to figure out
-         * optimal value for this.
-         */
-        int limit = Resources.getSystem().getInteger(
-                com.android.internal.R.integer.config_cursorWindowSize) * 1024 * 4;
-        native_setSqliteSoftHeapLimit(limit);
+    }
+
+    private boolean isReadOnlyLocked() {
+        return (mConfigurationLocked.openFlags & OPEN_READ_MASK) == OPEN_READONLY;
     }
 
     /**
-     * return whether the DB is opened as read only.
-     * @return true if DB is opened as read only
+     * Returns true if the database is in-memory db.
+     *
+     * @return True if the database is in-memory.
+     * @hide
      */
-    public boolean isReadOnly() {
-        return (mFlags & OPEN_READ_MASK) == OPEN_READONLY;
+    public boolean isInMemoryDatabase() {
+        synchronized (mLock) {
+            return mConfigurationLocked.isInMemoryDb();
+        }
     }
 
     /**
-     * @return true if the DB is currently open (has not been closed)
+     * Returns true if the database is currently open.
+     *
+     * @return True if the database is currently open (has not been closed).
      */
     public boolean isOpen() {
-        return mNativeHandle != 0;
+        synchronized (mLock) {
+            return mConnectionPoolLocked != null;
+        }
     }
 
+    /**
+     * Returns true if the new version code is greater than the current database version.
+     *
+     * @param newVersion The new version code.
+     * @return True if the new version code is greater than the current database version. 
+     */
     public boolean needUpgrade(int newVersion) {
         return newVersion > getVersion();
     }
 
     /**
-     * Getter for the path to the database file.
+     * Gets the path to the database file.
      *
-     * @return the path to our database file.
+     * @return The path to the database file.
      */
     public final String getPath() {
-        return mPath;
-    }
-
-    /* package */ void logTimeStat(String sql, long beginMillis) {
-        if (ENABLE_DB_SAMPLE) {
-            logTimeStat(sql, beginMillis, null);
+        synchronized (mLock) {
+            return mConfigurationLocked.path;
         }
     }
 
-    private void logTimeStat(String sql, long beginMillis, String prefix) {
-        // Sample fast queries in proportion to the time taken.
-        // Quantize the % first, so the logged sampling probability
-        // exactly equals the actual sampling rate for this query.
-
-        int samplePercent;
-        long durationMillis = SystemClock.uptimeMillis() - beginMillis;
-        if (durationMillis == 0 && prefix == GET_LOCK_LOG_PREFIX) {
-            // The common case is locks being uncontended.  Don't log those,
-            // even at 1%, which is our default below.
-            return;
-        }
-        if (sQueryLogTimeInMillis == 0) {
-            sQueryLogTimeInMillis = SystemProperties.getInt("db.db_operation.threshold_ms", 500);
-        }
-        if (durationMillis >= sQueryLogTimeInMillis) {
-            samplePercent = 100;
-        } else {
-            samplePercent = (int) (100 * durationMillis / sQueryLogTimeInMillis) + 1;
-            if (mRandom.nextInt(100) >= samplePercent) return;
-        }
-
-        // Note: the prefix will be "COMMIT;" or "GETLOCK:" when non-null.  We wait to do
-        // it here so we avoid allocating in the common case.
-        if (prefix != null) {
-            sql = prefix + sql;
-        }
-        if (sql.length() > QUERY_LOG_SQL_LENGTH) sql = sql.substring(0, QUERY_LOG_SQL_LENGTH);
-
-        // ActivityThread.currentPackageName() only returns non-null if the
-        // current thread is an application main thread.  This parameter tells
-        // us whether an event loop is blocked, and if so, which app it is.
-        //
-        // Sadly, there's no fast way to determine app name if this is *not* a
-        // main thread, or when we are invoked via Binder (e.g. ContentProvider).
-        // Hopefully the full path to the database will be informative enough.
-
-        String blockingPackage = AppGlobals.getInitialPackage();
-        if (blockingPackage == null) blockingPackage = "";
-
-        EventLog.writeEvent(
-            EVENT_DB_OPERATION,
-            getPathForLogs(),
-            sql,
-            durationMillis,
-            blockingPackage,
-            samplePercent);
-    }
-
-    /**
-     * Removes email addresses from database filenames before they're
-     * logged to the EventLog where otherwise apps could potentially
-     * read them.
-     */
-    private String getPathForLogs() {
-        if (mPathForLogs != null) {
-            return mPathForLogs;
-        }
-        if (mPath == null) {
-            return null;
-        }
-        if (mPath.indexOf('@') == -1) {
-            mPathForLogs = mPath;
-        } else {
-            mPathForLogs = EMAIL_IN_DB_PATTERN.matcher(mPath).replaceAll("XX@YY");
-        }
-        return mPathForLogs;
-    }
-
     /**
      * Sets the locale for this database.  Does nothing if this database has
      * the NO_LOCALIZED_COLLATORS flag set or was opened read only.
+     *
+     * @param locale The new locale.
+     *
      * @throws SQLException if the locale could not be set.  The most common reason
      * for this is that there is no collator available for the locale you requested.
      * In this case the database remains unchanged.
      */
     public void setLocale(Locale locale) {
-        lock();
-        try {
-            native_setLocale(locale.toString(), mFlags);
-        } finally {
-            unlock();
-        }
-    }
-
-    /* package */ void verifyDbIsOpen() {
-        if (!isOpen()) {
-            throw new IllegalStateException("database " + getPath() + " (conn# " +
-                    mConnectionNum + ") already closed");
-        }
-    }
-
-    /* package */ void verifyLockOwner() {
-        verifyDbIsOpen();
-        if (mLockingEnabled && !isDbLockedByCurrentThread()) {
-            throw new IllegalStateException("Don't have database lock!");
-        }
-    }
-
-    /**
-     * Adds the given SQL and its compiled-statement-id-returned-by-sqlite to the
-     * cache of compiledQueries attached to 'this'.
-     * <p>
-     * If there is already a {@link SQLiteCompiledSql} in compiledQueries for the given SQL,
-     * the new {@link SQLiteCompiledSql} object is NOT inserted into the cache (i.e.,the current
-     * mapping is NOT replaced with the new mapping).
-     */
-    /* package */ synchronized void addToCompiledQueries(
-            String sql, SQLiteCompiledSql compiledStatement) {
-        // don't insert the new mapping if a mapping already exists
-        if (mCompiledQueries.get(sql) != null) {
-            return;
+        if (locale == null) {
+            throw new IllegalArgumentException("locale must not be null.");
         }
 
-        int maxCacheSz = (mConnectionNum == 0) ? mCompiledQueries.maxSize() :
-                mParentConnObj.mCompiledQueries.maxSize();
-
-        if (SQLiteDebug.DEBUG_SQL_CACHE) {
-            boolean printWarning = (mConnectionNum == 0)
-                    ? (!mCacheFullWarning && mCompiledQueries.size() == maxCacheSz)
-                    : (!mParentConnObj.mCacheFullWarning &&
-                    mParentConnObj.mCompiledQueries.size() == maxCacheSz);
-            if (printWarning) {
-                /*
-                 * cache size is not enough for this app. log a warning.
-                 * chances are it is NOT using ? for bindargs - or cachesize is too small.
-                 */
-                Log.w(TAG, "Reached MAX size for compiled-sql statement cache for database " +
-                        getPath() + ". Use setMaxSqlCacheSize() to increase cachesize. ");
-                mCacheFullWarning = true;
-                Log.d(TAG, "Here are the SQL statements in Cache of database: " + mPath);
-                for (String s : mCompiledQueries.snapshot().keySet()) {
-                    Log.d(TAG, "Sql statement in Cache: " + s);
-                }
-            }
+        synchronized (mLock) {
+            throwIfNotOpenLocked();
+            mConfigurationLocked.locale = locale;
+            mConnectionPoolLocked.reconfigure(mConfigurationLocked);
         }
-        /* add the given SQLiteCompiledSql compiledStatement to cache.
-         * no need to worry about the cache size - because {@link #mCompiledQueries}
-         * self-limits its size.
-         */
-        mCompiledQueries.put(sql, compiledStatement);
-    }
-
-    /** package-level access for testing purposes */
-    /* package */ synchronized void deallocCachedSqlStatements() {
-        for (SQLiteCompiledSql compiledSql : mCompiledQueries.snapshot().values()) {
-            compiledSql.releaseSqlStatement();
-        }
-        mCompiledQueries.evictAll();
-    }
-
-    /**
-     * From the compiledQueries cache, returns the compiled-statement-id for the given SQL.
-     * Returns null, if not found in the cache.
-     */
-    /* package */ synchronized SQLiteCompiledSql getCompiledStatementForSql(String sql) {
-        return mCompiledQueries.get(sql);
     }
 
     /**
@@ -2162,116 +1516,22 @@ public class SQLiteDatabase extends SQLiteClosable {
      * This method is thread-safe.
      *
      * @param cacheSize the size of the cache. can be (0 to {@link #MAX_SQL_CACHE_SIZE})
-     * @throws IllegalStateException if input cacheSize > {@link #MAX_SQL_CACHE_SIZE} or
-     * the value set with previous setMaxSqlCacheSize() call.
+     * @throws IllegalStateException if input cacheSize > {@link #MAX_SQL_CACHE_SIZE}.
      */
     public void setMaxSqlCacheSize(int cacheSize) {
-        synchronized (this) {
-            LruCache<String, SQLiteCompiledSql> oldCompiledQueries = mCompiledQueries;
-            if (cacheSize > MAX_SQL_CACHE_SIZE || cacheSize < 0) {
-                throw new IllegalStateException(
-                        "expected value between 0 and " + MAX_SQL_CACHE_SIZE);
-            } else if (oldCompiledQueries != null && cacheSize < oldCompiledQueries.maxSize()) {
-                throw new IllegalStateException("cannot set cacheSize to a value less than the "
-                        + "value set with previous setMaxSqlCacheSize() call.");
-            }
-            mCompiledQueries = new LruCache<String, SQLiteCompiledSql>(cacheSize) {
-                @Override
-                protected void entryRemoved(boolean evicted, String key, SQLiteCompiledSql oldValue,
-                        SQLiteCompiledSql newValue) {
-                    verifyLockOwner();
-                    oldValue.releaseIfNotInUse();
-                }
-            };
-            if (oldCompiledQueries != null) {
-                for (Map.Entry<String, SQLiteCompiledSql> entry
-                        : oldCompiledQueries.snapshot().entrySet()) {
-                    mCompiledQueries.put(entry.getKey(), entry.getValue());
-                }
-            }
-        }
-    }
-
-    /* package */ synchronized boolean isInStatementCache(String sql) {
-        return mCompiledQueries.get(sql) != null;
-    }
-
-    /* package */ synchronized void releaseCompiledSqlObj(
-            String sql, SQLiteCompiledSql compiledSql) {
-        if (mCompiledQueries.get(sql) == compiledSql) {
-            // it is in cache - reset its inUse flag
-            compiledSql.release();
-        } else {
-            // it is NOT in cache. finalize it.
-            compiledSql.releaseSqlStatement();
-        }
-    }
-
-    private synchronized int getCacheHitNum() {
-        return mCompiledQueries.hitCount();
-    }
-
-    private synchronized int getCacheMissNum() {
-        return mCompiledQueries.missCount();
-    }
-
-    private synchronized int getCachesize() {
-        return mCompiledQueries.size();
-    }
-
-    /* package */ void finalizeStatementLater(int id) {
-        if (!isOpen()) {
-            // database already closed. this statement will already have been finalized.
-            return;
-        }
-        synchronized(mClosedStatementIds) {
-            if (mClosedStatementIds.contains(id)) {
-                // this statement id is already queued up for finalization.
-                return;
-            }
-            mClosedStatementIds.add(id);
-        }
-    }
-
-    /* package */ boolean isInQueueOfStatementsToBeFinalized(int id) {
-        if (!isOpen()) {
-            // database already closed. this statement will already have been finalized.
-            // return true so that the caller doesn't have to worry about finalizing this statement.
-            return true;
-        }
-        synchronized(mClosedStatementIds) {
-            return mClosedStatementIds.contains(id);
+        if (cacheSize > MAX_SQL_CACHE_SIZE || cacheSize < 0) {
+            throw new IllegalStateException(
+                    "expected value between 0 and " + MAX_SQL_CACHE_SIZE);
         }
-    }
 
-    /* package */ void closePendingStatements() {
-        if (!isOpen()) {
-            // since this database is already closed, no need to finalize anything.
-            mClosedStatementIds.clear();
-            return;
-        }
-        verifyLockOwner();
-        /* to minimize synchronization on mClosedStatementIds, make a copy of the list */
-        ArrayList<Integer> list = new ArrayList<Integer>(mClosedStatementIds.size());
-        synchronized(mClosedStatementIds) {
-            list.addAll(mClosedStatementIds);
-            mClosedStatementIds.clear();
-        }
-        // finalize all the statements from the copied list
-        int size = list.size();
-        for (int i = 0; i < size; i++) {
-            native_finalize(list.get(i));
+        synchronized (mLock) {
+            throwIfNotOpenLocked();
+            mConfigurationLocked.maxSqlCacheSize = cacheSize;
+            mConnectionPoolLocked.reconfigure(mConfigurationLocked);
         }
     }
 
     /**
-     * for testing only
-     */
-    /* package */ ArrayList<Integer> getQueuedUpStmtList() {
-        return mClosedStatementIds;
-    }
-
-    /**
      * This method enables parallel execution of queries from multiple threads on the same database.
      * It does this by opening multiple handles to the database and using a different
      * database handle for each query.
@@ -2314,37 +1574,43 @@ public class SQLiteDatabase extends SQLiteClosable {
      * @return true if write-ahead-logging is set. false otherwise
      */
     public boolean enableWriteAheadLogging() {
-        // make sure the database is not READONLY. WAL doesn't make sense for readonly-databases.
-        if (isReadOnly()) {
-            return false;
-        }
-        // acquire lock - no that no other thread is enabling WAL at the same time
-        lock();
-        try {
-            if (mConnectionPool != null) {
-                // already enabled
+        synchronized (mLock) {
+            throwIfNotOpenLocked();
+
+            if (mIsWALEnabledLocked) {
                 return true;
             }
-            if (mPath.equalsIgnoreCase(MEMORY_DB_PATH)) {
+
+            if (isReadOnlyLocked()) {
+                // WAL doesn't make sense for readonly-databases.
+                // TODO: True, but connection pooling does still make sense...
+                return false;
+            }
+
+            if (mConfigurationLocked.isInMemoryDb()) {
                 Log.i(TAG, "can't enable WAL for memory databases.");
                 return false;
             }
 
             // make sure this database has NO attached databases because sqlite's write-ahead-logging
             // doesn't work for databases with attached databases
-            if (mHasAttachedDbs) {
+            if (mHasAttachedDbsLocked) {
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
-                    Log.d(TAG,
-                            "this database: " + mPath + " has attached databases. can't  enable WAL.");
+                    Log.d(TAG, "this database: " + mConfigurationLocked.label
+                            + " has attached databases. can't  enable WAL.");
                 }
                 return false;
             }
-            mConnectionPool = new DatabaseConnectionPool(this);
-            setJournalMode(mPath, "WAL");
-            return true;
-        } finally {
-            unlock();
+
+            mIsWALEnabledLocked = true;
+            mConfigurationLocked.maxConnectionPoolSize = Math.max(2,
+                    Resources.getSystem().getInteger(
+                            com.android.internal.R.integer.db_connection_pool_size));
+            mConnectionPoolLocked.reconfigure(mConfigurationLocked);
         }
+
+        setJournalMode("WAL");
+        return true;
     }
 
     /**
@@ -2352,176 +1618,66 @@ public class SQLiteDatabase extends SQLiteClosable {
      * @hide
      */
     public void disableWriteAheadLogging() {
-        // grab database lock so that writeAheadLogging is not disabled from 2 different threads
-        // at the same time
-        lock();
-        try {
-            if (mConnectionPool == null) {
-                return; // already disabled
-            }
-            mConnectionPool.close();
-            setJournalMode(mPath, "TRUNCATE");
-            mConnectionPool = null;
-        } finally {
-            unlock();
-        }
-    }
+        synchronized (mLock) {
+            throwIfNotOpenLocked();
 
-    /* package */ SQLiteDatabase getDatabaseHandle(String sql) {
-        if (isPooledConnection()) {
-            // this is a pooled database connection
-            // use it if it is open AND if I am not currently part of a transaction
-            if (isOpen() && !amIInTransaction()) {
-                // TODO: use another connection from the pool
-                // if this connection is currently in use by some other thread
-                // AND if there are free connections in the pool
-                return this;
-            } else {
-                // the pooled connection is not open! could have been closed either due
-                // to corruption on this or some other connection to the database
-                // OR, maybe the connection pool is disabled after this connection has been
-                // allocated to me. try to get some other pooled or main database connection
-                return getParentDbConnObj().getDbConnection(sql);
+            if (!mIsWALEnabledLocked) {
+                return;
             }
-        } else {
-            // this is NOT a pooled connection. can we get one?
-            return getDbConnection(sql);
-        }
-    }
 
-    /* package */ SQLiteDatabase createPoolConnection(short connectionNum) {
-        SQLiteDatabase db = openDatabase(mPath, mFactory, mFlags, mErrorHandler, connectionNum);
-        db.mParentConnObj = this;
-        return db;
-    }
-
-    private synchronized SQLiteDatabase getParentDbConnObj() {
-        return mParentConnObj;
-    }
+            mIsWALEnabledLocked = false;
+            mConfigurationLocked.maxConnectionPoolSize = 1;
+            mConnectionPoolLocked.reconfigure(mConfigurationLocked);
+        }
 
-    private boolean isPooledConnection() {
-        return this.mConnectionNum > 0;
+        setJournalMode("TRUNCATE");
     }
 
-    /* package */ SQLiteDatabase getDbConnection(String sql) {
-        verifyDbIsOpen();
-        // this method should always be called with main database connection handle.
-        // the only time when it is called with pooled database connection handle is
-        // corruption occurs while trying to open a pooled database connection handle.
-        // in that case, simply return 'this' handle
-        if (isPooledConnection()) {
-            return this;
+    /**
+     * Collect statistics about all open databases in the current process.
+     * Used by bug report.
+     */
+    static ArrayList<DbStats> getDbStats() {
+        ArrayList<DbStats> dbStatsList = new ArrayList<DbStats>();
+        for (SQLiteDatabase db : getActiveDatabases()) {
+            db.collectDbStats(dbStatsList);
         }
+        return dbStatsList;
+    }
 
-        // use the current connection handle if
-        // 1. if the caller is part of the ongoing transaction, if any
-        // 2. OR, if there is NO connection handle pool setup
-        if (amIInTransaction() || mConnectionPool == null) {
-            return this;
-        } else {
-            // get a connection handle from the pool
-            if (Log.isLoggable(TAG, Log.DEBUG)) {
-                assert mConnectionPool != null;
-                Log.i(TAG, mConnectionPool.toString());
+    private void collectDbStats(ArrayList<DbStats> dbStatsList) {
+        synchronized (mLock) {
+            if (mConnectionPoolLocked != null) {
+                mConnectionPoolLocked.collectDbStats(dbStatsList);
             }
-            return mConnectionPool.get(sql);
         }
     }
 
-    private void releaseDbConnection(SQLiteDatabase db) {
-        // ignore this release call if
-        // 1. the database is closed
-        // 2. OR, if db is NOT a pooled connection handle
-        // 3. OR, if the database being released is same as 'this' (this condition means
-        //     that we should always be releasing a pooled connection handle by calling this method
-        //     from the 'main' connection handle
-        if (!isOpen() || !db.isPooledConnection() || (db == this)) {
-            return;
+    private static ArrayList<SQLiteDatabase> getActiveDatabases() {
+        ArrayList<SQLiteDatabase> databases = new ArrayList<SQLiteDatabase>();
+        synchronized (sActiveDatabases) {
+            databases.addAll(sActiveDatabases.keySet());
         }
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-            assert isPooledConnection();
-            assert mConnectionPool != null;
-            Log.d(TAG, "releaseDbConnection threadid = " + Thread.currentThread().getId() +
-                    ", releasing # " + db.mConnectionNum + ", " + getPath());
-        }
-        mConnectionPool.release(db);
+        return databases;
     }
 
     /**
-     * this method is used to collect data about ALL open databases in the current process.
-     * bugreport is a user of this data.
+     * Dump detailed information about all open databases in the current process.
+     * Used by bug report.
      */
-    /* package */ static ArrayList<DbStats> getDbStats() {
-        ArrayList<DbStats> dbStatsList = new ArrayList<DbStats>();
-        // make a local copy of mActiveDatabases - so that this method is not competing
-        // for synchronization lock on mActiveDatabases
-        ArrayList<WeakReference<SQLiteDatabase>> tempList;
-        synchronized(mActiveDatabases) {
-            tempList = (ArrayList<WeakReference<SQLiteDatabase>>)mActiveDatabases.clone();
+    static void dumpAll(Printer printer) {
+        for (SQLiteDatabase db : getActiveDatabases()) {
+            db.dump(printer);
         }
-        for (WeakReference<SQLiteDatabase> w : tempList) {
-            SQLiteDatabase db = w.get();
-            if (db == null || !db.isOpen()) {
-                continue;
-            }
+    }
 
-            try {
-                // get SQLITE_DBSTATUS_LOOKASIDE_USED for the db
-                int lookasideUsed = db.native_getDbLookaside();
-
-                // get the lastnode of the dbname
-                String path = db.getPath();
-                int indx = path.lastIndexOf("/");
-                String lastnode = path.substring((indx != -1) ? ++indx : 0);
-
-                // get list of attached dbs and for each db, get its size and pagesize
-                List<Pair<String, String>> attachedDbs = db.getAttachedDbs();
-                if (attachedDbs == null) {
-                    continue;
-                }
-                for (int i = 0; i < attachedDbs.size(); i++) {
-                    Pair<String, String> p = attachedDbs.get(i);
-                    long pageCount = DatabaseUtils.longForQuery(db, "PRAGMA " + p.first
-                            + ".page_count;", null);
-
-                    // first entry in the attached db list is always the main database
-                    // don't worry about prefixing the dbname with "main"
-                    String dbName;
-                    if (i == 0) {
-                        dbName = lastnode;
-                    } else {
-                        // lookaside is only relevant for the main db
-                        lookasideUsed = 0;
-                        dbName = "  (attached) " + p.first;
-                        // if the attached db has a path, attach the lastnode from the path to above
-                        if (p.second.trim().length() > 0) {
-                            int idx = p.second.lastIndexOf("/");
-                            dbName += " : " + p.second.substring((idx != -1) ? ++idx : 0);
-                        }
-                    }
-                    if (pageCount > 0) {
-                        dbStatsList.add(new DbStats(dbName, pageCount, db.getPageSize(),
-                                lookasideUsed, db.getCacheHitNum(), db.getCacheMissNum(),
-                                db.getCachesize()));
-                    }
-                }
-                // if there are pooled connections, return the cache stats for them also.
-                // while we are trying to query the pooled connections for stats, some other thread
-                // could be disabling conneciton pool. so, grab a reference to the connection pool.
-                DatabaseConnectionPool connPool = db.mConnectionPool;
-                if (connPool != null) {
-                    for (SQLiteDatabase pDb : connPool.getConnectionList()) {
-                        dbStatsList.add(new DbStats("(pooled # " + pDb.mConnectionNum + ") "
-                                + lastnode, 0, 0, 0, pDb.getCacheHitNum(),
-                                pDb.getCacheMissNum(), pDb.getCachesize()));
-                    }
-                }
-            } catch (SQLiteException e) {
-                // ignore. we don't care about exceptions when we are taking adb
-                // bugreport!
+    private void dump(Printer printer) {
+        synchronized (mLock) {
+            if (mConnectionPoolLocked != null) {
+                printer.println("");
+                mConnectionPoolLocked.dump(printer);
             }
         }
-        return dbStatsList;
     }
 
     /**
@@ -2532,23 +1688,27 @@ public class SQLiteDatabase extends SQLiteClosable {
      * is not open.
      */
     public List<Pair<String, String>> getAttachedDbs() {
-        if (!isOpen()) {
-            return null;
-        }
         ArrayList<Pair<String, String>> attachedDbs = new ArrayList<Pair<String, String>>();
-        if (!mHasAttachedDbs) {
-            // No attached databases.
-            // There is a small window where attached databases exist but this flag is not set yet.
-            // This can occur when this thread is in a race condition with another thread
-            // that is executing the SQL statement: "attach database <blah> as <foo>"
-            // If this thread is NOT ok with such a race condition (and thus possibly not receive
-            // the entire list of attached databases), then the caller should ensure that no thread
-            // is executing any SQL statements while a thread is calling this method.
-            // Typically, this method is called when 'adb bugreport' is done or the caller wants to
-            // collect stats on the database and all its attached databases.
-            attachedDbs.add(new Pair<String, String>("main", mPath));
-            return attachedDbs;
+        synchronized (mLock) {
+            if (mConnectionPoolLocked == null) {
+                return null; // not open
+            }
+
+            if (!mHasAttachedDbsLocked) {
+                // No attached databases.
+                // There is a small window where attached databases exist but this flag is not
+                // set yet.  This can occur when this thread is in a race condition with another
+                // thread that is executing the SQL statement: "attach database <blah> as <foo>"
+                // If this thread is NOT ok with such a race condition (and thus possibly not
+                // receivethe entire list of attached databases), then the caller should ensure
+                // that no thread is executing any SQL statements while a thread is calling this
+                // method.  Typically, this method is called when 'adb bugreport' is done or the
+                // caller wants to collect stats on the database and all its attached databases.
+                attachedDbs.add(new Pair<String, String>("main", mConfigurationLocked.path));
+                return attachedDbs;
+            }
         }
+
         // has attached databases. query sqlite to get the list of attached databases.
         Cursor c = null;
         try {
@@ -2583,7 +1743,8 @@ public class SQLiteDatabase extends SQLiteClosable {
      * false otherwise.
      */
     public boolean isDatabaseIntegrityOk() {
-        verifyDbIsOpen();
+        throwIfNotOpen(); // fail fast
+
         List<Pair<String, String>> attachedDbs = null;
         try {
             attachedDbs = getAttachedDbs();
@@ -2594,8 +1755,9 @@ public class SQLiteDatabase extends SQLiteClosable {
         } catch (SQLiteException e) {
             // can't get attachedDb list. do integrity check on the main database
             attachedDbs = new ArrayList<Pair<String, String>>();
-            attachedDbs.add(new Pair<String, String>("main", this.mPath));
+            attachedDbs.add(new Pair<String, String>("main", getPath()));
         }
+
         for (int i = 0; i < attachedDbs.size(); i++) {
             Pair<String, String> p = attachedDbs.get(i);
             SQLiteStatement prog = null;
@@ -2615,59 +1777,64 @@ public class SQLiteDatabase extends SQLiteClosable {
     }
 
     /**
-     * Native call to open the database.
+     * Prevent other threads from using the database's primary connection.
      *
-     * @param path The full path to the database
-     */
-    private native void dbopen(String path, int flags);
-
-    /**
-     * Native call to setup tracing of all SQL statements
+     * This method is only used by {@link SQLiteOpenHelper} when transitioning from
+     * a readable to a writable database.  It should not be used in any other way.
      *
-     * @param path the full path to the database
-     * @param connectionNum connection number: 0 - N, where the main database
-     *            connection handle is numbered 0 and the connection handles in the connection
-     *            pool are numbered 1..N.
+     * @see #unlockPrimaryConnection()
      */
-    private native void enableSqlTracing(String path, short connectionNum);
+    void lockPrimaryConnection() {
+        getThreadSession().beginTransaction(SQLiteSession.TRANSACTION_MODE_DEFERRED,
+                null, SQLiteConnectionPool.CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY);
+    }
 
     /**
-     * Native call to setup profiling of all SQL statements.
-     * currently, sqlite's profiling = printing of execution-time
-     * (wall-clock time) of each of the SQL statements, as they
-     * are executed.
+     * Allow other threads to use the database's primary connection.
      *
-     * @param path the full path to the database
-     * @param connectionNum connection number: 0 - N, where the main database
-     *            connection handle is numbered 0 and the connection handles in the connection
-     *            pool are numbered 1..N.
+     * @see #lockPrimaryConnection()
      */
-    private native void enableSqlProfiling(String path, short connectionNum);
+    void unlockPrimaryConnection() {
+        getThreadSession().endTransaction();
+    }
 
-    /**
-     * Native call to set the locale.  {@link #lock} must be held when calling
-     * this method.
-     * @throws SQLException
-     */
-    private native void native_setLocale(String loc, int flags);
+    @Override
+    public String toString() {
+        return "SQLiteDatabase: " + getPath();
+    }
 
-    /**
-     * return the SQLITE_DBSTATUS_LOOKASIDE_USED documented here
-     * http://www.sqlite.org/c3ref/c_dbstatus_lookaside_used.html
-     * @return int value of SQLITE_DBSTATUS_LOOKASIDE_USED
-     */
-    private native int native_getDbLookaside();
+    private void throwIfNotOpen() {
+        synchronized (mConnectionPoolLocked) {
+            throwIfNotOpenLocked();
+        }
+    }
+
+    private void throwIfNotOpenLocked() {
+        if (mConnectionPoolLocked == null) {
+            throw new IllegalStateException("The database '" + mConfigurationLocked.label
+                    + "' is not open.");
+        }
+    }
 
     /**
-     * finalizes the given statement id.
-     *
-     * @param statementId statement to be finzlied by sqlite
+     * Used to allow returning sub-classes of {@link Cursor} when calling query.
      */
-    private final native void native_finalize(int statementId);
+    public interface CursorFactory {
+        /**
+         * See {@link SQLiteCursor#SQLiteCursor(SQLiteCursorDriver, String, SQLiteQuery)}.
+         */
+        public Cursor newCursor(SQLiteDatabase db,
+                SQLiteCursorDriver masterQuery, String editTable,
+                SQLiteQuery query);
+    }
 
     /**
-     * set sqlite soft heap limit
-     * http://www.sqlite.org/c3ref/soft_heap_limit64.html
+     * A callback interface for a custom sqlite3 function.
+     * This can be used to create a function that can be called from
+     * sqlite3 database triggers.
+     * @hide
      */
-    private native void native_setSqliteSoftHeapLimit(int softHeapLimit);
+    public interface CustomFunction {
+        public void callback(String[] args);
+    }
 }
diff --git a/core/java/android/database/sqlite/SQLiteDatabaseConfiguration.java b/core/java/android/database/sqlite/SQLiteDatabaseConfiguration.java
new file mode 100644
index 0000000..bc79ad3
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteDatabaseConfiguration.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+import java.util.ArrayList;
+import java.util.Locale;
+import java.util.regex.Pattern;
+
+/**
+ * Describes how to configure a database.
+ * <p>
+ * The purpose of this object is to keep track of all of the little
+ * configuration settings that are applied to a database after it
+ * is opened so that they can be applied to all connections in the
+ * connection pool uniformly.
+ * </p><p>
+ * Each connection maintains its own copy of this object so it can
+ * keep track of which settings have already been applied.
+ * </p>
+ *
+ * @hide
+ */
+public final class SQLiteDatabaseConfiguration {
+    // The pattern we use to strip email addresses from database paths
+    // when constructing a label to use in log messages.
+    private static final Pattern EMAIL_IN_DB_PATTERN =
+            Pattern.compile("[\\w\\.\\-]+@[\\w\\.\\-]+");
+
+    /**
+     * Special path used by in-memory databases.
+     */
+    public static final String MEMORY_DB_PATH = ":memory:";
+
+    /**
+     * The database path.
+     */
+    public final String path;
+
+    /**
+     * The flags used to open the database.
+     */
+    public final int openFlags;
+
+    /**
+     * The label to use to describe the database when it appears in logs.
+     * This is derived from the path but is stripped to remove PII.
+     */
+    public final String label;
+
+    /**
+     * The maximum number of connections to retain in the connection pool.
+     * Must be at least 1.
+     *
+     * Default is 1.
+     */
+    public int maxConnectionPoolSize;
+
+    /**
+     * The maximum size of the prepared statement cache for each database connection.
+     * Must be non-negative.
+     *
+     * Default is 25.
+     */
+    public int maxSqlCacheSize;
+
+    /**
+     * The database locale.
+     *
+     * Default is the value returned by {@link Locale#getDefault()}.
+     */
+    public Locale locale;
+
+    /**
+     * The custom functions to register.
+     */
+    public final ArrayList<SQLiteCustomFunction> customFunctions =
+            new ArrayList<SQLiteCustomFunction>();
+
+    /**
+     * Creates a database configuration with the required parameters for opening a
+     * database and default values for all other parameters.
+     *
+     * @param path The database path.
+     * @param openFlags Open flags for the database, such as {@link SQLiteDatabase#OPEN_READWRITE}.
+     */
+    public SQLiteDatabaseConfiguration(String path, int openFlags) {
+        if (path == null) {
+            throw new IllegalArgumentException("path must not be null.");
+        }
+
+        this.path = path;
+        this.openFlags = openFlags;
+        label = stripPathForLogs(path);
+
+        // Set default values for optional parameters.
+        maxConnectionPoolSize = 1;
+        maxSqlCacheSize = 25;
+        locale = Locale.getDefault();
+    }
+
+    /**
+     * Creates a database configuration as a copy of another configuration.
+     *
+     * @param other The other configuration.
+     */
+    public SQLiteDatabaseConfiguration(SQLiteDatabaseConfiguration other) {
+        if (other == null) {
+            throw new IllegalArgumentException("other must not be null.");
+        }
+
+        this.path = other.path;
+        this.openFlags = other.openFlags;
+        this.label = other.label;
+        updateParametersFrom(other);
+    }
+
+    /**
+     * Updates the non-immutable parameters of this configuration object
+     * from the other configuration object.
+     *
+     * @param other The object from which to copy the parameters.
+     */
+    public void updateParametersFrom(SQLiteDatabaseConfiguration other) {
+        if (other == null) {
+            throw new IllegalArgumentException("other must not be null.");
+        }
+        if (!path.equals(other.path) || openFlags != other.openFlags) {
+            throw new IllegalArgumentException("other configuration must refer to "
+                    + "the same database.");
+        }
+
+        maxConnectionPoolSize = other.maxConnectionPoolSize;
+        maxSqlCacheSize = other.maxSqlCacheSize;
+        locale = other.locale;
+        customFunctions.clear();
+        customFunctions.addAll(other.customFunctions);
+    }
+
+    /**
+     * Returns true if the database is in-memory.
+     * @return True if the database is in-memory.
+     */
+    public boolean isInMemoryDb() {
+        return path.equalsIgnoreCase(MEMORY_DB_PATH);
+    }
+
+    private static String stripPathForLogs(String path) {
+        if (path.indexOf('@') == -1) {
+            return path;
+        }
+        return EMAIL_IN_DB_PATTERN.matcher(path).replaceAll("XX@YY");
+    }
+}
diff --git a/core/java/android/database/sqlite/SQLiteDebug.java b/core/java/android/database/sqlite/SQLiteDebug.java
index 029bb4a..d87c3e4 100644
--- a/core/java/android/database/sqlite/SQLiteDebug.java
+++ b/core/java/android/database/sqlite/SQLiteDebug.java
@@ -30,6 +30,12 @@ import android.util.Printer;
  */
 public final class SQLiteDebug {
     /**
+     * Controls the printing of informational SQL log messages.
+     */
+    public static final boolean DEBUG_SQL_LOG =
+            Log.isLoggable("SQLiteLog", Log.VERBOSE);
+
+    /**
      * Controls the printing of SQL statements as they are executed.
      */
     public static final boolean DEBUG_SQL_STATEMENTS =
@@ -186,6 +192,7 @@ public final class SQLiteDebug {
      * @param printer The printer for dumping database state.
      */
     public static void dump(Printer printer, String[] args) {
+        SQLiteDatabase.dumpAll(printer);
     }
 
     /**
diff --git a/core/java/android/database/sqlite/SQLiteDirectCursorDriver.java b/core/java/android/database/sqlite/SQLiteDirectCursorDriver.java
index a5e762e..52fd1d2 100644
--- a/core/java/android/database/sqlite/SQLiteDirectCursorDriver.java
+++ b/core/java/android/database/sqlite/SQLiteDirectCursorDriver.java
@@ -25,10 +25,9 @@ import android.database.sqlite.SQLiteDatabase.CursorFactory;
  * @hide
  */
 public class SQLiteDirectCursorDriver implements SQLiteCursorDriver {
-    private String mEditTable; 
-    private SQLiteDatabase mDatabase;
-    private Cursor mCursor;
-    private String mSql;
+    private final SQLiteDatabase mDatabase;
+    private final String mEditTable; 
+    private final String mSql;
     private SQLiteQuery mQuery;
 
     public SQLiteDirectCursorDriver(SQLiteDatabase db, String sql, String editTable) {
@@ -38,33 +37,27 @@ public class SQLiteDirectCursorDriver implements SQLiteCursorDriver {
     }
 
     public Cursor query(CursorFactory factory, String[] selectionArgs) {
-        // Compile the query
-        SQLiteQuery query = null;
-
+        final SQLiteQuery query = new SQLiteQuery(mDatabase, mSql);
+        final Cursor cursor;
         try {
-            mDatabase.lock(mSql);
-            mDatabase.closePendingStatements();
-            query = new SQLiteQuery(mDatabase, mSql, 0, selectionArgs);
+            query.bindAllArgsAsStrings(selectionArgs);
 
-            // Create the cursor
             if (factory == null) {
-                mCursor = new SQLiteCursor(this, mEditTable, query);
+                cursor = new SQLiteCursor(this, mEditTable, query);
             } else {
-                mCursor = factory.newCursor(mDatabase, this, mEditTable, query);
+                cursor = factory.newCursor(mDatabase, this, mEditTable, query);
             }
-
-            mQuery = query;
-            query = null;
-            return mCursor;
-        } finally {
-            // Make sure this object is cleaned up if something happens
-            if (query != null) query.close();
-            mDatabase.unlock();
+        } catch (RuntimeException ex) {
+            query.close();
+            throw ex;
         }
+
+        mQuery = query;
+        return cursor;
     }
 
     public void cursorClosed() {
-        mCursor = null;
+        // Do nothing
     }
 
     public void setBindArguments(String[] bindArgs) {
diff --git a/core/java/android/database/sqlite/SQLiteGlobal.java b/core/java/android/database/sqlite/SQLiteGlobal.java
new file mode 100644
index 0000000..5e129be
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteGlobal.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+import android.os.StatFs;
+
+/**
+ * Provides access to SQLite functions that affect all database connection,
+ * such as memory management.
+ *
+ * @hide
+ */
+public final class SQLiteGlobal {
+    private static final String TAG = "SQLiteGlobal";
+
+    private static final Object sLock = new Object();
+    private static boolean sInitialized;
+    private static int sSoftHeapLimit;
+    private static int sDefaultPageSize;
+
+    private static native void nativeConfig(boolean verboseLog, int softHeapLimit);
+    private static native int nativeReleaseMemory(int bytesToFree);
+
+    private SQLiteGlobal() {
+    }
+
+    /**
+     * Initializes global SQLite settings the first time it is called.
+     * Should be called before opening the first (or any) database.
+     * Does nothing on repeated subsequent calls.
+     */
+    public static void initializeOnce() {
+        synchronized (sLock) {
+            if (!sInitialized) {
+                sInitialized = true;
+
+                // Limit to 8MB for now.  This is 4 times the maximum cursor window
+                // size, as has been used by the original code in SQLiteDatabase for
+                // a long time.
+                // TODO: We really do need to test whether this helps or hurts us.
+                sSoftHeapLimit = 8 * 1024 * 1024;
+
+                // Configure SQLite.
+                nativeConfig(SQLiteDebug.DEBUG_SQL_LOG, sSoftHeapLimit);
+            }
+        }
+    }
+
+    /**
+     * Attempts to release memory by pruning the SQLite page cache and other
+     * internal data structures.
+     *
+     * @return The number of bytes that were freed.
+     */
+    public static int releaseMemory() {
+        synchronized (sLock) {
+            if (!sInitialized) {
+                return 0;
+            }
+            return nativeReleaseMemory(sSoftHeapLimit);
+        }
+    }
+
+    /**
+     * Gets the default page size to use when creating a database.
+     */
+    public static int getDefaultPageSize() {
+        synchronized (sLock) {
+            if (sDefaultPageSize == 0) {
+                sDefaultPageSize = new StatFs("/data").getBlockSize();
+            }
+            return sDefaultPageSize;
+        }
+    }
+}
diff --git a/core/java/android/database/sqlite/SQLiteOpenHelper.java b/core/java/android/database/sqlite/SQLiteOpenHelper.java
index 56cf948..31da7e4 100644
--- a/core/java/android/database/sqlite/SQLiteOpenHelper.java
+++ b/core/java/android/database/sqlite/SQLiteOpenHelper.java
@@ -143,12 +143,14 @@ public abstract class SQLiteOpenHelper {
         // 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.
+        // fail waiting for the file lock.  To prevent that, we acquire a lock
+        // on the read-only database, which shuts out other users.
 
         boolean success = false;
         SQLiteDatabase db = null;
-        if (mDatabase != null) mDatabase.lock();
+        if (mDatabase != null) {
+            mDatabase.lockPrimaryConnection();
+        }
         try {
             mIsInitializing = true;
             if (mName == null) {
@@ -185,11 +187,13 @@ public abstract class SQLiteOpenHelper {
             if (success) {
                 if (mDatabase != null) {
                     try { mDatabase.close(); } catch (Exception e) { }
-                    mDatabase.unlock();
+                    mDatabase.unlockPrimaryConnection();
                 }
                 mDatabase = db;
             } else {
-                if (mDatabase != null) mDatabase.unlock();
+                if (mDatabase != null) {
+                    mDatabase.unlockPrimaryConnection();
+                }
                 if (db != null) db.close();
             }
         }
diff --git a/core/java/android/database/sqlite/SQLiteProgram.java b/core/java/android/database/sqlite/SQLiteProgram.java
index 2bbc6d7..8194458 100644
--- a/core/java/android/database/sqlite/SQLiteProgram.java
+++ b/core/java/android/database/sqlite/SQLiteProgram.java
@@ -17,225 +17,104 @@
 package android.database.sqlite;
 
 import android.database.DatabaseUtils;
-import android.database.Cursor;
 
-import java.util.HashMap;
+import java.util.Arrays;
 
 /**
  * A base class for compiled SQLite programs.
- *<p>
- * SQLiteProgram is NOT internally synchronized so code using a SQLiteProgram from multiple
- * threads should perform its own synchronization when using the SQLiteProgram.
+ * <p>
+ * This class is not thread-safe.
+ * </p>
  */
 public abstract class SQLiteProgram extends SQLiteClosable {
+    private static final String[] EMPTY_STRING_ARRAY = new String[0];
 
-    private static final String TAG = "SQLiteProgram";
+    private final SQLiteDatabase mDatabase;
+    private final String mSql;
+    private final boolean mReadOnly;
+    private final String[] mColumnNames;
+    private final int mNumParameters;
+    private final Object[] mBindArgs;
 
-    /** The database this program is compiled against.
-     * @hide
-     */
-    protected SQLiteDatabase mDatabase;
-
-    /** The SQL used to create this query */
-    /* package */ final String mSql;
-
-    /**
-     * Native linkage, do not modify. This comes from the database and should not be modified
-     * in here or in the native code.
-     * @hide
-     */
-    protected int nHandle;
-
-    /**
-     * the SQLiteCompiledSql object for the given sql statement.
-     */
-    /* package */ SQLiteCompiledSql mCompiledSql;
-
-    /**
-     * SQLiteCompiledSql statement id is populated with the corresponding object from the above
-     * member. This member is used by the native_bind_* methods
-     * @hide
-     */
-    protected int nStatement;
-
-    /**
-     * In the case of {@link SQLiteStatement}, this member stores the bindargs passed
-     * to the following methods, instead of actually doing the binding.
-     * <ul>
-     *   <li>{@link #bindBlob(int, byte[])}</li>
-     *   <li>{@link #bindDouble(int, double)}</li>
-     *   <li>{@link #bindLong(int, long)}</li>
-     *   <li>{@link #bindNull(int)}</li>
-     *   <li>{@link #bindString(int, String)}</li>
-     * </ul>
-     * <p>
-     * Each entry in the array is a Pair of
-     * <ol>
-     *   <li>bind arg position number</li>
-     *   <li>the value to be bound to the bindarg</li>
-     * </ol>
-     * <p>
-     * It is lazily initialized in the above bind methods
-     * and it is cleared in {@link #clearBindings()} method.
-     * <p>
-     * It is protected (in multi-threaded environment) by {@link SQLiteProgram}.this
-     */
-    /* package */ HashMap<Integer, Object> mBindArgs = null;
-    /* package */ final int mStatementType;
-    /* package */ static final int STATEMENT_CACHEABLE = 16;
-    /* package */ static final int STATEMENT_DONT_PREPARE = 32;
-    /* package */ static final int STATEMENT_USE_POOLED_CONN = 64;
-    /* package */ static final int STATEMENT_TYPE_MASK = 0x0f;
-
-    /* package */ SQLiteProgram(SQLiteDatabase db, String sql) {
-        this(db, sql, null, true);
-    }
-
-    /* package */ SQLiteProgram(SQLiteDatabase db, String sql, Object[] bindArgs,
-            boolean compileFlag) {
+    SQLiteProgram(SQLiteDatabase db, String sql, Object[] bindArgs) {
+        mDatabase = db;
         mSql = sql.trim();
+
         int n = DatabaseUtils.getSqlStatementType(mSql);
         switch (n) {
-            case DatabaseUtils.STATEMENT_UPDATE:
-                mStatementType = n | STATEMENT_CACHEABLE;
-                break;
-            case DatabaseUtils.STATEMENT_SELECT:
-                mStatementType = n | STATEMENT_CACHEABLE | STATEMENT_USE_POOLED_CONN;
-                break;
             case DatabaseUtils.STATEMENT_BEGIN:
             case DatabaseUtils.STATEMENT_COMMIT:
             case DatabaseUtils.STATEMENT_ABORT:
-                mStatementType = n | STATEMENT_DONT_PREPARE;
+                mReadOnly = false;
+                mColumnNames = EMPTY_STRING_ARRAY;
+                mNumParameters = 0;
                 break;
+
             default:
-                mStatementType = n;
-        }
-        db.acquireReference();
-        db.addSQLiteClosable(this);
-        mDatabase = db;
-        nHandle = db.mNativeHandle;
-        if (bindArgs != null) {
-            int size = bindArgs.length;
-            for (int i = 0; i < size; i++) {
-                this.addToBindArgs(i + 1, bindArgs[i]);
-            }
-        }
-        if (compileFlag) {
-            compileAndbindAllArgs();
+                boolean assumeReadOnly = (n == DatabaseUtils.STATEMENT_SELECT);
+                SQLiteStatementInfo info = new SQLiteStatementInfo();
+                db.getThreadSession().prepare(mSql,
+                        db.getThreadDefaultConnectionFlags(assumeReadOnly), info);
+                mReadOnly = info.readOnly;
+                mColumnNames = info.columnNames;
+                mNumParameters = info.numParameters;
+                break;
         }
-    }
 
-    private void compileSql() {
-        // only cache CRUD statements
-        if ((mStatementType & STATEMENT_CACHEABLE) == 0) {
-            mCompiledSql = new SQLiteCompiledSql(mDatabase, mSql);
-            nStatement = mCompiledSql.nStatement;
-            // since it is not in the cache, no need to acquire() it.
-            return;
+        if (mNumParameters != 0) {
+            mBindArgs = new Object[mNumParameters];
+        } else {
+            mBindArgs = null;
         }
 
-        mCompiledSql = mDatabase.getCompiledStatementForSql(mSql);
-        if (mCompiledSql == null) {
-            // create a new compiled-sql obj
-            mCompiledSql = new SQLiteCompiledSql(mDatabase, mSql);
-
-            // add it to the cache of compiled-sqls
-            // but before adding it and thus making it available for anyone else to use it,
-            // make sure it is acquired by me.
-            mCompiledSql.acquire();
-            mDatabase.addToCompiledQueries(mSql, mCompiledSql);
-        } else {
-            // it is already in compiled-sql cache.
-            // try to acquire the object.
-            if (!mCompiledSql.acquire()) {
-                int last = mCompiledSql.nStatement;
-                // the SQLiteCompiledSql in cache is in use by some other SQLiteProgram object.
-                // we can't have two different SQLiteProgam objects can't share the same
-                // CompiledSql object. create a new one.
-                // finalize it when I am done with it in "this" object.
-                mCompiledSql = new SQLiteCompiledSql(mDatabase, mSql);
-                // since it is not in the cache, no need to acquire() it.
+        if (bindArgs != null) {
+            if (bindArgs.length > mNumParameters) {
+                throw new IllegalArgumentException("Too many bind arguments.  "
+                        + bindArgs.length + " arguments were provided but the statement needs "
+                        + mNumParameters + " arguments.");
             }
+            System.arraycopy(bindArgs, 0, mBindArgs, 0, bindArgs.length);
         }
-        nStatement = mCompiledSql.nStatement;
     }
 
-    @Override
-    protected void onAllReferencesReleased() {
-        release();
-        mDatabase.removeSQLiteClosable(this);
-        mDatabase.releaseReference();
+    final SQLiteDatabase getDatabase() {
+        return mDatabase;
     }
 
-    @Override
-    protected void onAllReferencesReleasedFromContainer() {
-        release();
-        mDatabase.releaseReference();
+    final String getSql() {
+        return mSql;
     }
 
-    /* package */ void release() {
-        if (mCompiledSql == null) {
-            return;
-        }
-        mDatabase.releaseCompiledSqlObj(mSql, mCompiledSql);
-        mCompiledSql = null;
-        nStatement = 0;
+    final Object[] getBindArgs() {
+        return mBindArgs;
     }
 
-    /**
-     * Returns a unique identifier for this program.
-     *
-     * @return a unique identifier for this program
-     * @deprecated do not use this method. it is not guaranteed to be the same across executions of
-     * the SQL statement contained in this object.
-     */
-    @Deprecated
-    public final int getUniqueId() {
-      return -1;
+    final String[] getColumnNames() {
+        return mColumnNames;
     }
 
-    /**
-     * used only for testing purposes
-     */
-    /* package */ int getSqlStatementId() {
-      synchronized(this) {
-        return (mCompiledSql == null) ? 0 : nStatement;
-      }
+    /** @hide */
+    protected final SQLiteSession getSession() {
+        return mDatabase.getThreadSession();
     }
 
-    /* package */ String getSqlString() {
-        return mSql;
+    /** @hide */
+    protected final int getConnectionFlags() {
+        return mDatabase.getThreadDefaultConnectionFlags(mReadOnly);
     }
 
-    private void bind(int type, int index, Object value) {
-        mDatabase.verifyDbIsOpen();
-        addToBindArgs(index, (type == Cursor.FIELD_TYPE_NULL) ? null : value);
-        if (nStatement > 0) {
-            // bind only if the SQL statement is compiled
-            acquireReference();
-            try {
-                switch (type) {
-                    case Cursor.FIELD_TYPE_NULL:
-                        native_bind_null(index);
-                        break;
-                    case Cursor.FIELD_TYPE_BLOB:
-                        native_bind_blob(index, (byte[]) value);
-                        break;
-                    case Cursor.FIELD_TYPE_FLOAT:
-                        native_bind_double(index, (Double) value);
-                        break;
-                    case Cursor.FIELD_TYPE_INTEGER:
-                        native_bind_long(index, (Long) value);
-                        break;
-                    case Cursor.FIELD_TYPE_STRING:
-                    default:
-                        native_bind_string(index, (String) value);
-                        break;
-                }
-            } finally {
-                releaseReference();
-            }
-        }
+    /** @hide */
+    protected final void onCorruption() {
+        mDatabase.onCorruption();
+    }
+
+    /**
+     * Unimplemented.
+     * @deprecated This method is deprecated and must not be used.
+     */
+    @Deprecated
+    public final int getUniqueId() {
+        return -1;
     }
 
     /**
@@ -245,7 +124,7 @@ public abstract class SQLiteProgram extends SQLiteClosable {
      * @param index The 1-based index to the parameter to bind null to
      */
     public void bindNull(int index) {
-        bind(Cursor.FIELD_TYPE_NULL, index, null);
+        bind(index, null);
     }
 
     /**
@@ -256,7 +135,7 @@ public abstract class SQLiteProgram extends SQLiteClosable {
      * @param value The value to bind
      */
     public void bindLong(int index, long value) {
-        bind(Cursor.FIELD_TYPE_INTEGER, index, value);
+        bind(index, value);
     }
 
     /**
@@ -267,7 +146,7 @@ public abstract class SQLiteProgram extends SQLiteClosable {
      * @param value The value to bind
      */
     public void bindDouble(int index, double value) {
-        bind(Cursor.FIELD_TYPE_FLOAT, index, value);
+        bind(index, value);
     }
 
     /**
@@ -275,13 +154,13 @@ public abstract class SQLiteProgram extends SQLiteClosable {
      * {@link #clearBindings} is called.
      *
      * @param index The 1-based index to the parameter to bind
-     * @param value The value to bind
+     * @param value The value to bind, must not be null
      */
     public void bindString(int index, String value) {
         if (value == null) {
             throw new IllegalArgumentException("the bind value at index " + index + " is null");
         }
-        bind(Cursor.FIELD_TYPE_STRING, index, value);
+        bind(index, value);
     }
 
     /**
@@ -289,29 +168,21 @@ public abstract class SQLiteProgram extends SQLiteClosable {
      * {@link #clearBindings} is called.
      *
      * @param index The 1-based index to the parameter to bind
-     * @param value The value to bind
+     * @param value The value to bind, must not be null
      */
     public void bindBlob(int index, byte[] value) {
         if (value == null) {
             throw new IllegalArgumentException("the bind value at index " + index + " is null");
         }
-        bind(Cursor.FIELD_TYPE_BLOB, index, value);
+        bind(index, value);
     }
 
     /**
      * Clears all existing bindings. Unset bindings are treated as NULL.
      */
     public void clearBindings() {
-        mBindArgs = null;
-        if (this.nStatement == 0) {
-            return;
-        }
-        mDatabase.verifyDbIsOpen();
-        acquireReference();
-        try {
-            native_clear_bindings();
-        } finally {
-            releaseReference();
+        if (mBindArgs != null) {
+            Arrays.fill(mBindArgs, null);
         }
     }
 
@@ -319,102 +190,33 @@ public abstract class SQLiteProgram extends SQLiteClosable {
      * Release this program's resources, making it invalid.
      */
     public void close() {
-        mBindArgs = null;
-        if (nHandle == 0 || !mDatabase.isOpen()) {
-            return;
-        }
         releaseReference();
     }
 
-    private void addToBindArgs(int index, Object value) {
-        if (mBindArgs == null) {
-            mBindArgs = new HashMap<Integer, Object>();
-        }
-        mBindArgs.put(index, value);
-    }
-
-    /* package */ void compileAndbindAllArgs() {
-        if ((mStatementType & STATEMENT_DONT_PREPARE) > 0) {
-            if (mBindArgs != null) {
-                throw new IllegalArgumentException("Can't pass bindargs for this sql :" + mSql);
-            }
-            // no need to prepare this SQL statement
-            return;
-        }
-        if (nStatement == 0) {
-            // SQL statement is not compiled yet. compile it now.
-            compileSql();
-        }
-        if (mBindArgs == null) {
-            return;
-        }
-        for (int index : mBindArgs.keySet()) {
-            Object value = mBindArgs.get(index);
-            if (value == null) {
-                native_bind_null(index);
-            } else if (value instanceof Double || value instanceof Float) {
-                native_bind_double(index, ((Number) value).doubleValue());
-            } else if (value instanceof Number) {
-                native_bind_long(index, ((Number) value).longValue());
-            } else if (value instanceof Boolean) {
-                Boolean bool = (Boolean)value;
-                native_bind_long(index, (bool) ? 1 : 0);
-                if (bool) {
-                    native_bind_long(index, 1);
-                } else {
-                    native_bind_long(index, 0);
-                }
-            } else if (value instanceof byte[]){
-                native_bind_blob(index, (byte[]) value);
-            } else {
-                native_bind_string(index, value.toString());
-            }
-        }
-    }
-
     /**
      * Given an array of String bindArgs, this method binds all of them in one single call.
      *
-     * @param bindArgs the String array of bind args.
+     * @param bindArgs the String array of bind args, none of which must be null.
      */
     public void bindAllArgsAsStrings(String[] bindArgs) {
-        if (bindArgs == null) {
-            return;
-        }
-        int size = bindArgs.length;
-        for (int i = 0; i < size; i++) {
-            bindString(i + 1, bindArgs[i]);
+        if (bindArgs != null) {
+            for (int i = bindArgs.length; i != 0; i--) {
+                bindString(i, bindArgs[i - 1]);
+            }
         }
     }
 
-    /* package */ synchronized final void setNativeHandle(int nHandle) {
-        this.nHandle = nHandle;
+    @Override
+    protected void onAllReferencesReleased() {
+        clearBindings();
     }
 
-    /**
-     * @hide
-     * Compiles SQL into a SQLite program.
-     *
-     * <P>The database lock must be held when calling this method.
-     * @param sql The SQL to compile.
-     */
-    protected final native void native_compile(String sql);
-
-    /**
-     * @hide
-     */
-    protected final native void native_finalize();
-
-    /** @hide */
-    protected final native void native_bind_null(int index);
-    /** @hide */
-    protected final native void native_bind_long(int index, long value);
-    /** @hide */
-    protected final native void native_bind_double(int index, double value);
-    /** @hide */
-    protected final native void native_bind_string(int index, String value);
-    /** @hide */
-    protected final native void native_bind_blob(int index, byte[] value);
-    private final native void native_clear_bindings();
+    private void bind(int index, Object value) {
+        if (index < 1 || index > mNumParameters) {
+            throw new IllegalArgumentException("Cannot bind argument at index "
+                    + index + " because the index is out of range.  "
+                    + "The statement has " + mNumParameters + " parameters.");
+        }
+        mBindArgs[index - 1] = value;
+    }
 }
-
diff --git a/core/java/android/database/sqlite/SQLiteQuery.java b/core/java/android/database/sqlite/SQLiteQuery.java
index 6dd2539..17aa886 100644
--- a/core/java/android/database/sqlite/SQLiteQuery.java
+++ b/core/java/android/database/sqlite/SQLiteQuery.java
@@ -17,60 +17,24 @@
 package android.database.sqlite;
 
 import android.database.CursorWindow;
-import android.os.SystemClock;
-import android.text.TextUtils;
 import android.util.Log;
 
 /**
- * A SQLite program that represents a query that reads the resulting rows into a CursorWindow.
- * This class is used by SQLiteCursor and isn't useful itself.
- *
- * SQLiteQuery is not internally synchronized so code using a SQLiteQuery from multiple
- * threads should perform its own synchronization when using the SQLiteQuery.
+ * Represents a query that reads the resulting rows into a {@link SQLiteQuery}.
+ * This class is used by {@link SQLiteCursor} and isn't useful itself.
+ * <p>
+ * This class is not thread-safe.
+ * </p>
  */
 public final class SQLiteQuery extends SQLiteProgram {
     private static final String TAG = "SQLiteQuery";
 
-    private static native long nativeFillWindow(int databasePtr, int statementPtr, int windowPtr,
-            int offsetParam, int startPos, int requiredPos, boolean countAllRows);
-
-    private static native int nativeColumnCount(int statementPtr);
-    private static native String nativeColumnName(int statementPtr, int columnIndex);
-
-    /** The index of the unbound OFFSET parameter */
-    private int mOffsetIndex = 0;
-
-    private boolean mClosed = false;
-
-    /**
-     * Create a persistent query object.
-     *
-     * @param db The database that this query object is associated with
-     * @param query The SQL string for this query. 
-     * @param offsetIndex The 1-based index to the OFFSET parameter, 
-     */
-    /* package */ SQLiteQuery(SQLiteDatabase db, String query, int offsetIndex, String[] bindArgs) {
-        super(db, query);
-        mOffsetIndex = offsetIndex;
-        bindAllArgsAsStrings(bindArgs);
-    }
-
-    /**
-     * Constructor used to create new instance to replace a given instance of this class.
-     * This constructor is used when the current Query object is now associated with a different
-     * {@link SQLiteDatabase} object.
-     *
-     * @param db The database that this query object is associated with
-     * @param query the instance of {@link SQLiteQuery} to be replaced
-     */
-    /* package */ SQLiteQuery(SQLiteDatabase db, SQLiteQuery query) {
-        super(db, query.mSql);
-        this.mBindArgs = query.mBindArgs;
-        this.mOffsetIndex = query.mOffsetIndex;
+    SQLiteQuery(SQLiteDatabase db, String query) {
+        super(db, query, null);
     }
 
     /**
-     * Reads rows into a buffer. This method acquires the database lock.
+     * Reads rows into a buffer.
      *
      * @param window The window to fill into
      * @param startPos The start position for filling the window.
@@ -81,106 +45,30 @@ public final class SQLiteQuery extends SQLiteProgram {
      * @return Number of rows that were enumerated.  Might not be all rows
      * unless countAllRows is true.
      */
-    /* package */ int fillWindow(CursorWindow window,
-            int startPos, int requiredPos, boolean countAllRows) {
-        mDatabase.lock(mSql);
-        long timeStart = SystemClock.uptimeMillis();
+    int fillWindow(CursorWindow window, int startPos, int requiredPos, boolean countAllRows) {
+        acquireReference();
         try {
-            acquireReference();
+            window.acquireReference();
             try {
-                window.acquireReference();
-                long result = nativeFillWindow(nHandle, nStatement, window.mWindowPtr,
-                        mOffsetIndex, startPos, requiredPos, countAllRows);
-                int actualPos = (int)(result >> 32);
-                int countedRows = (int)result;
-                window.setStartPosition(actualPos);
-                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
-                                + ", requiredPos=" + requiredPos
-                                + ", offset=" + mOffsetIndex
-                                + ", actualPos=" + actualPos
-                                + ", filledRows=" + window.getNumRows()
-                                + ", countedRows=" + countedRows
-                                + ", query=\"" + mSql + "\""
-                                + ", args=[" + (mBindArgs != null ?
-                                        TextUtils.join(", ", mBindArgs.values()) : "")
-                                + "]");
-                    }
-                }
-                mDatabase.logTimeStat(mSql, timeStart);
-                return countedRows;
-            } 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;
+                int numRows = getSession().executeForCursorWindow(getSql(), getBindArgs(),
+                        window, startPos, requiredPos, countAllRows, getConnectionFlags());
+                return numRows;
+            } catch (SQLiteDatabaseCorruptException ex) {
+                onCorruption();
+                throw ex;
+            } catch (SQLiteException ex) {
+                Log.e(TAG, "exception: " + ex.getMessage() + "; query: " + getSql());
+                throw ex;
             } finally {
                 window.releaseReference();
             }
         } finally {
             releaseReference();
-            mDatabase.unlock();
-        }
-    }
-
-    /**
-     * Get the column count for the statement. Only valid on query based
-     * statements. The database must be locked
-     * when calling this method.
-     * 
-     * @return The number of column in the statement's result set.
-     */
-    /* package */ int columnCountLocked() {
-        acquireReference();
-        try {
-            return nativeColumnCount(nStatement);
-        } finally {
-            releaseReference();
-        }
-    }
-
-    /**
-     * Retrieves the column name for the given column index. The database must be locked
-     * when calling this method.
-     * 
-     * @param columnIndex the index of the column to get the name for
-     * @return The requested column's name
-     */
-    /* package */ String columnNameLocked(int columnIndex) {
-        acquireReference();
-        try {
-            return nativeColumnName(nStatement, columnIndex);
-        } finally {
-            releaseReference();
         }
     }
 
     @Override
     public String toString() {
-        return "SQLiteQuery: " + mSql;
-    }
-
-    @Override
-    public void close() {
-        super.close();
-        mClosed = true;
-    }
-
-    /**
-     * Called by SQLiteCursor when it is requeried.
-     */
-    /* package */ void requery() {
-        if (mClosed) {
-            throw new IllegalStateException("requerying a closed cursor");
-        }
-        compileAndbindAllArgs();
+        return "SQLiteQuery: " + getSql();
     }
 }
diff --git a/core/java/android/database/sqlite/SQLiteQueryBuilder.java b/core/java/android/database/sqlite/SQLiteQueryBuilder.java
index 8f8eb6e..1b7b398 100644
--- a/core/java/android/database/sqlite/SQLiteQueryBuilder.java
+++ b/core/java/android/database/sqlite/SQLiteQueryBuilder.java
@@ -341,7 +341,7 @@ public class SQLiteQueryBuilder
             // in both the wrapped and original forms.
             String sqlForValidation = buildQuery(projectionIn, "(" + selection + ")", groupBy,
                     having, sortOrder, limit);
-            validateSql(db, sqlForValidation); // will throw if query is invalid
+            validateQuerySql(db, sqlForValidation); // will throw if query is invalid
         }
 
         String sql = buildQuery(
@@ -357,16 +357,12 @@ public class SQLiteQueryBuilder
     }
 
     /**
-     * Verifies that a SQL statement is valid by compiling it.
+     * Verifies that a SQL SELECT statement is valid by compiling it.
      * If the SQL statement is not valid, this method will throw a {@link SQLiteException}.
      */
-    private void validateSql(SQLiteDatabase db, String sql) {
-        db.lock(sql);
-        try {
-            new SQLiteCompiledSql(db, sql).releaseSqlStatement();
-        } finally {
-            db.unlock();
-        }
+    private void validateQuerySql(SQLiteDatabase db, String sql) {
+        db.getThreadSession().prepare(sql,
+                db.getThreadDefaultConnectionFlags(true /*readOnly*/), null);
     }
 
     /**
diff --git a/core/java/android/database/sqlite/SQLiteSession.java b/core/java/android/database/sqlite/SQLiteSession.java
new file mode 100644
index 0000000..61fe45a
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteSession.java
@@ -0,0 +1,878 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+import android.database.CursorWindow;
+import android.database.DatabaseUtils;
+import android.os.ParcelFileDescriptor;
+
+/**
+ * Provides a single client the ability to use a database.
+ *
+ * <h2>About database sessions</h2>
+ * <p>
+ * Database access is always performed using a session.  The session
+ * manages the lifecycle of transactions and database connections.
+ * </p><p>
+ * Sessions can be used to perform both read-only and read-write operations.
+ * There is some advantage to knowing when a session is being used for
+ * read-only purposes because the connection pool can optimize the use
+ * of the available connections to permit multiple read-only operations
+ * to execute in parallel whereas read-write operations may need to be serialized.
+ * </p><p>
+ * When <em>Write Ahead Logging (WAL)</em> is enabled, the database can
+ * execute simultaneous read-only and read-write transactions, provided that
+ * at most one read-write transaction is performed at a time.  When WAL is not
+ * enabled, read-only transactions can execute in parallel but read-write
+ * transactions are mutually exclusive.
+ * </p>
+ *
+ * <h2>Ownership and concurrency guarantees</h2>
+ * <p>
+ * Session objects are not thread-safe.  In fact, session objects are thread-bound.
+ * The {@link SQLiteDatabase} uses a thread-local variable to associate a session
+ * with each thread for the use of that thread alone.  Consequently, each thread
+ * has its own session object and therefore its own transaction state independent
+ * of other threads.
+ * </p><p>
+ * A thread has at most one session per database.  This constraint ensures that
+ * a thread can never use more than one database connection at a time for a
+ * given database.  As the number of available database connections is limited,
+ * if a single thread tried to acquire multiple connections for the same database
+ * at the same time, it might deadlock.  Therefore we allow there to be only
+ * one session (so, at most one connection) per thread per database.
+ * </p>
+ *
+ * <h2>Transactions</h2>
+ * <p>
+ * There are two kinds of transaction: implicit transactions and explicit
+ * transactions.
+ * </p><p>
+ * An implicit transaction is created whenever a database operation is requested
+ * and there is no explicit transaction currently in progress.  An implicit transaction
+ * only lasts for the duration of the database operation in question and then it
+ * is ended.  If the database operation was successful, then its changes are committed.
+ * </p><p>
+ * An explicit transaction is started by calling {@link #beginTransaction} and
+ * specifying the desired transaction mode.  Once an explicit transaction has begun,
+ * all subsequent database operations will be performed as part of that transaction.
+ * To end an explicit transaction, first call {@link #setTransactionSuccessful} if the
+ * transaction was successful, then call {@link #end}.  If the transaction was
+ * marked successful, its changes will be committed, otherwise they will be rolled back.
+ * </p><p>
+ * Explicit transactions can also be nested.  A nested explicit transaction is
+ * started with {@link #beginTransaction}, marked successful with
+ * {@link #setTransactionSuccessful}and ended with {@link #endTransaction}.
+ * If any nested transaction is not marked successful, then the entire transaction
+ * including all of its nested transactions will be rolled back
+ * when the outermost transaction is ended.
+ * </p><p>
+ * To improve concurrency, an explicit transaction can be yielded by calling
+ * {@link #yieldTransaction}.  If there is contention for use of the database,
+ * then yielding ends the current transaction, commits its changes, releases the
+ * database connection for use by another session for a little while, and starts a
+ * new transaction with the same properties as the original one.
+ * Changes committed by {@link #yieldTransaction} cannot be rolled back.
+ * </p><p>
+ * When a transaction is started, the client can provide a {@link SQLiteTransactionListener}
+ * to listen for notifications of transaction-related events.
+ * </p><p>
+ * Recommended usage:
+ * <code><pre>
+ * // First, begin the transaction.
+ * session.beginTransaction(SQLiteSession.TRANSACTION_MODE_DEFERRED, 0);
+ * try {
+ *     // Then do stuff...
+ *     session.execute("INSERT INTO ...", null, 0);
+ *
+ *     // As the very last step before ending the transaction, mark it successful.
+ *     session.setTransactionSuccessful();
+ * } finally {
+ *     // Finally, end the transaction.
+ *     // This statement will commit the transaction if it was marked successful or
+ *     // roll it back otherwise.
+ *     session.endTransaction();
+ * }
+ * </pre></code>
+ * </p>
+ *
+ * <h2>Database connections</h2>
+ * <p>
+ * A {@link SQLiteDatabase} can have multiple active sessions at the same
+ * time.  Each session acquires and releases connections to the database
+ * as needed to perform each requested database transaction.  If all connections
+ * are in use, then database transactions on some sessions will block until a
+ * connection becomes available.
+ * </p><p>
+ * The session acquires a single database connection only for the duration
+ * of a single (implicit or explicit) database transaction, then releases it.
+ * This characteristic allows a small pool of database connections to be shared
+ * efficiently by multiple sessions as long as they are not all trying to perform
+ * database transactions at the same time.
+ * </p>
+ *
+ * <h2>Responsiveness</h2>
+ * <p>
+ * Because there are a limited number of database connections and the session holds
+ * a database connection for the entire duration of a database transaction,
+ * it is important to keep transactions short.  This is especially important
+ * for read-write transactions since they may block other transactions
+ * from executing.  Consider calling {@link #yieldTransaction} periodically
+ * during long-running transactions.
+ * </p><p>
+ * Another important consideration is that transactions that take too long to
+ * run may cause the application UI to become unresponsive.  Even if the transaction
+ * is executed in a background thread, the user will get bored and
+ * frustrated if the application shows no data for several seconds while
+ * a transaction runs.
+ * </p><p>
+ * Guidelines:
+ * <ul>
+ * <li>Do not perform database transactions on the UI thread.</li>
+ * <li>Keep database transactions as short as possible.</li>
+ * <li>Simple queries often run faster than complex queries.</li>
+ * <li>Measure the performance of your database transactions.</li>
+ * <li>Consider what will happen when the size of the data set grows.
+ * A query that works well on 100 rows may struggle with 10,000.</li>
+ * </ul>
+ *
+ * TODO: Support timeouts on all possibly blocking operations.
+ *
+ * @hide
+ */
+public final class SQLiteSession {
+    private final SQLiteConnectionPool mConnectionPool;
+
+    private SQLiteConnection mConnection;
+    private int mConnectionFlags;
+    private Transaction mTransactionPool;
+    private Transaction mTransactionStack;
+
+    /**
+     * Transaction mode: Deferred.
+     * <p>
+     * In a deferred transaction, no locks are acquired on the database
+     * until the first operation is performed.  If the first operation is
+     * read-only, then a <code>SHARED</code> lock is acquired, otherwise
+     * a <code>RESERVED</code> lock is acquired.
+     * </p><p>
+     * While holding a <code>SHARED</code> lock, this session is only allowed to
+     * read but other sessions are allowed to read or write.
+     * While holding a <code>RESERVED</code> lock, this session is allowed to read
+     * or write but other sessions are only allowed to read.
+     * </p><p>
+     * Because the lock is only acquired when needed in a deferred transaction,
+     * it is possible for another session to write to the database first before
+     * this session has a chance to do anything.
+     * </p><p>
+     * Corresponds to the SQLite <code>BEGIN DEFERRED</code> transaction mode.
+     * </p>
+     */
+    public static final int TRANSACTION_MODE_DEFERRED = 0;
+
+    /**
+     * Transaction mode: Immediate.
+     * <p>
+     * When an immediate transaction begins, the session acquires a
+     * <code>RESERVED</code> lock.
+     * </p><p>
+     * While holding a <code>RESERVED</code> lock, this session is allowed to read
+     * or write but other sessions are only allowed to read.
+     * </p><p>
+     * Corresponds to the SQLite <code>BEGIN IMMEDIATE</code> transaction mode.
+     * </p>
+     */
+    public static final int TRANSACTION_MODE_IMMEDIATE = 1;
+
+    /**
+     * Transaction mode: Exclusive.
+     * <p>
+     * When an exclusive transaction begins, the session acquires an
+     * <code>EXCLUSIVE</code> lock.
+     * </p><p>
+     * While holding an <code>EXCLUSIVE</code> lock, this session is allowed to read
+     * or write but no other sessions are allowed to access the database.
+     * </p><p>
+     * Corresponds to the SQLite <code>BEGIN EXCLUSIVE</code> transaction mode.
+     * </p>
+     */
+    public static final int TRANSACTION_MODE_EXCLUSIVE = 2;
+
+    /**
+     * Creates a session bound to the specified connection pool.
+     *
+     * @param connectionPool The connection pool.
+     */
+    public SQLiteSession(SQLiteConnectionPool connectionPool) {
+        if (connectionPool == null) {
+            throw new IllegalArgumentException("connectionPool must not be null");
+        }
+
+        mConnectionPool = connectionPool;
+    }
+
+    /**
+     * Returns true if the session has a transaction in progress.
+     *
+     * @return True if the session has a transaction in progress.
+     */
+    public boolean hasTransaction() {
+        return mTransactionStack != null;
+    }
+
+    /**
+     * Returns true if the session has a nested transaction in progress.
+     *
+     * @return True if the session has a nested transaction in progress.
+     */
+    public boolean hasNestedTransaction() {
+        return mTransactionStack != null && mTransactionStack.mParent != null;
+    }
+
+    /**
+     * Returns true if the session has an active database connection.
+     *
+     * @return True if the session has an active database connection.
+     */
+    public boolean hasConnection() {
+        return mConnection != null;
+    }
+
+    /**
+     * Begins a transaction.
+     * <p>
+     * Transactions may nest.  If the transaction is not in progress,
+     * then a database connection is obtained and a new transaction is started.
+     * Otherwise, a nested transaction is started.
+     * </p><p>
+     * Each call to {@link #beginTransaction} must be matched exactly by a call
+     * to {@link #endTransaction}.  To mark a transaction as successful,
+     * call {@link #setTransactionSuccessful} before calling {@link #endTransaction}.
+     * If the transaction is not successful, or if any of its nested
+     * transactions were not successful, then the entire transaction will
+     * be rolled back when the outermost transaction is ended.
+     * </p>
+     *
+     * @param transactionMode The transaction mode.  One of: {@link #TRANSACTION_MODE_DEFERRED},
+     * {@link #TRANSACTION_MODE_IMMEDIATE}, or {@link #TRANSACTION_MODE_EXCLUSIVE}.
+     * Ignored when creating a nested transaction.
+     * @param transactionListener The transaction listener, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     *
+     * @throws IllegalStateException if {@link #setTransactionSuccessful} has already been
+     * called for the current transaction.
+     *
+     * @see #setTransactionSuccessful
+     * @see #yieldTransaction
+     * @see #endTransaction
+     */
+    public void beginTransaction(int transactionMode,
+            SQLiteTransactionListener transactionListener, int connectionFlags) {
+        throwIfTransactionMarkedSuccessful();
+        beginTransactionUnchecked(transactionMode, transactionListener, connectionFlags);
+    }
+
+    private void beginTransactionUnchecked(int transactionMode,
+            SQLiteTransactionListener transactionListener, int connectionFlags) {
+        acquireConnectionIfNoTransaction(null, connectionFlags); // might throw
+        try {
+            // Set up the transaction such that we can back out safely
+            // in case we fail part way.
+            if (mTransactionStack == null) {
+                // Execute SQL might throw a runtime exception.
+                switch (transactionMode) {
+                    case TRANSACTION_MODE_IMMEDIATE:
+                        mConnection.execute("BEGIN IMMEDIATE;", null); // might throw
+                        break;
+                    case TRANSACTION_MODE_EXCLUSIVE:
+                        mConnection.execute("BEGIN EXCLUSIVE;", null); // might throw
+                        break;
+                    default:
+                        mConnection.execute("BEGIN;", null); // might throw
+                        break;
+                }
+            }
+
+            // Listener might throw a runtime exception.
+            if (transactionListener != null) {
+                try {
+                    transactionListener.onBegin(); // might throw
+                } catch (RuntimeException ex) {
+                    if (mTransactionStack == null) {
+                        mConnection.execute("ROLLBACK;", null); // might throw
+                    }
+                    throw ex;
+                }
+            }
+
+            // Bookkeeping can't throw, except an OOM, which is just too bad...
+            Transaction transaction = obtainTransaction(transactionMode, transactionListener);
+            transaction.mParent = mTransactionStack;
+            mTransactionStack = transaction;
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Marks the current transaction as having completed successfully.
+     * <p>
+     * This method can be called at most once between {@link #beginTransaction} and
+     * {@link #endTransaction} to indicate that the changes made by the transaction should be
+     * committed.  If this method is not called, the changes will be rolled back
+     * when the transaction is ended.
+     * </p>
+     *
+     * @throws IllegalStateException if there is no current transaction, or if
+     * {@link #setTransactionSuccessful} has already been called for the current transaction.
+     *
+     * @see #beginTransaction
+     * @see #endTransaction
+     */
+    public void setTransactionSuccessful() {
+        throwIfNoTransaction();
+        throwIfTransactionMarkedSuccessful();
+
+        mTransactionStack.mMarkedSuccessful = true;
+    }
+
+    /**
+     * Ends the current transaction and commits or rolls back changes.
+     * <p>
+     * If this is the outermost transaction (not nested within any other
+     * transaction), then the changes are committed if {@link #setTransactionSuccessful}
+     * was called or rolled back otherwise.
+     * </p><p>
+     * This method must be called exactly once for each call to {@link #beginTransaction}.
+     * </p>
+     *
+     * @throws IllegalStateException if there is no current transaction.
+     *
+     * @see #beginTransaction
+     * @see #setTransactionSuccessful
+     * @see #yieldTransaction
+     */
+    public void endTransaction() {
+        throwIfNoTransaction();
+        assert mConnection != null;
+
+        endTransactionUnchecked();
+    }
+
+    private void endTransactionUnchecked() {
+        final Transaction top = mTransactionStack;
+        boolean successful = top.mMarkedSuccessful && !top.mChildFailed;
+
+        RuntimeException listenerException = null;
+        final SQLiteTransactionListener listener = top.mListener;
+        if (listener != null) {
+            try {
+                if (successful) {
+                    listener.onCommit(); // might throw
+                } else {
+                    listener.onRollback(); // might throw
+                }
+            } catch (RuntimeException ex) {
+                listenerException = ex;
+                successful = false;
+            }
+        }
+
+        mTransactionStack = top.mParent;
+        recycleTransaction(top);
+
+        if (mTransactionStack != null) {
+            if (!successful) {
+                mTransactionStack.mChildFailed = true;
+            }
+        } else {
+            try {
+                if (successful) {
+                    mConnection.execute("COMMIT;", null); // might throw
+                } else {
+                    mConnection.execute("ROLLBACK;", null); // might throw
+                }
+            } finally {
+                releaseConnectionIfNoTransaction(); // might throw
+            }
+        }
+
+        if (listenerException != null) {
+            throw listenerException;
+        }
+    }
+
+    /**
+     * Temporarily ends a transaction to let other threads have use of
+     * the database.  Begins a new transaction after a specified delay.
+     * <p>
+     * If there are other threads waiting to acquire connections,
+     * then the current transaction is committed and the database
+     * connection is released.  After a short delay, a new transaction
+     * is started.
+     * </p><p>
+     * The transaction is assumed to be successful so far.  Do not call
+     * {@link #setTransactionSuccessful()} before calling this method.
+     * This method will fail if the transaction has already been marked
+     * successful.
+     * </p><p>
+     * The changes that were committed by a yield cannot be rolled back later.
+     * </p><p>
+     * Before this method was called, there must already have been
+     * a transaction in progress.  When this method returns, there will
+     * still be a transaction in progress, either the same one as before
+     * or a new one if the transaction was actually yielded.
+     * </p><p>
+     * This method should not be called when there is a nested transaction
+     * in progress because it is not possible to yield a nested transaction.
+     * If <code>throwIfNested</code> is true, then attempting to yield
+     * a nested transaction will throw {@link IllegalStateException}, otherwise
+     * the method will return <code>false</code> in that case.
+     * </p><p>
+     * If there is no nested transaction in progress but a previous nested
+     * transaction failed, then the transaction is not yielded (because it
+     * must be rolled back) and this method returns <code>false</code>.
+     * </p>
+     *
+     * @param sleepAfterYieldDelayMillis A delay time to wait after yielding
+     * the database connection to allow other threads some time to run.
+     * If the value is less than or equal to zero, there will be no additional
+     * delay beyond the time it will take to begin a new transaction.
+     * @param throwIfUnsafe If true, then instead of returning false when no
+     * transaction is in progress, a nested transaction is in progress, or when
+     * the transaction has already been marked successful, throws {@link IllegalStateException}.
+     * @return True if the transaction was actually yielded.
+     *
+     * @throws IllegalStateException if <code>throwIfNested</code> is true and
+     * there is no current transaction, there is a nested transaction in progress or
+     * if {@link #setTransactionSuccessful} has already been called for the current transaction.
+     *
+     * @see #beginTransaction
+     * @see #endTransaction
+     */
+    public boolean yieldTransaction(long sleepAfterYieldDelayMillis, boolean throwIfUnsafe) {
+        if (throwIfUnsafe) {
+            throwIfNoTransaction();
+            throwIfTransactionMarkedSuccessful();
+            throwIfNestedTransaction();
+        } else {
+            if (mTransactionStack == null || mTransactionStack.mMarkedSuccessful
+                    || mTransactionStack.mParent != null) {
+                return false;
+            }
+        }
+        assert mConnection != null;
+
+        if (mTransactionStack.mChildFailed) {
+            return false;
+        }
+
+        return yieldTransactionUnchecked(sleepAfterYieldDelayMillis); // might throw
+    }
+
+    private boolean yieldTransactionUnchecked(long sleepAfterYieldDelayMillis) {
+        if (!mConnectionPool.shouldYieldConnection(mConnection, mConnectionFlags)) {
+            return false;
+        }
+
+        final int transactionMode = mTransactionStack.mMode;
+        final SQLiteTransactionListener listener = mTransactionStack.mListener;
+        final int connectionFlags = mConnectionFlags;
+        endTransactionUnchecked(); // might throw
+
+        if (sleepAfterYieldDelayMillis > 0) {
+            try {
+                Thread.sleep(sleepAfterYieldDelayMillis);
+            } catch (InterruptedException ex) {
+                // we have been interrupted, that's all we need to do
+            }
+        }
+
+        beginTransactionUnchecked(transactionMode, listener, connectionFlags); // might throw
+        return true;
+    }
+
+    /**
+     * Prepares a statement for execution but does not bind its parameters or execute it.
+     * <p>
+     * This method can be used to check for syntax errors during compilation
+     * prior to execution of the statement.  If the {@code outStatementInfo} argument
+     * is not null, the provided {@link SQLiteStatementInfo} object is populated
+     * with information about the statement.
+     * </p><p>
+     * A prepared statement makes no reference to the arguments that may eventually
+     * be bound to it, consequently it it possible to cache certain prepared statements
+     * such as SELECT or INSERT/UPDATE statements.  If the statement is cacheable,
+     * then it will be stored in the cache for later and reused if possible.
+     * </p>
+     *
+     * @param sql The SQL statement to prepare.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @param outStatementInfo The {@link SQLiteStatementInfo} object to populate
+     * with information about the statement, or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error.
+     */
+    public void prepare(String sql, int connectionFlags, SQLiteStatementInfo outStatementInfo) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            mConnection.prepare(sql, outStatementInfo); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement that does not return a result.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public void execute(String sql, Object[] bindArgs, int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            return;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            mConnection.execute(sql, bindArgs); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement that returns a single <code>long</code> result.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return The value of the first column in the first row of the result set
+     * as a <code>long</code>, or zero if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public long executeForLong(String sql, Object[] bindArgs, int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            return 0;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            return mConnection.executeForLong(sql, bindArgs); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement that returns a single {@link String} result.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return The value of the first column in the first row of the result set
+     * as a <code>String</code>, or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public String executeForString(String sql, Object[] bindArgs, int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            return null;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            return mConnection.executeForString(sql, bindArgs); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement that returns a single BLOB result as a
+     * file descriptor to a shared memory region.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return The file descriptor for a shared memory region that contains
+     * the value of the first column in the first row of the result set as a BLOB,
+     * or null if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public ParcelFileDescriptor executeForBlobFileDescriptor(String sql, Object[] bindArgs,
+            int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            return null;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            return mConnection.executeForBlobFileDescriptor(sql, bindArgs); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement that returns a count of the number of rows
+     * that were changed.  Use for UPDATE or DELETE SQL statements.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return The number of rows that were changed.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public int executeForChangedRowCount(String sql, Object[] bindArgs, int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            return 0;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            return mConnection.executeForChangedRowCount(sql, bindArgs); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement that returns the row id of the last row inserted
+     * by the statement.  Use for INSERT SQL statements.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return The row id of the last row that was inserted, or 0 if none.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public long executeForLastInsertedRowId(String sql, Object[] bindArgs, int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            return 0;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            return mConnection.executeForLastInsertedRowId(sql, bindArgs); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Executes a statement and populates the specified {@link CursorWindow}
+     * with a range of results.  Returns the number of rows that were counted
+     * during query execution.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param window The cursor window to clear and fill.
+     * @param startPos The start position for filling the window.
+     * @param requiredPos The position of a row that MUST be in the window.
+     * If it won't fit, then the query should discard part of what it filled
+     * so that it does.  Must be greater than or equal to <code>startPos</code>.
+     * @param countAllRows True to count all rows that the query would return
+     * regagless of whether they fit in the window.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return The number of rows that were counted during query execution.  Might
+     * not be all rows in the result set unless <code>countAllRows</code> is true.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    public int executeForCursorWindow(String sql, Object[] bindArgs,
+            CursorWindow window, int startPos, int requiredPos, boolean countAllRows,
+            int connectionFlags) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+        if (window == null) {
+            throw new IllegalArgumentException("window must not be null.");
+        }
+
+        if (executeSpecial(sql, bindArgs, connectionFlags)) {
+            window.clear();
+            return 0;
+        }
+
+        acquireConnectionIfNoTransaction(sql, connectionFlags); // might throw
+        try {
+            return mConnection.executeForCursorWindow(sql, bindArgs,
+                    window, startPos, requiredPos, countAllRows); // might throw
+        } finally {
+            releaseConnectionIfNoTransaction(); // might throw
+        }
+    }
+
+    /**
+     * Performs special reinterpretation of certain SQL statements such as "BEGIN",
+     * "COMMIT" and "ROLLBACK" to ensure that transaction state invariants are
+     * maintained.
+     *
+     * This function is mainly used to support legacy apps that perform their
+     * own transactions by executing raw SQL rather than calling {@link #beginTransaction}
+     * and the like.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param connectionFlags The connection flags to use if a connection must be
+     * acquired by this operation.  Refer to {@link SQLiteConnectionPool}.
+     * @return True if the statement was of a special form that was handled here,
+     * false otherwise.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     */
+    private boolean executeSpecial(String sql, Object[] bindArgs, int connectionFlags) {
+        final int type = DatabaseUtils.getSqlStatementType(sql);
+        switch (type) {
+            case DatabaseUtils.STATEMENT_BEGIN:
+                beginTransaction(TRANSACTION_MODE_EXCLUSIVE, null, connectionFlags);
+                return true;
+
+            case DatabaseUtils.STATEMENT_COMMIT:
+                setTransactionSuccessful();
+                endTransaction();
+                return true;
+
+            case DatabaseUtils.STATEMENT_ABORT:
+                endTransaction();
+                return true;
+        }
+        return false;
+    }
+
+    private void acquireConnectionIfNoTransaction(String sql, int connectionFlags) {
+        if (mTransactionStack == null) {
+            assert mConnection == null;
+            mConnection = mConnectionPool.acquireConnection(sql, connectionFlags); // might throw
+            mConnectionFlags = connectionFlags;
+        }
+    }
+
+    private void releaseConnectionIfNoTransaction() {
+        if (mTransactionStack == null && mConnection != null) {
+            try {
+                mConnectionPool.releaseConnection(mConnection); // might throw
+            } finally {
+                mConnection = null;
+            }
+        }
+    }
+
+    private void throwIfNoTransaction() {
+        if (mTransactionStack == null) {
+            throw new IllegalStateException("Cannot perform this operation because "
+                    + "there is no current transaction.");
+        }
+    }
+
+    private void throwIfTransactionMarkedSuccessful() {
+        if (mTransactionStack != null && mTransactionStack.mMarkedSuccessful) {
+            throw new IllegalStateException("Cannot perform this operation because "
+                    + "the transaction has already been marked successful.  The only "
+                    + "thing you can do now is call endTransaction().");
+        }
+    }
+
+    private void throwIfNestedTransaction() {
+        if (mTransactionStack == null && mTransactionStack.mParent != null) {
+            throw new IllegalStateException("Cannot perform this operation because "
+                    + "a nested transaction is in progress.");
+        }
+    }
+
+    private Transaction obtainTransaction(int mode, SQLiteTransactionListener listener) {
+        Transaction transaction = mTransactionPool;
+        if (transaction != null) {
+            mTransactionPool = transaction.mParent;
+            transaction.mParent = null;
+            transaction.mMarkedSuccessful = false;
+            transaction.mChildFailed = false;
+        } else {
+            transaction = new Transaction();
+        }
+        transaction.mMode = mode;
+        transaction.mListener = listener;
+        return transaction;
+    }
+
+    private void recycleTransaction(Transaction transaction) {
+        transaction.mParent = mTransactionPool;
+        transaction.mListener = null;
+        mTransactionPool = transaction;
+    }
+
+    private static final class Transaction {
+        public Transaction mParent;
+        public int mMode;
+        public SQLiteTransactionListener mListener;
+        public boolean mMarkedSuccessful;
+        public boolean mChildFailed;
+    }
+}
diff --git a/core/java/android/database/sqlite/SQLiteStatement.java b/core/java/android/database/sqlite/SQLiteStatement.java
index c99a6fb..4e20da0 100644
--- a/core/java/android/database/sqlite/SQLiteStatement.java
+++ b/core/java/android/database/sqlite/SQLiteStatement.java
@@ -16,47 +16,19 @@
 
 package android.database.sqlite;
 
-import android.database.DatabaseUtils;
 import android.os.ParcelFileDescriptor;
-import android.os.SystemClock;
-import android.util.Log;
-
-import java.io.IOException;
-
-import dalvik.system.BlockGuard;
 
 /**
- * A pre-compiled statement against a {@link SQLiteDatabase} that can be reused.
- * The statement cannot return multiple rows, but 1x1 result sets are allowed.
- * Don't use SQLiteStatement constructor directly, please use
- * {@link SQLiteDatabase#compileStatement(String)}
- *<p>
- * SQLiteStatement is NOT internally synchronized so code using a SQLiteStatement from multiple
- * threads should perform its own synchronization when using the SQLiteStatement.
+ * Represents a statement that can be executed against a database.  The statement
+ * cannot return multiple rows or columns, but single value (1 x 1) result sets
+ * are supported.
+ * <p>
+ * This class is not thread-safe.
+ * </p>
  */
-@SuppressWarnings("deprecation")
-public final class SQLiteStatement extends SQLiteProgram
-{
-    private static final String TAG = "SQLiteStatement";
-
-    private static final boolean READ = true;
-    private static final boolean WRITE = false;
-
-    private SQLiteDatabase mOrigDb;
-    private int mState;
-    /** possible value for {@link #mState}. indicates that a transaction is started. */
-    private static final int TRANS_STARTED = 1;
-    /** possible value for {@link #mState}. indicates that a lock is acquired. */
-    private static final int LOCK_ACQUIRED = 2;
-
-    /**
-     * Don't use SQLiteStatement constructor directly, please use
-     * {@link SQLiteDatabase#compileStatement(String)}
-     * @param db
-     * @param sql
-     */
-    /* package */ SQLiteStatement(SQLiteDatabase db, String sql, Object[] bindArgs) {
-        super(db, sql, bindArgs, false /* don't compile sql statement */);
+public final class SQLiteStatement extends SQLiteProgram {
+    SQLiteStatement(SQLiteDatabase db, String sql, Object[] bindArgs) {
+        super(db, sql, bindArgs);
     }
 
     /**
@@ -67,7 +39,15 @@ public final class SQLiteStatement extends SQLiteProgram
      *         some reason
      */
     public void execute() {
-        executeUpdateDelete();
+        acquireReference();
+        try {
+            getSession().execute(getSql(), getBindArgs(), getConnectionFlags());
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
+        } finally {
+            releaseReference();
+        }
     }
 
     /**
@@ -79,21 +59,15 @@ public final class SQLiteStatement extends SQLiteProgram
      *         some reason
      */
     public int executeUpdateDelete() {
+        acquireReference();
         try {
-            saveSqlAsLastSqlStatement();
-            acquireAndLock(WRITE);
-            int numChanges = 0;
-            if ((mStatementType & STATEMENT_DONT_PREPARE) > 0) {
-                // since the statement doesn't have to be prepared,
-                // call the following native method which will not prepare
-                // the query plan
-                native_executeSql(mSql);
-            } else {
-                numChanges = native_execute();
-            }
-            return numChanges;
+            return getSession().executeForChangedRowCount(
+                    getSql(), getBindArgs(), getConnectionFlags());
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
         } finally {
-            releaseAndUnlock();
+            releaseReference();
         }
     }
 
@@ -107,23 +81,18 @@ public final class SQLiteStatement extends SQLiteProgram
      *         some reason
      */
     public long executeInsert() {
+        acquireReference();
         try {
-            saveSqlAsLastSqlStatement();
-            acquireAndLock(WRITE);
-            return native_executeInsert();
+            return getSession().executeForLastInsertedRowId(
+                    getSql(), getBindArgs(), getConnectionFlags());
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
         } finally {
-            releaseAndUnlock();
+            releaseReference();
         }
     }
 
-    private void saveSqlAsLastSqlStatement() {
-        if (((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) ==
-                DatabaseUtils.STATEMENT_UPDATE) ||
-                (mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) ==
-                DatabaseUtils.STATEMENT_BEGIN) {
-            mDatabase.setLastSqlStatement(mSql);
-        }
-    }
     /**
      * Execute a statement that returns a 1 by 1 table with a numeric value.
      * For example, SELECT COUNT(*) FROM table;
@@ -133,17 +102,15 @@ public final class SQLiteStatement extends SQLiteProgram
      * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows
      */
     public long simpleQueryForLong() {
+        acquireReference();
         try {
-            long timeStart = acquireAndLock(READ);
-            long retValue = native_1x1_long();
-            mDatabase.logTimeStat(mSql, timeStart);
-            return retValue;
-        } catch (SQLiteDoneException e) {
-            throw new SQLiteDoneException(
-                    "expected 1 row from this query but query returned no data. check the query: " +
-                    mSql);
+            return getSession().executeForLong(
+                    getSql(), getBindArgs(), getConnectionFlags());
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
         } finally {
-            releaseAndUnlock();
+            releaseReference();
         }
     }
 
@@ -156,17 +123,15 @@ public final class SQLiteStatement extends SQLiteProgram
      * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows
      */
     public String simpleQueryForString() {
+        acquireReference();
         try {
-            long timeStart = acquireAndLock(READ);
-            String retValue = native_1x1_string();
-            mDatabase.logTimeStat(mSql, timeStart);
-            return retValue;
-        } catch (SQLiteDoneException e) {
-            throw new SQLiteDoneException(
-                    "expected 1 row from this query but query returned no data. check the query: " +
-                    mSql);
+            return getSession().executeForString(
+                    getSql(), getBindArgs(), getConnectionFlags());
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
         } finally {
-            releaseAndUnlock();
+            releaseReference();
         }
     }
 
@@ -179,121 +144,20 @@ public final class SQLiteStatement extends SQLiteProgram
      * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows
      */
     public ParcelFileDescriptor simpleQueryForBlobFileDescriptor() {
+        acquireReference();
         try {
-            long timeStart = acquireAndLock(READ);
-            ParcelFileDescriptor retValue = native_1x1_blob_ashmem();
-            mDatabase.logTimeStat(mSql, timeStart);
-            return retValue;
-        } catch (IOException ex) {
-            Log.e(TAG, "simpleQueryForBlobFileDescriptor() failed", ex);
-            return null;
-        } catch (SQLiteDoneException e) {
-            throw new SQLiteDoneException(
-                    "expected 1 row from this query but query returned no data. check the query: " +
-                    mSql);
+            return getSession().executeForBlobFileDescriptor(
+                    getSql(), getBindArgs(), getConnectionFlags());
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
         } finally {
-            releaseAndUnlock();
-        }
-    }
-
-    /**
-     * Called before every method in this class before executing a SQL statement,
-     * this method does the following:
-     * <ul>
-     *   <li>make sure the database is open</li>
-     *   <li>get a database connection from the connection pool,if possible</li>
-     *   <li>notifies {@link BlockGuard} of read/write</li>
-     *   <li>if the SQL statement is an update, start transaction if not already in one.
-     *   otherwise, get lock on the database</li>
-     *   <li>acquire reference on this object</li>
-     *   <li>and then return the current time _after_ the database lock was acquired</li>
-     * </ul>
-     * <p>
-     * This method removes the duplicate code from the other public
-     * methods in this class.
-     */
-    private long acquireAndLock(boolean rwFlag) {
-        mState = 0;
-        // use pooled database connection handles for SELECT SQL statements
-        mDatabase.verifyDbIsOpen();
-        SQLiteDatabase db = ((mStatementType & SQLiteProgram.STATEMENT_USE_POOLED_CONN) > 0)
-                ? mDatabase.getDbConnection(mSql) : mDatabase;
-        // use the database connection obtained above
-        mOrigDb = mDatabase;
-        mDatabase = db;
-        setNativeHandle(mDatabase.mNativeHandle);
-        if (rwFlag == WRITE) {
-            BlockGuard.getThreadPolicy().onWriteToDisk();
-        } else {
-            BlockGuard.getThreadPolicy().onReadFromDisk();
-        }
-
-        /*
-         * Special case handling of SQLiteDatabase.execSQL("BEGIN transaction").
-         * we know it is execSQL("BEGIN transaction") from the caller IF there is no lock held.
-         * beginTransaction() methods in SQLiteDatabase call lockForced() before
-         * calling execSQL("BEGIN transaction").
-         */
-        if ((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_BEGIN) {
-            if (!mDatabase.isDbLockedByCurrentThread()) {
-                // transaction is  NOT started by calling beginTransaction() methods in
-                // SQLiteDatabase
-                mDatabase.setTransactionUsingExecSqlFlag();
-            }
-        } else if ((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) ==
-                DatabaseUtils.STATEMENT_UPDATE) {
-            // got update SQL statement. if there is NO pending transaction, start one
-            if (!mDatabase.inTransaction()) {
-                mDatabase.beginTransactionNonExclusive();
-                mState = TRANS_STARTED;
-            }
+            releaseReference();
         }
-        // do I have database lock? if not, grab it.
-        if (!mDatabase.isDbLockedByCurrentThread()) {
-            mDatabase.lock(mSql);
-            mState = LOCK_ACQUIRED;
-        }
-
-        acquireReference();
-        long startTime = SystemClock.uptimeMillis();
-        mDatabase.closePendingStatements();
-        compileAndbindAllArgs();
-        return startTime;
     }
 
-    /**
-     * this method releases locks and references acquired in {@link #acquireAndLock(boolean)}
-     */
-    private void releaseAndUnlock() {
-        releaseReference();
-        if (mState == TRANS_STARTED) {
-            try {
-                mDatabase.setTransactionSuccessful();
-            } finally {
-                mDatabase.endTransaction();
-            }
-        } else if (mState == LOCK_ACQUIRED) {
-            mDatabase.unlock();
-        }
-        if ((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) ==
-                DatabaseUtils.STATEMENT_COMMIT ||
-                (mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) ==
-                DatabaseUtils.STATEMENT_ABORT) {
-            mDatabase.resetTransactionUsingExecSqlFlag();
-        }
-        clearBindings();
-        // release the compiled sql statement so that the caller's SQLiteStatement no longer
-        // has a hard reference to a database object that may get deallocated at any point.
-        release();
-        // restore the database connection handle to the original value
-        mDatabase = mOrigDb;
-        setNativeHandle(mDatabase.mNativeHandle);
+    @Override
+    public String toString() {
+        return "SQLiteProgram: " + getSql();
     }
-
-    private final native int native_execute();
-    private final native long native_executeInsert();
-    private final native long native_1x1_long();
-    private final native String native_1x1_string();
-    private final native ParcelFileDescriptor native_1x1_blob_ashmem() throws IOException;
-    private final native void native_executeSql(String sql);
 }
diff --git a/core/java/android/database/sqlite/SQLiteStatementInfo.java b/core/java/android/database/sqlite/SQLiteStatementInfo.java
new file mode 100644
index 0000000..3edfdb0
--- /dev/null
+++ b/core/java/android/database/sqlite/SQLiteStatementInfo.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+/**
+ * Describes a SQLite statement.
+ *
+ * @hide
+ */
+public final class SQLiteStatementInfo {
+    /**
+     * The number of parameters that the statement has.
+     */
+    public int numParameters;
+
+    /**
+     * The names of all columns in the result set of the statement.
+     */
+    public String[] columnNames;
+
+    /**
+     * True if the statement is read-only.
+     */
+    public boolean readOnly;
+}
diff --git a/core/java/android/util/LruCache.java b/core/java/android/util/LruCache.java
index f1014a7..51e373c 100644
--- a/core/java/android/util/LruCache.java
+++ b/core/java/android/util/LruCache.java
@@ -86,6 +86,23 @@ public class LruCache<K, V> {
     }
 
     /**
+     * Sets the size of the cache.
+     * @param maxSize The new maximum size.
+     *
+     * @hide
+     */
+    public void resize(int maxSize) {
+        if (maxSize <= 0) {
+            throw new IllegalArgumentException("maxSize <= 0");
+        }
+
+        synchronized (this) {
+            this.maxSize = maxSize;
+        }
+        trimToSize(maxSize);
+    }
+
+    /**
      * Returns the value for {@code key} if it exists in the cache or can be
      * created by {@code #create}. If a value was returned, it is moved to the
      * head of the queue. This returns null if a value is not cached and cannot
diff --git a/core/jni/Android.mk b/core/jni/Android.mk
index 8be1996..39b84bb 100644
--- a/core/jni/Android.mk
+++ b/core/jni/Android.mk
@@ -39,12 +39,10 @@ LOCAL_SRC_FILES:= \
 	android_opengl_GLES11Ext.cpp \
 	android_opengl_GLES20.cpp \
 	android_database_CursorWindow.cpp \
-	android_database_SQLiteCompiledSql.cpp \
+	android_database_SQLiteCommon.cpp \
+	android_database_SQLiteConnection.cpp \
+	android_database_SQLiteGlobal.cpp \
 	android_database_SQLiteDebug.cpp \
-	android_database_SQLiteDatabase.cpp \
-	android_database_SQLiteProgram.cpp \
-	android_database_SQLiteQuery.cpp \
-	android_database_SQLiteStatement.cpp \
 	android_emoji_EmojiFactory.cpp \
 	android_view_Display.cpp \
 	android_view_DisplayEventReceiver.cpp \
diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp
index c006615..8a3063f 100644
--- a/core/jni/AndroidRuntime.cpp
+++ b/core/jni/AndroidRuntime.cpp
@@ -121,12 +121,9 @@ extern int register_android_view_HardwareRenderer(JNIEnv* env);
 extern int register_android_view_Surface(JNIEnv* env);
 extern int register_android_view_TextureView(JNIEnv* env);
 extern int register_android_database_CursorWindow(JNIEnv* env);
-extern int register_android_database_SQLiteCompiledSql(JNIEnv* env);
-extern int register_android_database_SQLiteDatabase(JNIEnv* env);
+extern int register_android_database_SQLiteConnection(JNIEnv* env);
+extern int register_android_database_SQLiteGlobal(JNIEnv* env);
 extern int register_android_database_SQLiteDebug(JNIEnv* env);
-extern int register_android_database_SQLiteProgram(JNIEnv* env);
-extern int register_android_database_SQLiteQuery(JNIEnv* env);
-extern int register_android_database_SQLiteStatement(JNIEnv* env);
 extern int register_android_debug_JNITest(JNIEnv* env);
 extern int register_android_nio_utils(JNIEnv* env);
 extern int register_android_text_format_Time(JNIEnv* env);
@@ -1141,12 +1138,9 @@ static const RegJNIRec gRegJNI[] = {
     REG_JNI(register_android_graphics_YuvImage),
 
     REG_JNI(register_android_database_CursorWindow),
-    REG_JNI(register_android_database_SQLiteCompiledSql),
-    REG_JNI(register_android_database_SQLiteDatabase),
+    REG_JNI(register_android_database_SQLiteConnection),
+    REG_JNI(register_android_database_SQLiteGlobal),
     REG_JNI(register_android_database_SQLiteDebug),
-    REG_JNI(register_android_database_SQLiteProgram),
-    REG_JNI(register_android_database_SQLiteQuery),
-    REG_JNI(register_android_database_SQLiteStatement),
     REG_JNI(register_android_os_Debug),
     REG_JNI(register_android_os_FileObserver),
     REG_JNI(register_android_os_FileUtils),
diff --git a/core/jni/android_database_CursorWindow.cpp b/core/jni/android_database_CursorWindow.cpp
index 659fa35..d53644d 100644
--- a/core/jni/android_database_CursorWindow.cpp
+++ b/core/jni/android_database_CursorWindow.cpp
@@ -31,8 +31,8 @@
 #include <unistd.h>
 
 #include "binder/CursorWindow.h"
-#include "sqlite3_exception.h"
 #include "android_util_Binder.h"
+#include "android_database_SQLiteCommon.h"
 
 namespace android {
 
diff --git a/core/jni/android_database_SQLiteCommon.cpp b/core/jni/android_database_SQLiteCommon.cpp
new file mode 100644
index 0000000..d5fdb15
--- /dev/null
+++ b/core/jni/android_database_SQLiteCommon.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "android_database_SQLiteCommon.h"
+
+namespace android {
+
+/* throw a SQLiteException with a message appropriate for the error in handle */
+void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle) {
+    throw_sqlite3_exception(env, handle, NULL);
+}
+
+/* throw a SQLiteException with the given message */
+void throw_sqlite3_exception(JNIEnv* env, const char* message) {
+    throw_sqlite3_exception(env, NULL, message);
+}
+
+/* throw a SQLiteException with a message appropriate for the error in handle
+   concatenated with the given message
+ */
+void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message) {
+    if (handle) {
+        throw_sqlite3_exception(env, sqlite3_errcode(handle),
+                                sqlite3_errmsg(handle), message);
+    } else {
+        // we use SQLITE_OK so that a generic SQLiteException is thrown;
+        // any code not specified in the switch statement below would do.
+        throw_sqlite3_exception(env, SQLITE_OK, "unknown error", message);
+    }
+}
+
+/* throw a SQLiteException for a given error code */
+void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message) {
+    if (errcode == SQLITE_DONE) {
+        throw_sqlite3_exception(env, errcode, NULL, message);
+    } else {
+        char temp[21];
+        sprintf(temp, "error code %d", errcode);
+        throw_sqlite3_exception(env, errcode, temp, message);
+    }
+}
+
+/* throw a SQLiteException for a given error code, sqlite3message, and
+   user message
+ */
+void throw_sqlite3_exception(JNIEnv* env, int errcode,
+                             const char* sqlite3Message, const char* message) {
+    const char* exceptionClass;
+    switch (errcode) {
+        case SQLITE_IOERR:
+            exceptionClass = "android/database/sqlite/SQLiteDiskIOException";
+            break;
+        case SQLITE_CORRUPT:
+        case SQLITE_NOTADB: // treat "unsupported file format" error as corruption also
+            exceptionClass = "android/database/sqlite/SQLiteDatabaseCorruptException";
+            break;
+        case SQLITE_CONSTRAINT:
+           exceptionClass = "android/database/sqlite/SQLiteConstraintException";
+           break;
+        case SQLITE_ABORT:
+           exceptionClass = "android/database/sqlite/SQLiteAbortException";
+           break;
+        case SQLITE_DONE:
+           exceptionClass = "android/database/sqlite/SQLiteDoneException";
+           break;
+        case SQLITE_FULL:
+           exceptionClass = "android/database/sqlite/SQLiteFullException";
+           break;
+        case SQLITE_MISUSE:
+           exceptionClass = "android/database/sqlite/SQLiteMisuseException";
+           break;
+        case SQLITE_PERM:
+           exceptionClass = "android/database/sqlite/SQLiteAccessPermException";
+           break;
+        case SQLITE_BUSY:
+           exceptionClass = "android/database/sqlite/SQLiteDatabaseLockedException";
+           break;
+        case SQLITE_LOCKED:
+           exceptionClass = "android/database/sqlite/SQLiteTableLockedException";
+           break;
+        case SQLITE_READONLY:
+           exceptionClass = "android/database/sqlite/SQLiteReadOnlyDatabaseException";
+           break;
+        case SQLITE_CANTOPEN:
+           exceptionClass = "android/database/sqlite/SQLiteCantOpenDatabaseException";
+           break;
+        case SQLITE_TOOBIG:
+           exceptionClass = "android/database/sqlite/SQLiteBlobTooBigException";
+           break;
+        case SQLITE_RANGE:
+           exceptionClass = "android/database/sqlite/SQLiteBindOrColumnIndexOutOfRangeException";
+           break;
+        case SQLITE_NOMEM:
+           exceptionClass = "android/database/sqlite/SQLiteOutOfMemoryException";
+           break;
+        case SQLITE_MISMATCH:
+           exceptionClass = "android/database/sqlite/SQLiteDatatypeMismatchException";
+           break;
+        case SQLITE_UNCLOSED:
+           exceptionClass = "android/database/sqlite/SQLiteUnfinalizedObjectsException";
+           break;
+        default:
+           exceptionClass = "android/database/sqlite/SQLiteException";
+           break;
+    }
+
+    if (sqlite3Message != NULL && message != NULL) {
+        char* fullMessage = (char *)malloc(strlen(sqlite3Message) + strlen(message) + 3);
+        if (fullMessage != NULL) {
+            strcpy(fullMessage, sqlite3Message);
+            strcat(fullMessage, ": ");
+            strcat(fullMessage, message);
+            jniThrowException(env, exceptionClass, fullMessage);
+            free(fullMessage);
+        } else {
+            jniThrowException(env, exceptionClass, sqlite3Message);
+        }
+    } else if (sqlite3Message != NULL) {
+        jniThrowException(env, exceptionClass, sqlite3Message);
+    } else {
+        jniThrowException(env, exceptionClass, message);
+    }
+}
+
+
+} // namespace android
diff --git a/core/jni/android_database_SQLiteCommon.h b/core/jni/android_database_SQLiteCommon.h
new file mode 100644
index 0000000..0cac176
--- /dev/null
+++ b/core/jni/android_database_SQLiteCommon.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _ANDROID_DATABASE_SQLITE_COMMON_H
+#define _ANDROID_DATABASE_SQLITE_COMMON_H
+
+#include <jni.h>
+#include <JNIHelp.h>
+
+#include <sqlite3.h>
+
+// Special log tags defined in SQLiteDebug.java.
+#define SQLITE_LOG_TAG "SQLiteLog"
+#define SQLITE_TRACE_TAG "SQLiteStatements"
+#define SQLITE_PROFILE_TAG "SQLiteTime"
+
+namespace android {
+
+/* throw a SQLiteException with a message appropriate for the error in handle */
+void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle);
+
+/* throw a SQLiteException with the given message */
+void throw_sqlite3_exception(JNIEnv* env, const char* message);
+
+/* throw a SQLiteException with a message appropriate for the error in handle
+   concatenated with the given message
+ */
+void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message);
+
+/* throw a SQLiteException for a given error code */
+void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message);
+
+void throw_sqlite3_exception(JNIEnv* env, int errcode,
+        const char* sqlite3Message, const char* message);
+
+}
+
+#endif // _ANDROID_DATABASE_SQLITE_COMMON_H
diff --git a/core/jni/android_database_SQLiteCompiledSql.cpp b/core/jni/android_database_SQLiteCompiledSql.cpp
deleted file mode 100644
index 857267a..0000000
--- a/core/jni/android_database_SQLiteCompiledSql.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (C) 2006-2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "Cursor"
-
-#include <jni.h>
-#include <JNIHelp.h>
-#include <android_runtime/AndroidRuntime.h>
-
-#include <sqlite3.h>
-
-#include <utils/Log.h>
-
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "sqlite3_exception.h"
-
-
-namespace android {
-
-static jfieldID gHandleField;
-static jfieldID gStatementField;
-
-
-#define GET_STATEMENT(env, object) \
-        (sqlite3_stmt *)env->GetIntField(object, gStatementField)
-#define GET_HANDLE(env, object) \
-        (sqlite3 *)env->GetIntField(object, gHandleField)
-
-
-sqlite3_stmt * compile(JNIEnv* env, jobject object,
-                       sqlite3 * handle, jstring sqlString)
-{
-    int err;
-    jchar const * sql;
-    jsize sqlLen;
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-
-    // Make sure not to leak the statement if it already exists
-    if (statement != NULL) {
-        sqlite3_finalize(statement);
-        env->SetIntField(object, gStatementField, 0);
-    }
-
-    // Compile the SQL
-    sql = env->GetStringChars(sqlString, NULL);
-    sqlLen = env->GetStringLength(sqlString);
-    err = sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL);
-    env->ReleaseStringChars(sqlString, sql);
-
-    if (err == SQLITE_OK) {
-        // Store the statement in the Java object for future calls
-        ALOGV("Prepared statement %p on %p", statement, handle);
-        env->SetIntField(object, gStatementField, (int)statement);
-        return statement;
-    } else {
-        // Error messages like 'near ")": syntax error' are not
-        // always helpful enough, so construct an error string that
-        // includes the query itself.
-        const char *query = env->GetStringUTFChars(sqlString, NULL);
-        char *message = (char*) malloc(strlen(query) + 50);
-        if (message) {
-            strcpy(message, ", while compiling: "); // less than 50 chars
-            strcat(message, query);
-        }
-        env->ReleaseStringUTFChars(sqlString, query);
-        throw_sqlite3_exception(env, handle, message);
-        free(message);
-        return NULL;
-    }
-}
-
-static void native_compile(JNIEnv* env, jobject object, jstring sqlString)
-{
-    compile(env, object, GET_HANDLE(env, object), sqlString);
-}
-
-
-static JNINativeMethod sMethods[] =
-{
-     /* name, signature, funcPtr */
-    {"native_compile", "(Ljava/lang/String;)V", (void *)native_compile},
-};
-
-int register_android_database_SQLiteCompiledSql(JNIEnv * env)
-{
-    jclass clazz;
-
-    clazz = env->FindClass("android/database/sqlite/SQLiteCompiledSql");
-    if (clazz == NULL) {
-        ALOGE("Can't find android/database/sqlite/SQLiteCompiledSql");
-        return -1;
-    }
-
-    gHandleField = env->GetFieldID(clazz, "nHandle", "I");
-    gStatementField = env->GetFieldID(clazz, "nStatement", "I");
-
-    if (gHandleField == NULL || gStatementField == NULL) {
-        ALOGE("Error locating fields");
-        return -1;
-    }
-
-    return AndroidRuntime::registerNativeMethods(env,
-        "android/database/sqlite/SQLiteCompiledSql", sMethods, NELEM(sMethods));
-}
-
-} // namespace android
diff --git a/core/jni/android_database_SQLiteConnection.cpp b/core/jni/android_database_SQLiteConnection.cpp
new file mode 100644
index 0000000..d0d53f6
--- /dev/null
+++ b/core/jni/android_database_SQLiteConnection.cpp
@@ -0,0 +1,959 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SQLiteConnection"
+
+#include <jni.h>
+#include <JNIHelp.h>
+#include <android_runtime/AndroidRuntime.h>
+
+#include <utils/Log.h>
+#include <utils/String8.h>
+#include <utils/String16.h>
+#include <cutils/ashmem.h>
+#include <sys/mman.h>
+
+#include <string.h>
+#include <unistd.h>
+
+#include "binder/CursorWindow.h"
+
+#include <sqlite3.h>
+#include <sqlite3_android.h>
+
+#include "android_database_SQLiteCommon.h"
+
+#define UTF16_STORAGE 0
+#define ANDROID_TABLE "android_metadata"
+
+namespace android {
+
+static struct {
+    jfieldID name;
+    jfieldID numArgs;
+    jmethodID dispatchCallback;
+} gSQLiteCustomFunctionClassInfo;
+
+static struct {
+    jclass clazz;
+} gStringClassInfo;
+
+struct SQLiteConnection {
+    // Open flags.
+    // Must be kept in sync with the constants defined in SQLiteDatabase.java.
+    enum {
+        OPEN_READWRITE          = 0x00000000,
+        OPEN_READONLY           = 0x00000001,
+        OPEN_READ_MASK          = 0x00000001,
+        NO_LOCALIZED_COLLATORS  = 0x00000010,
+        CREATE_IF_NECESSARY     = 0x10000000,
+    };
+
+    sqlite3* const db;
+    const int openFlags;
+    const String8 path;
+    const String8 label;
+
+    SQLiteConnection(sqlite3* db, int openFlags, const String8& path, const String8& label) :
+        db(db), openFlags(openFlags), path(path), label(label) { }
+};
+
+// Called each time a statement begins execution, when tracing is enabled.
+static void sqliteTraceCallback(void *data, const char *sql) {
+    SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
+    ALOG(LOG_VERBOSE, SQLITE_TRACE_TAG, "%s: \"%s\"\n",
+            connection->label.string(), sql);
+}
+
+// Called each time a statement finishes execution, when profiling is enabled.
+static void sqliteProfileCallback(void *data, const char *sql, sqlite3_uint64 tm) {
+    SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
+    ALOG(LOG_VERBOSE, SQLITE_PROFILE_TAG, "%s: \"%s\" took %0.3f ms\n",
+            connection->label.string(), sql, tm * 0.000001f);
+}
+
+
+static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags,
+        jstring labelStr, jboolean enableTrace, jboolean enableProfile) {
+    int sqliteFlags;
+    if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) {
+        sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+    } else if (openFlags & SQLiteConnection::OPEN_READONLY) {
+        sqliteFlags = SQLITE_OPEN_READONLY;
+    } else {
+        sqliteFlags = SQLITE_OPEN_READWRITE;
+    }
+
+    const char* pathChars = env->GetStringUTFChars(pathStr, NULL);
+    String8 path(pathChars);
+    env->ReleaseStringUTFChars(pathStr, pathChars);
+
+    const char* labelChars = env->GetStringUTFChars(labelStr, NULL);
+    String8 label(labelChars);
+    env->ReleaseStringUTFChars(labelStr, labelChars);
+
+    sqlite3* db;
+    int err = sqlite3_open_v2(path.string(), &db, sqliteFlags, NULL);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception_errcode(env, err, "Could not open database");
+        return 0;
+    }
+
+    // Set the default busy handler to retry for 1000ms and then return SQLITE_BUSY
+    err = sqlite3_busy_timeout(db, 1000 /* ms */);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, db, "Could not set busy timeout");
+        sqlite3_close(db);
+        return 0;
+    }
+
+    // Enable WAL auto-checkpointing after a commit whenever at least one frame is in the log.
+    // This ensures that a checkpoint will occur after each transaction if needed.
+    err = sqlite3_wal_autocheckpoint(db, 1);
+    if (err) {
+        throw_sqlite3_exception(env, db, "Could not enable auto-checkpointing.");
+        sqlite3_close(db);
+        return 0;
+    }
+
+    // Register custom Android functions.
+    err = register_android_functions(db, UTF16_STORAGE);
+    if (err) {
+        throw_sqlite3_exception(env, db, "Could not register Android SQL functions.");
+        sqlite3_close(db);
+        return 0;
+    }
+
+    // Create wrapper object.
+    SQLiteConnection* connection = new SQLiteConnection(db, openFlags, path, label);
+
+    // Enable tracing and profiling if requested.
+    if (enableTrace) {
+        sqlite3_trace(db, &sqliteTraceCallback, connection);
+    }
+    if (enableProfile) {
+        sqlite3_profile(db, &sqliteProfileCallback, connection);
+    }
+
+    ALOGV("Opened connection %p with label '%s'", db, label.string());
+    return reinterpret_cast<jint>(connection);
+}
+
+static void nativeClose(JNIEnv* env, jclass clazz, jint connectionPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+
+    if (connection) {
+        ALOGV("Closing connection %p", connection->db);
+        int err = sqlite3_close(connection->db);
+        if (err != SQLITE_OK) {
+            // This can happen if sub-objects aren't closed first.  Make sure the caller knows.
+            ALOGE("sqlite3_close(%p) failed: %d", connection->db, err);
+            throw_sqlite3_exception(env, connection->db, "Count not close db.");
+            return;
+        }
+
+        delete connection;
+    }
+}
+
+// Called each time a custom function is evaluated.
+static void sqliteCustomFunctionCallback(sqlite3_context *context,
+        int argc, sqlite3_value **argv) {
+    JNIEnv* env = AndroidRuntime::getJNIEnv();
+
+    // Get the callback function object.
+    // Create a new local reference to it in case the callback tries to do something
+    // dumb like unregister the function (thereby destroying the global ref) while it is running.
+    jobject functionObjGlobal = reinterpret_cast<jobject>(sqlite3_user_data(context));
+    jobject functionObj = env->NewLocalRef(functionObjGlobal);
+
+    jobjectArray argsArray = env->NewObjectArray(argc, gStringClassInfo.clazz, NULL);
+    if (argsArray) {
+        for (int i = 0; i < argc; i++) {
+            const jchar* arg = static_cast<const jchar*>(sqlite3_value_text16(argv[i]));
+            if (!arg) {
+                ALOGW("NULL argument in custom_function_callback.  This should not happen.");
+            } else {
+                size_t argLen = sqlite3_value_bytes16(argv[i]) / sizeof(jchar);
+                jstring argStr = env->NewString(arg, argLen);
+                if (!argStr) {
+                    goto error; // out of memory error
+                }
+                env->SetObjectArrayElement(argsArray, i, argStr);
+                env->DeleteLocalRef(argStr);
+            }
+        }
+
+        // TODO: Support functions that return values.
+        env->CallVoidMethod(functionObj,
+                gSQLiteCustomFunctionClassInfo.dispatchCallback, argsArray);
+
+error:
+        env->DeleteLocalRef(argsArray);
+    }
+
+    env->DeleteLocalRef(functionObj);
+
+    if (env->ExceptionCheck()) {
+        ALOGE("An exception was thrown by custom SQLite function.");
+        LOGE_EX(env);
+        env->ExceptionClear();
+    }
+}
+
+// Called when a custom function is destroyed.
+static void sqliteCustomFunctionDestructor(void* data) {
+    jobject functionObjGlobal = reinterpret_cast<jobject>(data);
+
+    JNIEnv* env = AndroidRuntime::getJNIEnv();
+    env->DeleteGlobalRef(functionObjGlobal);
+}
+
+static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jobject functionObj) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+
+    jstring nameStr = jstring(env->GetObjectField(
+            functionObj, gSQLiteCustomFunctionClassInfo.name));
+    jint numArgs = env->GetIntField(functionObj, gSQLiteCustomFunctionClassInfo.numArgs);
+
+    jobject functionObjGlobal = env->NewGlobalRef(functionObj);
+
+    const char* name = env->GetStringUTFChars(nameStr, NULL);
+    int err = sqlite3_create_function_v2(connection->db, name, numArgs, SQLITE_UTF16,
+            reinterpret_cast<void*>(functionObjGlobal),
+            &sqliteCustomFunctionCallback, NULL, NULL, &sqliteCustomFunctionDestructor);
+    env->ReleaseStringUTFChars(nameStr, name);
+
+    if (err != SQLITE_OK) {
+        ALOGE("sqlite3_create_function returned %d", err);
+        env->DeleteGlobalRef(functionObjGlobal);
+        throw_sqlite3_exception(env, connection->db);
+        return;
+    }
+}
+
+// Set locale in the android_metadata table, install localized collators, and rebuild indexes
+static void nativeSetLocale(JNIEnv* env, jclass clazz, jint connectionPtr, jstring localeStr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+
+    if (connection->openFlags & SQLiteConnection::NO_LOCALIZED_COLLATORS) {
+        // We should probably throw IllegalStateException but the contract for
+        // setLocale says that we just do nothing.  Oh well.
+        return;
+    }
+
+    int err;
+    char const* locale = env->GetStringUTFChars(localeStr, NULL);
+    sqlite3_stmt* stmt = NULL;
+    char** meta = NULL;
+    int rowCount, colCount;
+    char* dbLocale = NULL;
+
+    // create the table, if necessary and possible
+    if (!(connection->openFlags & SQLiteConnection::OPEN_READONLY)) {
+        err = sqlite3_exec(connection->db,
+                "CREATE TABLE IF NOT EXISTS " ANDROID_TABLE " (locale TEXT)",
+                NULL, NULL, NULL);
+        if (err != SQLITE_OK) {
+            ALOGE("CREATE TABLE " ANDROID_TABLE " failed");
+            throw_sqlite3_exception(env, connection->db);
+            goto done;
+        }
+    }
+
+    // try to read from the table
+    err = sqlite3_get_table(connection->db,
+            "SELECT locale FROM " ANDROID_TABLE " LIMIT 1",
+            &meta, &rowCount, &colCount, NULL);
+    if (err != SQLITE_OK) {
+        ALOGE("SELECT locale FROM " ANDROID_TABLE " failed");
+        throw_sqlite3_exception(env, connection->db);
+        goto done;
+    }
+
+    dbLocale = (rowCount >= 1) ? meta[colCount] : NULL;
+
+    if (dbLocale != NULL && !strcmp(dbLocale, locale)) {
+        // database locale is the same as the desired locale; set up the collators and go
+        err = register_localized_collators(connection->db, locale, UTF16_STORAGE);
+        if (err != SQLITE_OK) {
+            throw_sqlite3_exception(env, connection->db);
+        }
+        goto done;   // no database changes needed
+    }
+
+    if (connection->openFlags & SQLiteConnection::OPEN_READONLY) {
+        // read-only database, so we're going to have to put up with whatever we got
+        // For registering new index. Not for modifing the read-only database.
+        err = register_localized_collators(connection->db, locale, UTF16_STORAGE);
+        if (err != SQLITE_OK) {
+            throw_sqlite3_exception(env, connection->db);
+        }
+        goto done;
+    }
+
+    // need to update android_metadata and indexes atomically, so use a transaction...
+    err = sqlite3_exec(connection->db, "BEGIN TRANSACTION", NULL, NULL, NULL);
+    if (err != SQLITE_OK) {
+        ALOGE("BEGIN TRANSACTION failed setting locale");
+        throw_sqlite3_exception(env, connection->db);
+        goto done;
+    }
+
+    err = register_localized_collators(connection->db, locale, UTF16_STORAGE);
+    if (err != SQLITE_OK) {
+        ALOGE("register_localized_collators() failed setting locale");
+        throw_sqlite3_exception(env, connection->db);
+        goto rollback;
+    }
+
+    err = sqlite3_exec(connection->db, "DELETE FROM " ANDROID_TABLE, NULL, NULL, NULL);
+    if (err != SQLITE_OK) {
+        ALOGE("DELETE failed setting locale");
+        throw_sqlite3_exception(env, connection->db);
+        goto rollback;
+    }
+
+    static const char *sql = "INSERT INTO " ANDROID_TABLE " (locale) VALUES(?);";
+    err = sqlite3_prepare_v2(connection->db, sql, -1, &stmt, NULL);
+    if (err != SQLITE_OK) {
+        ALOGE("sqlite3_prepare_v2(\"%s\") failed", sql);
+        throw_sqlite3_exception(env, connection->db);
+        goto rollback;
+    }
+
+    err = sqlite3_bind_text(stmt, 1, locale, -1, SQLITE_TRANSIENT);
+    if (err != SQLITE_OK) {
+        ALOGE("sqlite3_bind_text() failed setting locale");
+        throw_sqlite3_exception(env, connection->db);
+        goto rollback;
+    }
+
+    err = sqlite3_step(stmt);
+    if (err != SQLITE_OK && err != SQLITE_DONE) {
+        ALOGE("sqlite3_step(\"%s\") failed setting locale", sql);
+        throw_sqlite3_exception(env, connection->db);
+        goto rollback;
+    }
+
+    err = sqlite3_exec(connection->db, "REINDEX LOCALIZED", NULL, NULL, NULL);
+    if (err != SQLITE_OK) {
+        ALOGE("REINDEX LOCALIZED failed");
+        throw_sqlite3_exception(env, connection->db);
+        goto rollback;
+    }
+
+    // all done, yay!
+    err = sqlite3_exec(connection->db, "COMMIT TRANSACTION", NULL, NULL, NULL);
+    if (err != SQLITE_OK) {
+        ALOGE("COMMIT TRANSACTION failed setting locale");
+        throw_sqlite3_exception(env, connection->db);
+        goto done;
+    }
+
+rollback:
+    if (err != SQLITE_OK) {
+        sqlite3_exec(connection->db, "ROLLBACK TRANSACTION", NULL, NULL, NULL);
+    }
+
+done:
+    if (stmt) {
+        sqlite3_finalize(stmt);
+    }
+    if (meta) {
+        sqlite3_free_table(meta);
+    }
+    if (locale) {
+        env->ReleaseStringUTFChars(localeStr, locale);
+    }
+}
+
+static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jstring sqlString) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+
+    jsize sqlLength = env->GetStringLength(sqlString);
+    const jchar* sql = env->GetStringCritical(sqlString, NULL);
+    sqlite3_stmt* statement;
+    int err = sqlite3_prepare16_v2(connection->db,
+            sql, sqlLength * sizeof(jchar), &statement, NULL);
+    env->ReleaseStringCritical(sqlString, sql);
+
+    if (err != SQLITE_OK) {
+        // Error messages like 'near ")": syntax error' are not
+        // always helpful enough, so construct an error string that
+        // includes the query itself.
+        const char *query = env->GetStringUTFChars(sqlString, NULL);
+        char *message = (char*) malloc(strlen(query) + 50);
+        if (message) {
+            strcpy(message, ", while compiling: "); // less than 50 chars
+            strcat(message, query);
+        }
+        env->ReleaseStringUTFChars(sqlString, query);
+        throw_sqlite3_exception(env, connection->db, message);
+        free(message);
+        return 0;
+    }
+
+    ALOGV("Prepared statement %p on connection %p", statement, connection->db);
+    return reinterpret_cast<jint>(statement);
+}
+
+static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    ALOGV("Finalized statement %p on connection %p", statement, connection->db);
+    int err = sqlite3_finalize(statement);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    return sqlite3_bind_parameter_count(statement);
+}
+
+static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    return sqlite3_stmt_readonly(statement) != 0;
+}
+
+static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    return sqlite3_column_count(statement);
+}
+
+static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr, jint index) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    const jchar* name = static_cast<const jchar*>(sqlite3_column_name16(statement, index));
+    if (name) {
+        size_t length = 0;
+        while (name[length]) {
+            length += 1;
+        }
+        return env->NewString(name, length);
+    }
+    return NULL;
+}
+
+static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr, jint index) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = sqlite3_bind_null(statement, index);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr, jint index, jlong value) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = sqlite3_bind_int64(statement, index, value);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr, jint index, jdouble value) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = sqlite3_bind_double(statement, index, value);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr, jint index, jstring valueString) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    jsize valueLength = env->GetStringLength(valueString);
+    const jchar* value = env->GetStringCritical(valueString, NULL);
+    int err = sqlite3_bind_text16(statement, index, value, valueLength * sizeof(jchar),
+            SQLITE_TRANSIENT);
+    env->ReleaseStringCritical(valueString, value);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr, jint index, jbyteArray valueArray) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    jsize valueLength = env->GetArrayLength(valueArray);
+    jbyte* value = static_cast<jbyte*>(env->GetPrimitiveArrayCritical(valueArray, NULL));
+    int err = sqlite3_bind_blob(statement, index, value, valueLength, SQLITE_TRANSIENT);
+    env->ReleasePrimitiveArrayCritical(valueArray, value, JNI_ABORT);
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = sqlite3_reset(statement);
+    if (err == SQLITE_OK) {
+        err = sqlite3_clear_bindings(statement);
+    }
+    if (err != SQLITE_OK) {
+        throw_sqlite3_exception(env, connection->db, NULL);
+    }
+}
+
+static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {
+    int err = sqlite3_step(statement);
+    if (err == SQLITE_ROW) {
+        throw_sqlite3_exception(env,
+                "Queries can be performed using SQLiteDatabase query or rawQuery methods only.");
+    } else if (err != SQLITE_DONE) {
+        throw_sqlite3_exception_errcode(env, err, sqlite3_errmsg(connection->db));
+    }
+    return err;
+}
+
+static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr,
+        jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    executeNonQuery(env, connection, statement);
+}
+
+static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz,
+        jint connectionPtr, jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = executeNonQuery(env, connection, statement);
+    return err == SQLITE_DONE ? sqlite3_changes(connection->db) : -1;
+}
+
+static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz,
+        jint connectionPtr, jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = executeNonQuery(env, connection, statement);
+    return err == SQLITE_DONE && sqlite3_changes(connection->db) > 0
+            ? sqlite3_last_insert_rowid(connection->db) : -1;
+}
+
+static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {
+    int err = sqlite3_step(statement);
+    if (err != SQLITE_ROW) {
+        throw_sqlite3_exception_errcode(env, err, sqlite3_errmsg(connection->db));
+    }
+    return err;
+}
+
+static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz,
+        jint connectionPtr, jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = executeOneRowQuery(env, connection, statement);
+    if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
+        return sqlite3_column_int64(statement, 0);
+    }
+    return -1;
+}
+
+static jstring nativeExecuteForString(JNIEnv* env, jclass clazz,
+        jint connectionPtr, jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = executeOneRowQuery(env, connection, statement);
+    if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
+        const jchar* text = static_cast<const jchar*>(sqlite3_column_text16(statement, 0));
+        if (text) {
+            size_t length = sqlite3_column_bytes16(statement, 0) / sizeof(jchar);
+            return env->NewString(text, length);
+        }
+    }
+    return NULL;
+}
+
+static int createAshmemRegionWithData(JNIEnv* env, const void* data, size_t length) {
+    int error = 0;
+    int fd = ashmem_create_region(NULL, length);
+    if (fd < 0) {
+        error = errno;
+        ALOGE("ashmem_create_region failed: %s", strerror(error));
+    } else {
+        if (length > 0) {
+            void* ptr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+            if (ptr == MAP_FAILED) {
+                error = errno;
+                ALOGE("mmap failed: %s", strerror(error));
+            } else {
+                memcpy(ptr, data, length);
+                munmap(ptr, length);
+            }
+        }
+
+        if (!error) {
+            if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
+                error = errno;
+                ALOGE("ashmem_set_prot_region failed: %s", strerror(errno));
+            } else {
+                return fd;
+            }
+        }
+
+        close(fd);
+    }
+
+    jniThrowIOException(env, error);
+    return -1;
+}
+
+static jint nativeExecuteForBlobFileDescriptor(JNIEnv* env, jclass clazz,
+        jint connectionPtr, jint statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    int err = executeOneRowQuery(env, connection, statement);
+    if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
+        const void* blob = sqlite3_column_blob(statement, 0);
+        if (blob) {
+            int length = sqlite3_column_bytes(statement, 0);
+            if (length >= 0) {
+                return createAshmemRegionWithData(env, blob, length);
+            }
+        }
+    }
+    return -1;
+}
+
+enum CopyRowResult {
+    CPR_OK,
+    CPR_FULL,
+    CPR_ERROR,
+};
+
+static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
+        sqlite3_stmt* statement, int numColumns, int startPos, int addedRows) {
+    // Allocate a new field directory for the row.
+    status_t status = window->allocRow();
+    if (status) {
+        LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
+                startPos, addedRows, status);
+        return CPR_FULL;
+    }
+
+    // Pack the row into the window.
+    CopyRowResult result = CPR_OK;
+    for (int i = 0; i < numColumns; i++) {
+        int type = sqlite3_column_type(statement, i);
+        if (type == SQLITE_TEXT) {
+            // TEXT data
+            const char* text = reinterpret_cast<const char*>(
+                    sqlite3_column_text(statement, i));
+            // SQLite does not include the NULL terminator in size, but does
+            // ensure all strings are NULL terminated, so increase size by
+            // one to make sure we store the terminator.
+            size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
+            status = window->putString(addedRows, i, text, sizeIncludingNull);
+            if (status) {
+                LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
+                        sizeIncludingNull, startPos + addedRows, i, status);
+                result = CPR_FULL;
+                break;
+            }
+            LOG_WINDOW("%d,%d is TEXT with %u bytes",
+                    startPos + addedRows, i, sizeIncludingNull);
+        } else if (type == SQLITE_INTEGER) {
+            // INTEGER data
+            int64_t value = sqlite3_column_int64(statement, i);
+            status = window->putLong(addedRows, i, value);
+            if (status) {
+                LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
+                        i, status);
+                result = CPR_FULL;
+                break;
+            }
+            LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
+        } else if (type == SQLITE_FLOAT) {
+            // FLOAT data
+            double value = sqlite3_column_double(statement, i);
+            status = window->putDouble(addedRows, i, value);
+            if (status) {
+                LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
+                        i, status);
+                result = CPR_FULL;
+                break;
+            }
+            LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
+        } else if (type == SQLITE_BLOB) {
+            // BLOB data
+            const void* blob = sqlite3_column_blob(statement, i);
+            size_t size = sqlite3_column_bytes(statement, i);
+            status = window->putBlob(addedRows, i, blob, size);
+            if (status) {
+                LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
+                        size, startPos + addedRows, i, status);
+                result = CPR_FULL;
+                break;
+            }
+            LOG_WINDOW("%d,%d is Blob with %u bytes",
+                    startPos + addedRows, i, size);
+        } else if (type == SQLITE_NULL) {
+            // NULL field
+            status = window->putNull(addedRows, i);
+            if (status) {
+                LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
+                        i, status);
+                result = CPR_FULL;
+                break;
+            }
+
+            LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
+        } else {
+            // Unknown data
+            ALOGE("Unknown column type when filling database window");
+            throw_sqlite3_exception(env, "Unknown column type when filling window");
+            result = CPR_ERROR;
+            break;
+        }
+    }
+
+    // Free the last row if if was not successfully copied.
+    if (result != CPR_OK) {
+        window->freeLastRow();
+    }
+    return result;
+}
+
+static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz,
+        jint connectionPtr, jint statementPtr, jint windowPtr,
+        jint startPos, jint requiredPos, jboolean countAllRows) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+    CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
+
+    status_t status = window->clear();
+    if (status) {
+        String8 msg;
+        msg.appendFormat("Failed to clear the cursor window, status=%d", status);
+        throw_sqlite3_exception(env, connection->db, msg.string());
+        return 0;
+    }
+
+    int numColumns = sqlite3_column_count(statement);
+    status = window->setNumColumns(numColumns);
+    if (status) {
+        String8 msg;
+        msg.appendFormat("Failed to set the cursor window column count to %d, status=%d",
+                numColumns, status);
+        throw_sqlite3_exception(env, connection->db, msg.string());
+        return 0;
+    }
+
+    int retryCount = 0;
+    int totalRows = 0;
+    int addedRows = 0;
+    bool windowFull = false;
+    bool gotException = false;
+    while (!gotException && (!windowFull || countAllRows)) {
+        int err = sqlite3_step(statement);
+        if (err == SQLITE_ROW) {
+            LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
+            retryCount = 0;
+            totalRows += 1;
+
+            // Skip the row if the window is full or we haven't reached the start position yet.
+            if (startPos >= totalRows || windowFull) {
+                continue;
+            }
+
+            CopyRowResult cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
+            if (cpr == CPR_FULL && addedRows && startPos + addedRows < requiredPos) {
+                // We filled the window before we got to the one row that we really wanted.
+                // Clear the window and start filling it again from here.
+                // TODO: Would be nicer if we could progressively replace earlier rows.
+                window->clear();
+                window->setNumColumns(numColumns);
+                startPos += addedRows;
+                addedRows = 0;
+                cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
+            }
+
+            if (cpr == CPR_OK) {
+                addedRows += 1;
+            } else if (cpr == CPR_FULL) {
+                windowFull = true;
+            } else {
+                gotException = true;
+            }
+        } else if (err == SQLITE_DONE) {
+            // All rows processed, bail
+            LOG_WINDOW("Processed all rows");
+            break;
+        } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {
+            // The table is locked, retry
+            LOG_WINDOW("Database locked, retrying");
+            if (retryCount > 50) {
+                ALOGE("Bailing on database busy retry");
+                throw_sqlite3_exception(env, connection->db, "retrycount exceeded");
+                gotException = true;
+            } else {
+                // Sleep to give the thread holding the lock a chance to finish
+                usleep(1000);
+                retryCount++;
+            }
+        } else {
+            throw_sqlite3_exception(env, connection->db);
+            gotException = true;
+        }
+    }
+
+    LOG_WINDOW("Resetting statement %p after fetching %d rows and adding %d rows"
+            "to the window in %d bytes",
+            statement, totalRows, addedRows, window->size() - window->freeSpace());
+    sqlite3_reset(statement);
+
+    // Report the total number of rows on request.
+    if (startPos > totalRows) {
+        ALOGE("startPos %d > actual rows %d", startPos, totalRows);
+    }
+    jlong result = jlong(startPos) << 32 | jlong(totalRows);
+    return result;
+}
+
+static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+
+    int cur = -1;
+    int unused;
+    sqlite3_db_status(connection->db, SQLITE_DBSTATUS_LOOKASIDE_USED, &cur, &unused, 0);
+    return cur;
+}
+
+
+static JNINativeMethod sMethods[] =
+{
+    /* name, signature, funcPtr */
+    { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)I",
+            (void*)nativeOpen },
+    { "nativeClose", "(I)V",
+            (void*)nativeClose },
+    { "nativeRegisterCustomFunction", "(ILandroid/database/sqlite/SQLiteCustomFunction;)V",
+            (void*)nativeRegisterCustomFunction },
+    { "nativeSetLocale", "(ILjava/lang/String;)V",
+            (void*)nativeSetLocale },
+    { "nativePrepareStatement", "(ILjava/lang/String;)I",
+            (void*)nativePrepareStatement },
+    { "nativeFinalizeStatement", "(II)V",
+            (void*)nativeFinalizeStatement },
+    { "nativeGetParameterCount", "(II)I",
+            (void*)nativeGetParameterCount },
+    { "nativeIsReadOnly", "(II)Z",
+            (void*)nativeIsReadOnly },
+    { "nativeGetColumnCount", "(II)I",
+            (void*)nativeGetColumnCount },
+    { "nativeGetColumnName", "(III)Ljava/lang/String;",
+            (void*)nativeGetColumnName },
+    { "nativeBindNull", "(III)V",
+            (void*)nativeBindNull },
+    { "nativeBindLong", "(IIIJ)V",
+            (void*)nativeBindLong },
+    { "nativeBindDouble", "(IIID)V",
+            (void*)nativeBindDouble },
+    { "nativeBindString", "(IIILjava/lang/String;)V",
+            (void*)nativeBindString },
+    { "nativeBindBlob", "(III[B)V",
+            (void*)nativeBindBlob },
+    { "nativeResetStatementAndClearBindings", "(II)V",
+            (void*)nativeResetStatementAndClearBindings },
+    { "nativeExecute", "(II)V",
+            (void*)nativeExecute },
+    { "nativeExecuteForLong", "(II)J",
+            (void*)nativeExecuteForLong },
+    { "nativeExecuteForString", "(II)Ljava/lang/String;",
+            (void*)nativeExecuteForString },
+    { "nativeExecuteForBlobFileDescriptor", "(II)I",
+            (void*)nativeExecuteForBlobFileDescriptor },
+    { "nativeExecuteForChangedRowCount", "(II)I",
+            (void*)nativeExecuteForChangedRowCount },
+    { "nativeExecuteForLastInsertedRowId", "(II)J",
+            (void*)nativeExecuteForLastInsertedRowId },
+    { "nativeExecuteForCursorWindow", "(IIIIIZ)J",
+            (void*)nativeExecuteForCursorWindow },
+    { "nativeGetDbLookaside", "(I)I",
+            (void*)nativeGetDbLookaside },
+};
+
+#define FIND_CLASS(var, className) \
+        var = env->FindClass(className); \
+        LOG_FATAL_IF(! var, "Unable to find class " className);
+
+#define GET_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
+        var = env->GetMethodID(clazz, methodName, fieldDescriptor); \
+        LOG_FATAL_IF(! var, "Unable to find method" methodName);
+
+#define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
+        var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
+        LOG_FATAL_IF(! var, "Unable to find field " fieldName);
+
+int register_android_database_SQLiteConnection(JNIEnv *env)
+{
+    jclass clazz;
+    FIND_CLASS(clazz, "android/database/sqlite/SQLiteCustomFunction");
+
+    GET_FIELD_ID(gSQLiteCustomFunctionClassInfo.name, clazz,
+            "name", "Ljava/lang/String;");
+    GET_FIELD_ID(gSQLiteCustomFunctionClassInfo.numArgs, clazz,
+            "numArgs", "I");
+    GET_METHOD_ID(gSQLiteCustomFunctionClassInfo.dispatchCallback,
+            clazz, "dispatchCallback", "([Ljava/lang/String;)V");
+
+    FIND_CLASS(clazz, "java/lang/String");
+    gStringClassInfo.clazz = jclass(env->NewGlobalRef(clazz));
+
+    return AndroidRuntime::registerNativeMethods(env, "android/database/sqlite/SQLiteConnection",
+            sMethods, NELEM(sMethods));
+}
+
+} // namespace android
diff --git a/core/jni/android_database_SQLiteDatabase.cpp b/core/jni/android_database_SQLiteDatabase.cpp
deleted file mode 100644
index 28c421d..0000000
--- a/core/jni/android_database_SQLiteDatabase.cpp
+++ /dev/null
@@ -1,636 +0,0 @@
-/*
- * Copyright (C) 2006-2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "SqliteDatabaseCpp"
-
-#include <utils/Log.h>
-#include <utils/String8.h>
-#include <utils/String16.h>
-
-#include <jni.h>
-#include <JNIHelp.h>
-#include <android_runtime/AndroidRuntime.h>
-
-#include <sqlite3.h>
-#include <sqlite3_android.h>
-#include <string.h>
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <utils/List.h>
-#include <utils/Errors.h>
-#include <ctype.h>
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <string.h>
-#include <netdb.h>
-#include <sys/ioctl.h>
-
-#include "sqlite3_exception.h"
-
-#define UTF16_STORAGE 0
-#define INVALID_VERSION -1
-#define ANDROID_TABLE "android_metadata"
-/* uncomment the next line to force-enable logging of all statements */
-// #define DB_LOG_STATEMENTS
-
-#define DEBUG_JNI 0
-
-namespace android {
-
-enum {
-    OPEN_READWRITE          = 0x00000000,
-    OPEN_READONLY           = 0x00000001,
-    OPEN_READ_MASK          = 0x00000001,
-    NO_LOCALIZED_COLLATORS  = 0x00000010,
-    CREATE_IF_NECESSARY     = 0x10000000
-};
-
-static jfieldID offset_db_handle;
-static jmethodID method_custom_function_callback;
-static jclass string_class;
-static jint sSqliteSoftHeapLimit = 0;
-
-static char *createStr(const char *path, short extra) {
-    int len = strlen(path) + extra;
-    char *str = (char *)malloc(len + 1);
-    strncpy(str, path, len);
-    str[len] = NULL;
-    return str;
-}
-
-static void sqlLogger(void *databaseName, int iErrCode, const char *zMsg) {
-    // skip printing this message if it is due to certain types of errors
-    if (iErrCode == 0 || iErrCode == SQLITE_CONSTRAINT) return;
-    // print databasename, errorcode and msg
-    ALOGI("sqlite returned: error code = %d, msg = %s, db=%s\n", iErrCode, zMsg, databaseName);
-}
-
-// register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called.
-static void registerLoggingFunc(const char *path) {
-    static bool loggingFuncSet = false;
-    if (loggingFuncSet) {
-        return;
-    }
-
-    ALOGV("Registering sqlite logging func \n");
-    int err = sqlite3_config(SQLITE_CONFIG_LOG, &sqlLogger, (void *)createStr(path, 0));
-    if (err != SQLITE_OK) {
-        ALOGW("sqlite returned error = %d when trying to register logging func.\n", err);
-        return;
-    }
-    loggingFuncSet = true;
-}
-
-/* public native void dbopen(String path, int flags, String locale); */
-static void dbopen(JNIEnv* env, jobject object, jstring pathString, jint flags)
-{
-    int err;
-    sqlite3 * handle = NULL;
-    sqlite3_stmt * statement = NULL;
-    char const * path8 = env->GetStringUTFChars(pathString, NULL);
-    int sqliteFlags;
-
-    // register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called.
-    registerLoggingFunc(path8);
-
-    // convert our flags into the sqlite flags
-    if (flags & CREATE_IF_NECESSARY) {
-        sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
-    } else if (flags & OPEN_READONLY) {
-        sqliteFlags = SQLITE_OPEN_READONLY;
-    } else {
-        sqliteFlags = SQLITE_OPEN_READWRITE;
-    }
-
-    err = sqlite3_open_v2(path8, &handle, sqliteFlags, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("sqlite3_open_v2(\"%s\", &handle, %d, NULL) failed\n", path8, sqliteFlags);
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-    // The soft heap limit prevents the page cache allocations from growing
-    // beyond the given limit, no matter what the max page cache sizes are
-    // set to. The limit does not, as of 3.5.0, affect any other allocations.
-    sqlite3_soft_heap_limit(sSqliteSoftHeapLimit);
-
-    // Set the default busy handler to retry for 1000ms and then return SQLITE_BUSY
-    err = sqlite3_busy_timeout(handle, 1000 /* ms */);
-    if (err != SQLITE_OK) {
-        ALOGE("sqlite3_busy_timeout(handle, 1000) failed for \"%s\"\n", path8);
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-#ifdef DB_INTEGRITY_CHECK
-    static const char* integritySql = "pragma integrity_check(1);";
-    err = sqlite3_prepare_v2(handle, integritySql, -1, &statement, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("sqlite_prepare_v2(handle, \"%s\") failed for \"%s\"\n", integritySql, path8);
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-    // first is OK or error message
-    err = sqlite3_step(statement);
-    if (err != SQLITE_ROW) {
-        ALOGE("integrity check failed for \"%s\"\n", integritySql, path8);
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    } else {
-        const char *text = (const char*)sqlite3_column_text(statement, 0);
-        if (strcmp(text, "ok") != 0) {
-            ALOGE("integrity check failed for \"%s\": %s\n", integritySql, path8, text);
-            jniThrowException(env, "android/database/sqlite/SQLiteDatabaseCorruptException", text);
-            goto done;
-        }
-    }
-#endif
-
-    err = register_android_functions(handle, UTF16_STORAGE);
-    if (err) {
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-    ALOGV("Opened '%s' - %p\n", path8, handle);
-    env->SetIntField(object, offset_db_handle, (int) handle);
-    handle = NULL;  // The caller owns the handle now.
-
-done:
-    // Release allocated resources
-    if (path8 != NULL) env->ReleaseStringUTFChars(pathString, path8);
-    if (statement != NULL) sqlite3_finalize(statement);
-    if (handle != NULL) sqlite3_close(handle);
-}
-
-static char *getDatabaseName(JNIEnv* env, sqlite3 * handle, jstring databaseName, short connNum) {
-    char const *path = env->GetStringUTFChars(databaseName, NULL);
-    if (path == NULL) {
-        ALOGE("Failure in getDatabaseName(). VM ran out of memory?\n");
-        return NULL; // VM would have thrown OutOfMemoryError
-    }
-    char *dbNameStr = createStr(path, 4);
-    if (connNum > 999) { // TODO: if number of pooled connections > 999, fix this line.
-      connNum = -1;
-    }
-    sprintf(dbNameStr + strlen(path), "|%03d", connNum);
-    env->ReleaseStringUTFChars(databaseName, path);
-    return dbNameStr;
-}
-
-static void sqlTrace(void *databaseName, const char *sql) {
-    ALOGI("sql_statement|%s|%s\n", (char *)databaseName, sql);
-}
-
-/* public native void enableSqlTracing(); */
-static void enableSqlTracing(JNIEnv* env, jobject object, jstring databaseName, jshort connType)
-{
-    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
-    sqlite3_trace(handle, &sqlTrace, (void *)getDatabaseName(env, handle, databaseName, connType));
-}
-
-static void sqlProfile(void *databaseName, const char *sql, sqlite3_uint64 tm) {
-    double d = tm/1000000.0;
-    ALOGI("elapsedTime4Sql|%s|%.3f ms|%s\n", (char *)databaseName, d, sql);
-}
-
-/* public native void enableSqlProfiling(); */
-static void enableSqlProfiling(JNIEnv* env, jobject object, jstring databaseName, jshort connType)
-{
-    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
-    sqlite3_profile(handle, &sqlProfile, (void *)getDatabaseName(env, handle, databaseName,
-            connType));
-}
-
-/* public native void close(); */
-static void dbclose(JNIEnv* env, jobject object)
-{
-    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
-
-    if (handle != NULL) {
-        // release the memory associated with the traceFuncArg in enableSqlTracing function
-        void *traceFuncArg = sqlite3_trace(handle, &sqlTrace, NULL);
-        if (traceFuncArg != NULL) {
-            free(traceFuncArg);
-        }
-        // release the memory associated with the traceFuncArg in enableSqlProfiling function
-        traceFuncArg = sqlite3_profile(handle, &sqlProfile, NULL);
-        if (traceFuncArg != NULL) {
-            free(traceFuncArg);
-        }
-        ALOGV("Closing database: handle=%p\n", handle);
-        int result = sqlite3_close(handle);
-        if (result == SQLITE_OK) {
-            ALOGV("Closed %p\n", handle);
-            env->SetIntField(object, offset_db_handle, 0);
-        } else {
-            // This can happen if sub-objects aren't closed first.  Make sure the caller knows.
-            throw_sqlite3_exception(env, handle);
-            ALOGE("sqlite3_close(%p) failed: %d\n", handle, result);
-        }
-    }
-}
-
-/* native int native_getDbLookaside(); */
-static jint native_getDbLookaside(JNIEnv* env, jobject object)
-{
-    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
-    int pCur = -1;
-    int unused;
-    sqlite3_db_status(handle, SQLITE_DBSTATUS_LOOKASIDE_USED, &pCur, &unused, 0);
-    return pCur;
-}
-
-/* set locale in the android_metadata table, install localized collators, and rebuild indexes */
-static void native_setLocale(JNIEnv* env, jobject object, jstring localeString, jint flags)
-{
-    if ((flags & NO_LOCALIZED_COLLATORS)) return;
-
-    int err;
-    char const* locale8 = env->GetStringUTFChars(localeString, NULL);
-    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
-    sqlite3_stmt* stmt = NULL;
-    char** meta = NULL;
-    int rowCount, colCount;
-    char* dbLocale = NULL;
-
-    // create the table, if necessary and possible
-    if (!(flags & OPEN_READONLY)) {
-        static const char *createSql ="CREATE TABLE IF NOT EXISTS " ANDROID_TABLE " (locale TEXT)";
-        err = sqlite3_exec(handle, createSql, NULL, NULL, NULL);
-        if (err != SQLITE_OK) {
-            ALOGE("CREATE TABLE " ANDROID_TABLE " failed\n");
-            throw_sqlite3_exception(env, handle);
-            goto done;
-        }
-    }
-
-    // try to read from the table
-    static const char *selectSql = "SELECT locale FROM " ANDROID_TABLE " LIMIT 1";
-    err = sqlite3_get_table(handle, selectSql, &meta, &rowCount, &colCount, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("SELECT locale FROM " ANDROID_TABLE " failed\n");
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-    dbLocale = (rowCount >= 1) ? meta[colCount] : NULL;
-
-    if (dbLocale != NULL && !strcmp(dbLocale, locale8)) {
-        // database locale is the same as the desired locale; set up the collators and go
-        err = register_localized_collators(handle, locale8, UTF16_STORAGE);
-        if (err != SQLITE_OK) throw_sqlite3_exception(env, handle);
-        goto done;   // no database changes needed
-    }
-
-    if ((flags & OPEN_READONLY)) {
-        // read-only database, so we're going to have to put up with whatever we got
-        // For registering new index. Not for modifing the read-only database.
-        err = register_localized_collators(handle, locale8, UTF16_STORAGE);
-        if (err != SQLITE_OK) throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-    // need to update android_metadata and indexes atomically, so use a transaction...
-    err = sqlite3_exec(handle, "BEGIN TRANSACTION", NULL, NULL, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("BEGIN TRANSACTION failed setting locale\n");
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-    err = register_localized_collators(handle, locale8, UTF16_STORAGE);
-    if (err != SQLITE_OK) {
-        ALOGE("register_localized_collators() failed setting locale\n");
-        throw_sqlite3_exception(env, handle);
-        goto rollback;
-    }
-
-    err = sqlite3_exec(handle, "DELETE FROM " ANDROID_TABLE, NULL, NULL, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("DELETE failed setting locale\n");
-        throw_sqlite3_exception(env, handle);
-        goto rollback;
-    }
-
-    static const char *sql = "INSERT INTO " ANDROID_TABLE " (locale) VALUES(?);";
-    err = sqlite3_prepare_v2(handle, sql, -1, &stmt, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("sqlite3_prepare_v2(\"%s\") failed\n", sql);
-        throw_sqlite3_exception(env, handle);
-        goto rollback;
-    }
-
-    err = sqlite3_bind_text(stmt, 1, locale8, -1, SQLITE_TRANSIENT);
-    if (err != SQLITE_OK) {
-        ALOGE("sqlite3_bind_text() failed setting locale\n");
-        throw_sqlite3_exception(env, handle);
-        goto rollback;
-    }
-
-    err = sqlite3_step(stmt);
-    if (err != SQLITE_OK && err != SQLITE_DONE) {
-        ALOGE("sqlite3_step(\"%s\") failed setting locale\n", sql);
-        throw_sqlite3_exception(env, handle);
-        goto rollback;
-    }
-
-    err = sqlite3_exec(handle, "REINDEX LOCALIZED", NULL, NULL, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("REINDEX LOCALIZED failed\n");
-        throw_sqlite3_exception(env, handle);
-        goto rollback;
-    }
-
-    // all done, yay!
-    err = sqlite3_exec(handle, "COMMIT TRANSACTION", NULL, NULL, NULL);
-    if (err != SQLITE_OK) {
-        ALOGE("COMMIT TRANSACTION failed setting locale\n");
-        throw_sqlite3_exception(env, handle);
-        goto done;
-    }
-
-rollback:
-    if (err != SQLITE_OK) {
-        sqlite3_exec(handle, "ROLLBACK TRANSACTION", NULL, NULL, NULL);
-    }
-
-done:
-    if (locale8 != NULL) env->ReleaseStringUTFChars(localeString, locale8);
-    if (stmt != NULL) sqlite3_finalize(stmt);
-    if (meta != NULL) sqlite3_free_table(meta);
-}
-
-static void native_setSqliteSoftHeapLimit(JNIEnv* env, jobject clazz, jint limit) {
-    sSqliteSoftHeapLimit = limit;
-}
-
-static jint native_releaseMemory(JNIEnv *env, jobject clazz)
-{
-    // Attempt to release as much memory from the
-    return sqlite3_release_memory(sSqliteSoftHeapLimit);
-}
-
-static void native_finalize(JNIEnv* env, jobject object, jint statementId)
-{
-    if (statementId > 0) {
-        sqlite3_finalize((sqlite3_stmt *)statementId);
-    }
-}
-
-static void custom_function_callback(sqlite3_context * context, int argc, sqlite3_value ** argv) {
-    JNIEnv* env = AndroidRuntime::getJNIEnv();
-    if (!env) {
-        ALOGE("custom_function_callback cannot call into Java on this thread");
-        return;
-    }
-    // get global ref to CustomFunction object from our user data
-    jobject function = (jobject)sqlite3_user_data(context);
-
-    // pack up the arguments into a string array
-    jobjectArray strArray = env->NewObjectArray(argc, string_class, NULL);
-    if (!strArray)
-        goto done;
-    for (int i = 0; i < argc; i++) {
-        char* arg = (char *)sqlite3_value_text(argv[i]);
-        if (!arg) {
-            ALOGE("NULL argument in custom_function_callback.  This should not happen.");
-            return;
-        }
-        jobject obj = env->NewStringUTF(arg);
-        if (!obj)
-            goto done;
-        env->SetObjectArrayElement(strArray, i, obj);
-        env->DeleteLocalRef(obj);
-    }
-
-    env->CallVoidMethod(function, method_custom_function_callback, strArray);
-    env->DeleteLocalRef(strArray);
-
-done:
-    if (env->ExceptionCheck()) {
-        ALOGE("An exception was thrown by custom sqlite3 function.");
-        LOGE_EX(env);
-        env->ExceptionClear();
-    }
-}
-
-static jint native_addCustomFunction(JNIEnv* env, jobject object,
-        jstring name, jint numArgs, jobject function)
-{
-    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
-    char const *nameStr = env->GetStringUTFChars(name, NULL);
-    jobject ref = env->NewGlobalRef(function);
-    ALOGD_IF(DEBUG_JNI, "native_addCustomFunction %s ref: %p", nameStr, ref);
-    int err = sqlite3_create_function(handle, nameStr, numArgs, SQLITE_UTF8,
-            (void *)ref, custom_function_callback, NULL, NULL);
-    env->ReleaseStringUTFChars(name, nameStr);
-
-    if (err == SQLITE_OK)
-        return (int)ref;
-    else {
-        ALOGE("sqlite3_create_function returned %d", err);
-        env->DeleteGlobalRef(ref);
-        throw_sqlite3_exception(env, handle);
-        return 0;
-     }
-}
-
-static void native_releaseCustomFunction(JNIEnv* env, jobject object, jint ref)
-{
-    ALOGD_IF(DEBUG_JNI, "native_releaseCustomFunction %d", ref);
-    env->DeleteGlobalRef((jobject)ref);
-}
-
-static JNINativeMethod sMethods[] =
-{
-    /* name, signature, funcPtr */
-    {"dbopen", "(Ljava/lang/String;I)V", (void *)dbopen},
-    {"dbclose", "()V", (void *)dbclose},
-    {"enableSqlTracing", "(Ljava/lang/String;S)V", (void *)enableSqlTracing},
-    {"enableSqlProfiling", "(Ljava/lang/String;S)V", (void *)enableSqlProfiling},
-    {"native_setLocale", "(Ljava/lang/String;I)V", (void *)native_setLocale},
-    {"native_getDbLookaside", "()I", (void *)native_getDbLookaside},
-    {"native_setSqliteSoftHeapLimit", "(I)V", (void *)native_setSqliteSoftHeapLimit},
-    {"releaseMemory", "()I", (void *)native_releaseMemory},
-    {"native_finalize", "(I)V", (void *)native_finalize},
-    {"native_addCustomFunction",
-                    "(Ljava/lang/String;ILandroid/database/sqlite/SQLiteDatabase$CustomFunction;)I",
-                    (void *)native_addCustomFunction},
-    {"native_releaseCustomFunction", "(I)V", (void *)native_releaseCustomFunction},
-};
-
-int register_android_database_SQLiteDatabase(JNIEnv *env)
-{
-    jclass clazz;
-
-    clazz = env->FindClass("android/database/sqlite/SQLiteDatabase");
-    if (clazz == NULL) {
-        ALOGE("Can't find android/database/sqlite/SQLiteDatabase\n");
-        return -1;
-    }
-
-    string_class = (jclass)env->NewGlobalRef(env->FindClass("java/lang/String"));
-    if (string_class == NULL) {
-        ALOGE("Can't find java/lang/String\n");
-        return -1;
-    }
-
-    offset_db_handle = env->GetFieldID(clazz, "mNativeHandle", "I");
-    if (offset_db_handle == NULL) {
-        ALOGE("Can't find SQLiteDatabase.mNativeHandle\n");
-        return -1;
-    }
-
-    clazz = env->FindClass("android/database/sqlite/SQLiteDatabase$CustomFunction");
-    if (clazz == NULL) {
-        ALOGE("Can't find android/database/sqlite/SQLiteDatabase$CustomFunction\n");
-        return -1;
-    }
-    method_custom_function_callback = env->GetMethodID(clazz, "callback", "([Ljava/lang/String;)V");
-    if (method_custom_function_callback == NULL) {
-        ALOGE("Can't find method SQLiteDatabase.CustomFunction.callback\n");
-        return -1;
-    }
-
-    return AndroidRuntime::registerNativeMethods(env, "android/database/sqlite/SQLiteDatabase",
-            sMethods, NELEM(sMethods));
-}
-
-/* throw a SQLiteException with a message appropriate for the error in handle */
-void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle) {
-    throw_sqlite3_exception(env, handle, NULL);
-}
-
-/* throw a SQLiteException with the given message */
-void throw_sqlite3_exception(JNIEnv* env, const char* message) {
-    throw_sqlite3_exception(env, NULL, message);
-}
-
-/* throw a SQLiteException with a message appropriate for the error in handle
-   concatenated with the given message
- */
-void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message) {
-    if (handle) {
-        throw_sqlite3_exception(env, sqlite3_errcode(handle),
-                                sqlite3_errmsg(handle), message);
-    } else {
-        // we use SQLITE_OK so that a generic SQLiteException is thrown;
-        // any code not specified in the switch statement below would do.
-        throw_sqlite3_exception(env, SQLITE_OK, "unknown error", message);
-    }
-}
-
-/* throw a SQLiteException for a given error code */
-void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message) {
-    if (errcode == SQLITE_DONE) {
-        throw_sqlite3_exception(env, errcode, NULL, message);
-    } else {
-        char temp[21];
-        sprintf(temp, "error code %d", errcode);
-        throw_sqlite3_exception(env, errcode, temp, message);
-    }
-}
-
-/* throw a SQLiteException for a given error code, sqlite3message, and
-   user message
- */
-void throw_sqlite3_exception(JNIEnv* env, int errcode,
-                             const char* sqlite3Message, const char* message) {
-    const char* exceptionClass;
-    switch (errcode) {
-        case SQLITE_IOERR:
-            exceptionClass = "android/database/sqlite/SQLiteDiskIOException";
-            break;
-        case SQLITE_CORRUPT:
-        case SQLITE_NOTADB: // treat "unsupported file format" error as corruption also
-            exceptionClass = "android/database/sqlite/SQLiteDatabaseCorruptException";
-            break;
-        case SQLITE_CONSTRAINT:
-           exceptionClass = "android/database/sqlite/SQLiteConstraintException";
-           break;
-        case SQLITE_ABORT:
-           exceptionClass = "android/database/sqlite/SQLiteAbortException";
-           break;
-        case SQLITE_DONE:
-           exceptionClass = "android/database/sqlite/SQLiteDoneException";
-           break;
-        case SQLITE_FULL:
-           exceptionClass = "android/database/sqlite/SQLiteFullException";
-           break;
-        case SQLITE_MISUSE:
-           exceptionClass = "android/database/sqlite/SQLiteMisuseException";
-           break;
-        case SQLITE_PERM:
-           exceptionClass = "android/database/sqlite/SQLiteAccessPermException";
-           break;
-        case SQLITE_BUSY:
-           exceptionClass = "android/database/sqlite/SQLiteDatabaseLockedException";
-           break;
-        case SQLITE_LOCKED:
-           exceptionClass = "android/database/sqlite/SQLiteTableLockedException";
-           break;
-        case SQLITE_READONLY:
-           exceptionClass = "android/database/sqlite/SQLiteReadOnlyDatabaseException";
-           break;
-        case SQLITE_CANTOPEN:
-           exceptionClass = "android/database/sqlite/SQLiteCantOpenDatabaseException";
-           break;
-        case SQLITE_TOOBIG:
-           exceptionClass = "android/database/sqlite/SQLiteBlobTooBigException";
-           break;
-        case SQLITE_RANGE:
-           exceptionClass = "android/database/sqlite/SQLiteBindOrColumnIndexOutOfRangeException";
-           break;
-        case SQLITE_NOMEM:
-           exceptionClass = "android/database/sqlite/SQLiteOutOfMemoryException";
-           break;
-        case SQLITE_MISMATCH:
-           exceptionClass = "android/database/sqlite/SQLiteDatatypeMismatchException";
-           break;
-        case SQLITE_UNCLOSED:
-           exceptionClass = "android/database/sqlite/SQLiteUnfinalizedObjectsException";
-           break;
-        default:
-           exceptionClass = "android/database/sqlite/SQLiteException";
-           break;
-    }
-
-    if (sqlite3Message != NULL && message != NULL) {
-        char* fullMessage = (char *)malloc(strlen(sqlite3Message) + strlen(message) + 3);
-        if (fullMessage != NULL) {
-            strcpy(fullMessage, sqlite3Message);
-            strcat(fullMessage, ": ");
-            strcat(fullMessage, message);
-            jniThrowException(env, exceptionClass, fullMessage);
-            free(fullMessage);
-        } else {
-            jniThrowException(env, exceptionClass, sqlite3Message);
-        }
-    } else if (sqlite3Message != NULL) {
-        jniThrowException(env, exceptionClass, sqlite3Message);
-    } else {
-        jniThrowException(env, exceptionClass, message);
-    }
-}
-
-
-} // namespace android
diff --git a/core/jni/android_database_SQLiteGlobal.cpp b/core/jni/android_database_SQLiteGlobal.cpp
new file mode 100644
index 0000000..82cae5a
--- /dev/null
+++ b/core/jni/android_database_SQLiteGlobal.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SQLiteGlobal"
+
+#include <jni.h>
+#include <JNIHelp.h>
+#include <android_runtime/AndroidRuntime.h>
+
+#include <sqlite3.h>
+#include <sqlite3_android.h>
+
+#include "android_database_SQLiteCommon.h"
+
+namespace android {
+
+// Called each time a message is logged.
+static void sqliteLogCallback(void* data, int iErrCode, const char* zMsg) {
+    bool verboseLog = !!data;
+    if (iErrCode == 0 || iErrCode == SQLITE_CONSTRAINT) {
+        if (verboseLog) {
+            ALOGV(LOG_VERBOSE, SQLITE_LOG_TAG, "(%d) %s\n", iErrCode, zMsg);
+        }
+    } else {
+        ALOG(LOG_ERROR, SQLITE_LOG_TAG, "(%d) %s\n", iErrCode, zMsg);
+    }
+}
+
+// Sets the global SQLite configuration.
+// This must be called before any other SQLite functions are called. */
+static void nativeConfig(JNIEnv* env, jclass clazz, jboolean verboseLog, jint softHeapLimit) {
+    // Enable multi-threaded mode.  In this mode, SQLite is safe to use by multiple
+    // threads as long as no two threads use the same database connection at the same
+    // time (which we guarantee in the SQLite database wrappers).
+    sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
+
+    // Redirect SQLite log messages to the Android log.
+    sqlite3_config(SQLITE_CONFIG_LOG, &sqliteLogCallback, verboseLog ? (void*)1 : NULL);
+
+    // The soft heap limit prevents the page cache allocations from growing
+    // beyond the given limit, no matter what the max page cache sizes are
+    // set to. The limit does not, as of 3.5.0, affect any other allocations.
+    sqlite3_soft_heap_limit(softHeapLimit);
+}
+
+static jint nativeReleaseMemory(JNIEnv* env, jclass clazz, jint bytesToFree) {
+    return sqlite3_release_memory(bytesToFree);
+}
+
+static JNINativeMethod sMethods[] =
+{
+    /* name, signature, funcPtr */
+    { "nativeConfig", "(ZI)V",
+            (void*)nativeConfig },
+    { "nativeReleaseMemory", "(I)I",
+            (void*)nativeReleaseMemory },
+};
+
+int register_android_database_SQLiteGlobal(JNIEnv *env)
+{
+    return AndroidRuntime::registerNativeMethods(env, "android/database/sqlite/SQLiteGlobal",
+            sMethods, NELEM(sMethods));
+}
+
+} // namespace android
diff --git a/core/jni/android_database_SQLiteProgram.cpp b/core/jni/android_database_SQLiteProgram.cpp
deleted file mode 100644
index 2e34c00..0000000
--- a/core/jni/android_database_SQLiteProgram.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (C) 2006-2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "Cursor"
-
-#include <jni.h>
-#include <JNIHelp.h>
-#include <android_runtime/AndroidRuntime.h>
-
-#include <sqlite3.h>
-
-#include <utils/Log.h>
-
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "sqlite3_exception.h"
-
-
-namespace android {
-
-static jfieldID gHandleField;
-static jfieldID gStatementField;
-
-
-#define GET_STATEMENT(env, object) \
-        (sqlite3_stmt *)env->GetIntField(object, gStatementField)
-#define GET_HANDLE(env, object) \
-        (sqlite3 *)env->GetIntField(object, gHandleField)
-
-static void native_compile(JNIEnv* env, jobject object, jstring sqlString)
-{
-    char buf[65];
-    strcpy(buf, "android_database_SQLiteProgram->native_compile() not implemented");
-    throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-    return;
-}
-
-static void native_bind_null(JNIEnv* env, jobject object,
-                             jint index)
-{
-    int err;
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-
-    err = sqlite3_bind_null(statement, index);
-    if (err != SQLITE_OK) {
-        char buf[32];
-        sprintf(buf, "handle %p", statement);
-        throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-        return;
-    }
-}
-
-static void native_bind_long(JNIEnv* env, jobject object,
-                             jint index, jlong value)
-{
-    int err;
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-
-    err = sqlite3_bind_int64(statement, index, value);
-    if (err != SQLITE_OK) {
-        char buf[32];
-        sprintf(buf, "handle %p", statement);
-        throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-        return;
-    }
-}
-
-static void native_bind_double(JNIEnv* env, jobject object,
-                             jint index, jdouble value)
-{
-    int err;
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-
-    err = sqlite3_bind_double(statement, index, value);
-    if (err != SQLITE_OK) {
-        char buf[32];
-        sprintf(buf, "handle %p", statement);
-        throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-        return;
-    }
-}
-
-static void native_bind_string(JNIEnv* env, jobject object,
-                               jint index, jstring sqlString)
-{
-    int err;
-    jchar const * sql;
-    jsize sqlLen;
-    sqlite3_stmt * statement= GET_STATEMENT(env, object);
-
-    sql = env->GetStringChars(sqlString, NULL);
-    sqlLen = env->GetStringLength(sqlString);
-    err = sqlite3_bind_text16(statement, index, sql, sqlLen * 2, SQLITE_TRANSIENT);
-    env->ReleaseStringChars(sqlString, sql);
-    if (err != SQLITE_OK) {
-        char buf[32];
-        sprintf(buf, "handle %p", statement);
-        throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-        return;
-    }
-}
-
-static void native_bind_blob(JNIEnv* env, jobject object,
-                               jint index, jbyteArray value)
-{
-    int err;
-    jchar const * sql;
-    jsize sqlLen;
-    sqlite3_stmt * statement= GET_STATEMENT(env, object);
-
-    jint len = env->GetArrayLength(value);
-    jbyte * bytes = env->GetByteArrayElements(value, NULL);
-
-    err = sqlite3_bind_blob(statement, index, bytes, len, SQLITE_TRANSIENT);
-    env->ReleaseByteArrayElements(value, bytes, JNI_ABORT);
-
-    if (err != SQLITE_OK) {
-        char buf[32];
-        sprintf(buf, "statement %p", statement);
-        throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-        return;
-    }
-}
-
-static void native_clear_bindings(JNIEnv* env, jobject object)
-{
-    int err;
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-
-    err = sqlite3_clear_bindings(statement);
-    if (err != SQLITE_OK) {
-        throw_sqlite3_exception(env, GET_HANDLE(env, object));
-        return;
-    }
-}
-
-static void native_finalize(JNIEnv* env, jobject object)
-{
-    char buf[66];
-    strcpy(buf, "android_database_SQLiteProgram->native_finalize() not implemented");
-    throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
-    return;
-}
-
-
-static JNINativeMethod sMethods[] =
-{
-     /* name, signature, funcPtr */
-    {"native_bind_null", "(I)V", (void *)native_bind_null},
-    {"native_bind_long", "(IJ)V", (void *)native_bind_long},
-    {"native_bind_double", "(ID)V", (void *)native_bind_double},
-    {"native_bind_string", "(ILjava/lang/String;)V", (void *)native_bind_string},
-    {"native_bind_blob", "(I[B)V", (void *)native_bind_blob},
-    {"native_clear_bindings", "()V", (void *)native_clear_bindings},
-};
-
-int register_android_database_SQLiteProgram(JNIEnv * env)
-{
-    jclass clazz;
-
-    clazz = env->FindClass("android/database/sqlite/SQLiteProgram");
-    if (clazz == NULL) {
-        ALOGE("Can't find android/database/sqlite/SQLiteProgram");
-        return -1;
-    }
-
-    gHandleField = env->GetFieldID(clazz, "nHandle", "I");
-    gStatementField = env->GetFieldID(clazz, "nStatement", "I");
-
-    if (gHandleField == NULL || gStatementField == NULL) {
-        ALOGE("Error locating fields");
-        return -1;
-    }
-
-    return AndroidRuntime::registerNativeMethods(env,
-        "android/database/sqlite/SQLiteProgram", sMethods, NELEM(sMethods));
-}
-
-} // namespace android
diff --git a/core/jni/android_database_SQLiteQuery.cpp b/core/jni/android_database_SQLiteQuery.cpp
deleted file mode 100644
index da7ccf0..0000000
--- a/core/jni/android_database_SQLiteQuery.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "SqliteCursor.cpp"
-
-#include <jni.h>
-#include <JNIHelp.h>
-#include <android_runtime/AndroidRuntime.h>
-
-#include <sqlite3.h>
-
-#include <utils/Log.h>
-
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "binder/CursorWindow.h"
-#include "sqlite3_exception.h"
-
-
-namespace android {
-
-enum CopyRowResult {
-    CPR_OK,
-    CPR_FULL,
-    CPR_ERROR,
-};
-
-static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
-        sqlite3_stmt* statement, int numColumns, int startPos, int addedRows) {
-    // Allocate a new field directory for the row. This pointer is not reused
-    // since it may be possible for it to be relocated on a call to alloc() when
-    // the field data is being allocated.
-    status_t status = window->allocRow();
-    if (status) {
-        LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
-                startPos, addedRows, status);
-        return CPR_FULL;
-    }
-
-    // Pack the row into the window.
-    CopyRowResult result = CPR_OK;
-    for (int i = 0; i < numColumns; i++) {
-        int type = sqlite3_column_type(statement, i);
-        if (type == SQLITE_TEXT) {
-            // TEXT data
-            const char* text = reinterpret_cast<const char*>(
-                    sqlite3_column_text(statement, i));
-            // SQLite does not include the NULL terminator in size, but does
-            // ensure all strings are NULL terminated, so increase size by
-            // one to make sure we store the terminator.
-            size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
-            status = window->putString(addedRows, i, text, sizeIncludingNull);
-            if (status) {
-                LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
-                        sizeIncludingNull, startPos + addedRows, i, status);
-                result = CPR_FULL;
-                break;
-            }
-            LOG_WINDOW("%d,%d is TEXT with %u bytes",
-                    startPos + addedRows, i, sizeIncludingNull);
-        } else if (type == SQLITE_INTEGER) {
-            // INTEGER data
-            int64_t value = sqlite3_column_int64(statement, i);
-            status = window->putLong(addedRows, i, value);
-            if (status) {
-                LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
-                        i, status);
-                result = CPR_FULL;
-                break;
-            }
-            LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
-        } else if (type == SQLITE_FLOAT) {
-            // FLOAT data
-            double value = sqlite3_column_double(statement, i);
-            status = window->putDouble(addedRows, i, value);
-            if (status) {
-                LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
-                        i, status);
-                result = CPR_FULL;
-                break;
-            }
-            LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
-        } else if (type == SQLITE_BLOB) {
-            // BLOB data
-            const void* blob = sqlite3_column_blob(statement, i);
-            size_t size = sqlite3_column_bytes(statement, i);
-            status = window->putBlob(addedRows, i, blob, size);
-            if (status) {
-                LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
-                        size, startPos + addedRows, i, status);
-                result = CPR_FULL;
-                break;
-            }
-            LOG_WINDOW("%d,%d is Blob with %u bytes",
-                    startPos + addedRows, i, size);
-        } else if (type == SQLITE_NULL) {
-            // NULL field
-            status = window->putNull(addedRows, i);
-            if (status) {
-                LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
-                        i, status);
-                result = CPR_FULL;
-                break;
-            }
-
-            LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
-        } else {
-            // Unknown data
-            ALOGE("Unknown column type when filling database window");
-            throw_sqlite3_exception(env, "Unknown column type when filling window");
-            result = CPR_ERROR;
-            break;
-        }
-    }
-
-    // Free the last row if if was not successfully copied.
-    if (result != CPR_OK) {
-        window->freeLastRow();
-    }
-    return result;
-}
-
-static jlong nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
-        jint statementPtr, jint windowPtr, jint offsetParam,
-        jint startPos, jint requiredPos, jboolean countAllRows) {
-    sqlite3* database = reinterpret_cast<sqlite3*>(databasePtr);
-    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
-    CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
-
-    // Only do the binding if there is a valid offsetParam. If no binding needs to be done
-    // offsetParam will be set to 0, an invalid value.
-    if (offsetParam > 0) {
-        // Bind the offset parameter, telling the program which row to start with
-        // If an offset parameter is used, we cannot simply clear the window if it
-        // turns out that the requiredPos won't fit because the result set may
-        // depend on startPos, so we set startPos to requiredPos.
-        startPos = requiredPos;
-        int err = sqlite3_bind_int(statement, offsetParam, startPos);
-        if (err != SQLITE_OK) {
-            ALOGE("Unable to bind offset position, offsetParam = %d", offsetParam);
-            throw_sqlite3_exception(env, database);
-            return 0;
-        }
-        LOG_WINDOW("Bound offset position to startPos %d", startPos);
-    }
-
-    // We assume numRows is initially 0.
-    LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d",
-            window->getNumRows(), window->size(), window->freeSpace());
-
-    int numColumns = sqlite3_column_count(statement);
-    status_t status = window->setNumColumns(numColumns);
-    if (status) {
-        ALOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns);
-        jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch");
-        return 0;
-    }
-
-    int retryCount = 0;
-    int totalRows = 0;
-    int addedRows = 0;
-    bool windowFull = false;
-    bool gotException = false;
-    while (!gotException && (!windowFull || countAllRows)) {
-        int err = sqlite3_step(statement);
-        if (err == SQLITE_ROW) {
-            LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
-            retryCount = 0;
-            totalRows += 1;
-
-            // Skip the row if the window is full or we haven't reached the start position yet.
-            if (startPos >= totalRows || windowFull) {
-                continue;
-            }
-
-            CopyRowResult cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
-            if (cpr == CPR_FULL && addedRows && startPos + addedRows < requiredPos) {
-                // We filled the window before we got to the one row that we really wanted.
-                // Clear the window and start filling it again from here.
-                // TODO: Would be nicer if we could progressively replace earlier rows.
-                window->clear();
-                window->setNumColumns(numColumns);
-                startPos += addedRows;
-                addedRows = 0;
-                cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
-            }
-
-            if (cpr == CPR_OK) {
-                addedRows += 1;
-            } else if (cpr == CPR_FULL) {
-                windowFull = true;
-            } else {
-                gotException = true;
-            }
-        } else if (err == SQLITE_DONE) {
-            // All rows processed, bail
-            LOG_WINDOW("Processed all rows");
-            break;
-        } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {
-            // The table is locked, retry
-            LOG_WINDOW("Database locked, retrying");
-            if (retryCount > 50) {
-                ALOGE("Bailing on database busy retry");
-                throw_sqlite3_exception(env, database, "retrycount exceeded");
-                gotException = true;
-            } else {
-                // Sleep to give the thread holding the lock a chance to finish
-                usleep(1000);
-                retryCount++;
-            }
-        } else {
-            throw_sqlite3_exception(env, database);
-            gotException = true;
-        }
-    }
-
-    LOG_WINDOW("Resetting statement %p after fetching %d rows and adding %d rows"
-            "to the window in %d bytes",
-            statement, totalRows, addedRows, window->size() - window->freeSpace());
-    sqlite3_reset(statement);
-
-    // Report the total number of rows on request.
-    if (startPos > totalRows) {
-        ALOGE("startPos %d > actual rows %d", startPos, totalRows);
-    }
-    jlong result = jlong(startPos) << 32 | jlong(totalRows);
-    return result;
-}
-
-static jint nativeColumnCount(JNIEnv* env, jclass clazz, jint statementPtr) {
-    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
-    return sqlite3_column_count(statement);
-}
-
-static jstring nativeColumnName(JNIEnv* env, jclass clazz, jint statementPtr,
-        jint columnIndex) {
-    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
-    const char* name = sqlite3_column_name(statement, columnIndex);
-    return env->NewStringUTF(name);
-}
-
-
-static JNINativeMethod sMethods[] =
-{
-     /* name, signature, funcPtr */
-    { "nativeFillWindow", "(IIIIIIZ)J",
-            (void*)nativeFillWindow },
-    { "nativeColumnCount", "(I)I",
-            (void*)nativeColumnCount},
-    { "nativeColumnName", "(II)Ljava/lang/String;",
-            (void*)nativeColumnName},
-};
-
-int register_android_database_SQLiteQuery(JNIEnv * env)
-{
-    return AndroidRuntime::registerNativeMethods(env,
-        "android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods));
-}
-
-} // namespace android
diff --git a/core/jni/android_database_SQLiteStatement.cpp b/core/jni/android_database_SQLiteStatement.cpp
deleted file mode 100644
index e376258..0000000
--- a/core/jni/android_database_SQLiteStatement.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-/* //device/libs/android_runtime/android_database_SQLiteCursor.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#undef LOG_TAG
-#define LOG_TAG "SQLiteStatementCpp"
-
-#include "android_util_Binder.h"
-
-#include <jni.h>
-#include <JNIHelp.h>
-#include <android_runtime/AndroidRuntime.h>
-
-#include <sqlite3.h>
-
-#include <cutils/ashmem.h>
-#include <utils/Log.h>
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include "sqlite3_exception.h"
-
-namespace android {
-
-
-sqlite3_stmt * compile(JNIEnv* env, jobject object,
-                       sqlite3 * handle, jstring sqlString);
-
-static jfieldID gHandleField;
-static jfieldID gStatementField;
-
-
-#define GET_STATEMENT(env, object) \
-        (sqlite3_stmt *)env->GetIntField(object, gStatementField)
-#define GET_HANDLE(env, object) \
-        (sqlite3 *)env->GetIntField(object, gHandleField)
-
-
-static jint native_execute(JNIEnv* env, jobject object)
-{
-    int err;
-    sqlite3 * handle = GET_HANDLE(env, object);
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-    int numChanges = -1;
-
-    // Execute the statement
-    err = sqlite3_step(statement);
-
-    // Throw an exception if an error occurred
-    if (err == SQLITE_ROW) {
-        throw_sqlite3_exception(env,
-                "Queries can be performed using SQLiteDatabase query or rawQuery methods only.");
-    } else if (err != SQLITE_DONE) {
-        throw_sqlite3_exception_errcode(env, err, sqlite3_errmsg(handle));
-    } else {
-        numChanges = sqlite3_changes(handle);
-    }
-
-    // Reset the statement so it's ready to use again
-    sqlite3_reset(statement);
-    return numChanges;
-}
-
-static jlong native_executeInsert(JNIEnv* env, jobject object)
-{
-    sqlite3 * handle = GET_HANDLE(env, object);
-    jint numChanges = native_execute(env, object);
-    if (numChanges > 0) {
-        return sqlite3_last_insert_rowid(handle);
-    } else {
-        return -1;
-    }
-}
-
-static jlong native_1x1_long(JNIEnv* env, jobject object)
-{
-    int err;
-    sqlite3 * handle = GET_HANDLE(env, object);
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-    jlong value = -1;
-
-    // Execute the statement
-    err = sqlite3_step(statement);
-
-    // Handle the result
-    if (err == SQLITE_ROW) {
-        // No errors, read the data and return it
-        value = sqlite3_column_int64(statement, 0);
-    } else {
-        throw_sqlite3_exception_errcode(env, err, sqlite3_errmsg(handle));
-    }
-
-    // Reset the statment so it's ready to use again
-    sqlite3_reset(statement);
-
-    return value;
-}
-
-static jstring native_1x1_string(JNIEnv* env, jobject object)
-{
-    int err;
-    sqlite3 * handle = GET_HANDLE(env, object);
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-    jstring value = NULL;
-
-    // Execute the statement
-    err = sqlite3_step(statement);
-
-    // Handle the result
-    if (err == SQLITE_ROW) {
-        // No errors, read the data and return it
-        char const * text = (char const *)sqlite3_column_text(statement, 0);
-        value = env->NewStringUTF(text);
-    } else {
-        throw_sqlite3_exception_errcode(env, err, sqlite3_errmsg(handle));
-    }
-
-    // Reset the statment so it's ready to use again
-    sqlite3_reset(statement);
-
-    return value;
-}
-
-static jobject createParcelFileDescriptor(JNIEnv * env, int fd)
-{
-    // Create FileDescriptor object
-    jobject fileDesc = jniCreateFileDescriptor(env, fd);
-    if (fileDesc == NULL) {
-        // FileDescriptor constructor has thrown an exception
-        close(fd);
-        return NULL;
-    }
-
-    // Wrap it in a ParcelFileDescriptor
-    jobject parcelFileDesc = newParcelFileDescriptor(env, fileDesc);
-    if (parcelFileDesc == NULL) {
-        // ParcelFileDescriptor constructor has thrown an exception
-        close(fd);
-        return NULL;
-    }
-
-    return parcelFileDesc;
-}
-
-// Creates an ashmem area, copies some data into it, and returns
-// a ParcelFileDescriptor for the ashmem area.
-static jobject create_ashmem_region_with_data(JNIEnv * env,
-                                              const void * data, int length)
-{
-    // Create ashmem area
-    int fd = ashmem_create_region(NULL, length);
-    if (fd < 0) {
-        ALOGE("ashmem_create_region failed: %s", strerror(errno));
-        jniThrowIOException(env, errno);
-        return NULL;
-    }
-
-    if (length > 0) {
-        // mmap the ashmem area
-        void * ashmem_ptr =
-                mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-        if (ashmem_ptr == MAP_FAILED) {
-            ALOGE("mmap failed: %s", strerror(errno));
-            jniThrowIOException(env, errno);
-            close(fd);
-            return NULL;
-        }
-
-        // Copy data to ashmem area
-        memcpy(ashmem_ptr, data, length);
-
-        // munmap ashmem area
-        if (munmap(ashmem_ptr, length) < 0) {
-            ALOGE("munmap failed: %s", strerror(errno));
-            jniThrowIOException(env, errno);
-            close(fd);
-            return NULL;
-        }
-    }
-
-    // Make ashmem area read-only
-    if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
-        ALOGE("ashmem_set_prot_region failed: %s", strerror(errno));
-        jniThrowIOException(env, errno);
-        close(fd);
-        return NULL;
-    }
-
-    // Wrap it in a ParcelFileDescriptor
-    return createParcelFileDescriptor(env, fd);
-}
-
-static jobject native_1x1_blob_ashmem(JNIEnv* env, jobject object)
-{
-    int err;
-    sqlite3 * handle = GET_HANDLE(env, object);
-    sqlite3_stmt * statement = GET_STATEMENT(env, object);
-    jobject value = NULL;
-
-    // Execute the statement
-    err = sqlite3_step(statement);
-
-    // Handle the result
-    if (err == SQLITE_ROW) {
-        // No errors, read the data and return it
-        const void * blob = sqlite3_column_blob(statement, 0);
-        if (blob != NULL) {
-            int len = sqlite3_column_bytes(statement, 0);
-            if (len >= 0) {
-                value = create_ashmem_region_with_data(env, blob, len);
-            }
-        }
-    } else {
-        throw_sqlite3_exception_errcode(env, err, sqlite3_errmsg(handle));
-    }
-
-    // Reset the statment so it's ready to use again
-    sqlite3_reset(statement);
-
-    return value;
-}
-
-static void native_executeSql(JNIEnv* env, jobject object, jstring sql)
-{
-    char const* sqlString = env->GetStringUTFChars(sql, NULL);
-    sqlite3 * handle = GET_HANDLE(env, object);
-    int err = sqlite3_exec(handle, sqlString, NULL, NULL, NULL);
-    if (err != SQLITE_OK) {
-        throw_sqlite3_exception(env, handle);
-    }
-    env->ReleaseStringUTFChars(sql, sqlString);
-}
-
-static JNINativeMethod sMethods[] =
-{
-     /* name, signature, funcPtr */
-    {"native_execute", "()I", (void *)native_execute},
-    {"native_executeInsert", "()J", (void *)native_executeInsert},
-    {"native_1x1_long", "()J", (void *)native_1x1_long},
-    {"native_1x1_string", "()Ljava/lang/String;", (void *)native_1x1_string},
-    {"native_1x1_blob_ashmem", "()Landroid/os/ParcelFileDescriptor;", (void *)native_1x1_blob_ashmem},
-    {"native_executeSql", "(Ljava/lang/String;)V", (void *)native_executeSql},
-};
-
-int register_android_database_SQLiteStatement(JNIEnv * env)
-{
-    jclass clazz;
-
-    clazz = env->FindClass("android/database/sqlite/SQLiteStatement");
-    if (clazz == NULL) {
-        ALOGE("Can't find android/database/sqlite/SQLiteStatement");
-        return -1;
-    }
-
-    gHandleField = env->GetFieldID(clazz, "nHandle", "I");
-    gStatementField = env->GetFieldID(clazz, "nStatement", "I");
-
-    if (gHandleField == NULL || gStatementField == NULL) {
-        ALOGE("Error locating fields");
-        return -1;
-    }
-
-    return AndroidRuntime::registerNativeMethods(env,
-        "android/database/sqlite/SQLiteStatement", sMethods, NELEM(sMethods));
-}
-
-} // namespace android
diff --git a/core/jni/sqlite3_exception.h b/core/jni/sqlite3_exception.h
deleted file mode 100644
index 13735a1..0000000
--- a/core/jni/sqlite3_exception.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* //device/libs/include/android_runtime/sqlite3_exception.h
-**
-** Copyright 2007, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#ifndef _SQLITE3_EXCEPTION_H
-#define _SQLITE3_EXCEPTION_H 1
-
-#include <jni.h>
-#include <JNIHelp.h>
-//#include <android_runtime/AndroidRuntime.h>
-
-#include <sqlite3.h>
-
-namespace android {
-
-/* throw a SQLiteException with a message appropriate for the error in handle */
-void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle);
-
-/* throw a SQLiteException with the given message */
-void throw_sqlite3_exception(JNIEnv* env, const char* message);
-
-/* throw a SQLiteException with a message appropriate for the error in handle
-   concatenated with the given message
- */
-void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message);
-
-/* throw a SQLiteException for a given error code */
-void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message);
-
-void throw_sqlite3_exception(JNIEnv* env, int errcode,
-                             const char* sqlite3Message, const char* message);
-}
-
-#endif // _SQLITE3_EXCEPTION_H
diff --git a/core/tests/coretests/src/android/database/sqlite/DatabaseConnectionPoolTest.java b/core/tests/coretests/src/android/database/sqlite/DatabaseConnectionPoolTest.java
deleted file mode 100644
index 525dd2d..0000000
--- a/core/tests/coretests/src/android/database/sqlite/DatabaseConnectionPoolTest.java
+++ /dev/null
@@ -1,368 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.database.sqlite;
-
-import android.content.Context;
-import android.database.sqlite.SQLiteDatabaseTest.ClassToTestSqlCompilationAndCaching;
-import android.test.AndroidTestCase;
-import android.test.suitebuilder.annotation.SmallTest;
-import android.util.Log;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
-
-public class DatabaseConnectionPoolTest extends AndroidTestCase {
-    private static final String TAG = "DatabaseConnectionPoolTest";
-
-    private static final int MAX_CONN = 5;
-    private static final String TEST_SQL = "select * from test where i = ? AND j = 1";
-    private static final String[] TEST_SQLS = new String[] {
-        TEST_SQL, TEST_SQL + 1, TEST_SQL + 2, TEST_SQL + 3, TEST_SQL + 4
-    };
-
-    private SQLiteDatabase mDatabase;
-    private File mDatabaseFile;
-    private DatabaseConnectionPool mTestPool;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        File dbDir = getContext().getDir(this.getClass().getName(), Context.MODE_PRIVATE);
-        mDatabaseFile = new File(dbDir, "database_test.db");
-        if (mDatabaseFile.exists()) {
-            mDatabaseFile.delete();
-        }
-        mDatabase = SQLiteDatabase.openOrCreateDatabase(mDatabaseFile.getPath(), null);
-        assertNotNull(mDatabase);
-        mDatabase.execSQL("create table test (i int, j int);");
-        mTestPool = new DatabaseConnectionPool(mDatabase);
-        assertNotNull(mTestPool);
-    }
-
-    @Override
-    protected void tearDown() throws Exception {
-        mTestPool.close();
-        mDatabase.close();
-        mDatabaseFile.delete();
-        super.tearDown();
-    }
-
-    @SmallTest
-    public void testGetAndRelease() {
-        mTestPool.setMaxPoolSize(MAX_CONN);
-        // connections should be lazily created.
-        assertEquals(0, mTestPool.getSize());
-        // MAX pool size should be set to MAX_CONN
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // get a connection
-        SQLiteDatabase db = mTestPool.get(TEST_SQL);
-        // pool size should be one - since only one should be allocated for the above get()
-        assertEquals(1, mTestPool.getSize());
-        assertEquals(mDatabase, db.mParentConnObj);
-        // no free connections should be available
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertFalse(mTestPool.isDatabaseObjFree(db));
-        // release the connection
-        mTestPool.release(db);
-        assertEquals(1, mTestPool.getFreePoolSize());
-        assertEquals(1, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        assertTrue(mTestPool.isDatabaseObjFree(db));
-        // release the same object again and expect IllegalStateException
-        try {
-            mTestPool.release(db);
-            fail("illegalStateException expected");
-        } catch (IllegalStateException e ) {
-            // expected.
-        }
-    }
-
-    /**
-     * get all connections from the pool and ask for one more.
-     * should get one of the connections already got so far. 
-     */
-    @SmallTest
-    public void testGetAllConnAndOneMore() {
-        mTestPool.setMaxPoolSize(MAX_CONN);
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        ArrayList<SQLiteDatabase> dbObjs = new ArrayList<SQLiteDatabase>();
-        for (int i = 0; i < MAX_CONN; i++) {
-            SQLiteDatabase db = mTestPool.get(TEST_SQL);
-            assertFalse(dbObjs.contains(db));
-            dbObjs.add(db);
-            assertEquals(mDatabase, db.mParentConnObj);
-        }
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // pool is maxed out and no free connections. ask for one more connection
-        SQLiteDatabase db1 = mTestPool.get(TEST_SQL);
-        // make sure db1 is one of the existing ones
-        assertTrue(dbObjs.contains(db1));
-        // pool size should remain at MAX_CONN
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // release db1 but since it is allocated 2 times, it should still remain 'busy'
-        mTestPool.release(db1);
-        assertFalse(mTestPool.isDatabaseObjFree(db1));
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // release all connections
-        for (int i = 0; i < MAX_CONN; i++) {
-            mTestPool.release(dbObjs.get(i));
-        }
-        // all objects in the pool should be freed now
-        assertEquals(MAX_CONN, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-    }
-    
-    /**
-     * same as above except that each connection has different SQL statement associated with it. 
-     */
-    @SmallTest
-    public void testConnRetrievalForPreviouslySeenSql() {
-        mTestPool.setMaxPoolSize(MAX_CONN);
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        HashMap<String, SQLiteDatabase> dbObjs = new HashMap<String, SQLiteDatabase>();
-        for (int i = 0; i < MAX_CONN; i++) {
-            SQLiteDatabase db = mTestPool.get(TEST_SQLS[i]);
-            executeSqlOnDatabaseConn(db, TEST_SQLS[i]);
-            assertFalse(dbObjs.values().contains(db));
-            dbObjs.put(TEST_SQLS[i], db);
-        }
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // pool is maxed out and no free connections. ask for one more connection
-        // use a previously seen SQL statement
-        String testSql = TEST_SQLS[MAX_CONN - 1];
-        SQLiteDatabase db1 = mTestPool.get(testSql);
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // make sure db1 is one of the existing ones
-        assertTrue(dbObjs.values().contains(db1));
-        assertEquals(db1, dbObjs.get(testSql));
-        // do the same again
-        SQLiteDatabase db2 = mTestPool.get(testSql);
-        // make sure db1 is one of the existing ones
-        assertEquals(db2, dbObjs.get(testSql));
-
-        // pool size should remain at MAX_CONN
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        // release db1 but since the same connection is allocated 3 times,
-        // it should still remain 'busy'
-        mTestPool.release(db1);
-        assertFalse(mTestPool.isDatabaseObjFree(dbObjs.get(testSql)));
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        // release db2 but since the same connection is allocated 2 times,
-        // it should still remain 'busy'
-        mTestPool.release(db2);
-        assertFalse(mTestPool.isDatabaseObjFree(dbObjs.get(testSql)));
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        // release all connections
-        for (int i = 0; i < MAX_CONN; i++) {
-            mTestPool.release(dbObjs.get(TEST_SQLS[i]));
-        }
-        // all objects in the pool should be freed now
-        assertEquals(MAX_CONN, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-    }
-
-    private void executeSqlOnDatabaseConn(SQLiteDatabase db, String sql) {
-        // get the given sql be compiled on the given database connection.
-        // this will help DatabaseConenctionPool figure out if a given SQL statement
-        // is already cached by a database connection.
-        ClassToTestSqlCompilationAndCaching c =
-                ClassToTestSqlCompilationAndCaching.create(db, sql);
-        c.close();
-    }
-
-    /**
-     * get a connection for a SQL statement 'blah'. (connection_s)
-     * make sure the pool has at least one free connection even after this get().
-     * and get a connection for the same SQL again.
-     *    this connection should be different from connection_s.
-     *    even though there is a connection with the given SQL pre-compiled, since is it not free
-     *    AND since the pool has free connections available, should get a new connection.
-     */
-    @SmallTest
-    public void testGetConnForTheSameSql() {
-        mTestPool.setMaxPoolSize(MAX_CONN);
-
-        SQLiteDatabase db = mTestPool.get(TEST_SQL);
-        executeSqlOnDatabaseConn(db, TEST_SQL);
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(1, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        assertFalse(mTestPool.isDatabaseObjFree(db));
-
-        SQLiteDatabase db1 = mTestPool.get(TEST_SQL);
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(2, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        assertFalse(mTestPool.isDatabaseObjFree(db1));
-        assertFalse(db1.equals(db));
-
-        mTestPool.release(db);
-        assertEquals(1, mTestPool.getFreePoolSize());
-        assertEquals(2, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        mTestPool.release(db1);
-        assertEquals(2, mTestPool.getFreePoolSize());
-        assertEquals(2, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-    }
-
-    /**
-     * get the same connection N times and release it N times.
-     * this tests DatabaseConnectionPool.PoolObj.mNumHolders
-     */
-    @SmallTest
-    public void testGetSameConnNtimesAndReleaseItNtimes() {
-        mTestPool.setMaxPoolSize(MAX_CONN);
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        HashMap<String, SQLiteDatabase> dbObjs = new HashMap<String, SQLiteDatabase>();
-        for (int i = 0; i < MAX_CONN; i++) {
-            SQLiteDatabase db = mTestPool.get(TEST_SQLS[i]);
-            executeSqlOnDatabaseConn(db, TEST_SQLS[i]);
-            assertFalse(dbObjs.values().contains(db));
-            dbObjs.put(TEST_SQLS[i], db);
-        }
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // every connection in the pool should have numHolders = 1
-        for (int i = 0; i < MAX_CONN; i ++) {
-            assertEquals(1, mTestPool.getPool().get(i).getNumHolders());
-        }
-        // pool is maxed out and no free connections. ask for one more connection
-        // use a previously seen SQL statement
-        String testSql = TEST_SQLS[MAX_CONN - 1];
-        SQLiteDatabase db1 = mTestPool.get(testSql);
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // make sure db1 is one of the existing ones
-        assertTrue(dbObjs.values().contains(db1));
-        assertEquals(db1, dbObjs.get(testSql));
-        assertFalse(mTestPool.isDatabaseObjFree(db1));
-        DatabaseConnectionPool.PoolObj poolObj = mTestPool.getPool().get(db1.mConnectionNum - 1);
-        int numHolders = poolObj.getNumHolders();
-        assertEquals(2, numHolders);
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // get the same connection N times more
-        int N = 100;
-        for (int i = 0; i < N; i++) {
-            SQLiteDatabase db2 = mTestPool.get(testSql);
-            assertEquals(db1, db2);
-            assertFalse(mTestPool.isDatabaseObjFree(db2));
-            // numHolders for this object should be now up by 1
-            int prev = numHolders;
-            numHolders = poolObj.getNumHolders();
-            assertEquals(prev + 1, numHolders);
-        }
-        // release it N times
-        for (int i = 0; i < N; i++) {
-            mTestPool.release(db1);
-            int prev = numHolders;
-            numHolders = poolObj.getNumHolders();
-            assertEquals(prev - 1, numHolders);
-            assertFalse(mTestPool.isDatabaseObjFree(db1));
-        }
-        // the connection should still have 2 more holders
-        assertFalse(mTestPool.isDatabaseObjFree(db1));
-        assertEquals(2, poolObj.getNumHolders());
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // release 2 more times
-        mTestPool.release(db1);
-        mTestPool.release(db1);
-        assertEquals(0, poolObj.getNumHolders());
-        assertEquals(1, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        assertTrue(mTestPool.isDatabaseObjFree(db1));
-    }
-
-    @SmallTest
-    public void testStressTest() {
-        mTestPool.setMaxPoolSize(MAX_CONN);
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-
-        HashMap<SQLiteDatabase, Integer> dbMap = new HashMap<SQLiteDatabase, Integer>();
-        for (int i = 0; i < MAX_CONN; i++) {
-            SQLiteDatabase db = mTestPool.get(TEST_SQLS[i]);
-            assertFalse(dbMap.containsKey(db));
-            dbMap.put(db, 1);
-            executeSqlOnDatabaseConn(db, TEST_SQLS[i]);
-        }
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // ask for lot more connections but since the pool is maxed out, we should start receiving
-        // connections that we already got so far
-        for (int i = MAX_CONN; i < 1000; i++) {
-            SQLiteDatabase db = mTestPool.get(TEST_SQL + i);
-            assertTrue(dbMap.containsKey(db));
-            int k = dbMap.get(db);
-            dbMap.put(db, ++k);
-        }
-        assertEquals(0, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-        // print the distribution of the database connection handles received, should be uniform.
-        for (SQLiteDatabase d : dbMap.keySet()) {
-            Log.i(TAG, "connection # " + d.mConnectionNum + ", numHolders: " + dbMap.get(d));
-        }
-        // print the pool info
-        Log.i(TAG, mTestPool.toString());
-        // release all
-        for (SQLiteDatabase d : dbMap.keySet()) {
-            int num = dbMap.get(d);
-            for (int i = 0; i < num; i++) {
-                mTestPool.release(d);
-            }
-        }
-        assertEquals(MAX_CONN, mTestPool.getFreePoolSize());
-        assertEquals(MAX_CONN, mTestPool.getSize());
-        assertEquals(MAX_CONN, mTestPool.getMaxPoolSize());
-    }
-}
diff --git a/core/tests/coretests/src/android/database/sqlite/SQLiteCursorTest.java b/core/tests/coretests/src/android/database/sqlite/SQLiteCursorTest.java
index f6b1d04..9ccc6e8 100644
--- a/core/tests/coretests/src/android/database/sqlite/SQLiteCursorTest.java
+++ b/core/tests/coretests/src/android/database/sqlite/SQLiteCursorTest.java
@@ -21,8 +21,6 @@ import android.content.Context;
 import android.database.Cursor;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.LargeTest;
-import android.test.suitebuilder.annotation.SmallTest;
-import android.util.Log;
 
 import java.io.File;
 import java.util.HashSet;
@@ -54,52 +52,8 @@ public class SQLiteCursorTest extends AndroidTestCase {
         super.tearDown();
     }
 
-    @SmallTest
-    public void testQueryObjReassignment() {
-        mDatabase.enableWriteAheadLogging();
-        // have a few connections in the database connection pool
-        DatabaseConnectionPool pool = mDatabase.mConnectionPool;
-        pool.setMaxPoolSize(5);
-        SQLiteCursor cursor =
-                (SQLiteCursor) mDatabase.rawQuery("select * from " + TABLE_NAME, null);
-        assertNotNull(cursor);
-        // it should use a pooled database connection
-        SQLiteDatabase db = cursor.getDatabase();
-        assertTrue(db.mConnectionNum > 0);
-        assertFalse(mDatabase.equals(db));
-        assertEquals(mDatabase, db.mParentConnObj);
-        assertTrue(pool.getConnectionList().contains(db));
-        assertTrue(db.isOpen());
-        // do a requery. cursor should continue to use the above pooled connection
-        cursor.requery();
-        SQLiteDatabase dbAgain = cursor.getDatabase();
-        assertEquals(db, dbAgain);
-        // disable WAL so that the pooled connection held by the above cursor is closed
-        mDatabase.disableWriteAheadLogging();
-        assertFalse(db.isOpen());
-        assertNull(mDatabase.mConnectionPool);
-        // requery - which should make the cursor use mDatabase connection since the pooled
-        // connection is no longer available
-        cursor.requery();
-        SQLiteDatabase db1 = cursor.getDatabase();
-        assertTrue(db1.mConnectionNum == 0);
-        assertEquals(mDatabase, db1);
-        assertNull(mDatabase.mConnectionPool);
-        assertTrue(db1.isOpen());
-        assertFalse(mDatabase.equals(db));
-        // enable WAL and requery - this time a pooled connection should be used
-        mDatabase.enableWriteAheadLogging();
-        cursor.requery();
-        db = cursor.getDatabase();
-        assertTrue(db.mConnectionNum > 0);
-        assertFalse(mDatabase.equals(db));
-        assertEquals(mDatabase, db.mParentConnObj);
-        assertTrue(mDatabase.mConnectionPool.getConnectionList().contains(db));
-        assertTrue(db.isOpen());
-    }
-
     /**
-     * this test could take a while to execute. so, designate it as LargetTest
+     * this test could take a while to execute. so, designate it as LargeTest
      */
     @LargeTest
     public void testFillWindow() {
diff --git a/core/tests/coretests/src/android/database/sqlite/SQLiteDatabaseTest.java b/core/tests/coretests/src/android/database/sqlite/SQLiteDatabaseTest.java
deleted file mode 100644
index 5ef8d11..0000000
--- a/core/tests/coretests/src/android/database/sqlite/SQLiteDatabaseTest.java
+++ /dev/null
@@ -1,971 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.database.sqlite;
-
-import android.content.ContentValues;
-import android.content.Context;
-import android.database.Cursor;
-import android.database.DatabaseErrorHandler;
-import android.database.DatabaseUtils;
-import android.database.DefaultDatabaseErrorHandler;
-import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteDatabase.CursorFactory;
-import android.database.sqlite.SQLiteStatement;
-import android.test.AndroidTestCase;
-import android.test.suitebuilder.annotation.LargeTest;
-import android.test.suitebuilder.annotation.MediumTest;
-import android.test.suitebuilder.annotation.SmallTest;
-import android.test.suitebuilder.annotation.Suppress;
-import android.util.Log;
-import android.util.Pair;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-public class SQLiteDatabaseTest extends AndroidTestCase {
-    private static final String TAG = "DatabaseGeneralTest";
-    private static final String TEST_TABLE = "test";
-    private static final int CURRENT_DATABASE_VERSION = 42;
-    private SQLiteDatabase mDatabase;
-    private File mDatabaseFile;
-    private static final int INSERT = 1;
-    private static final int UPDATE = 2;
-    private static final int DELETE = 3;
-    private static final String DB_NAME = "database_test.db";
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        dbSetUp();
-    }
-
-    @Override
-    protected void tearDown() throws Exception {
-        dbTeardown();
-        super.tearDown();
-    }
-
-    private void dbTeardown() throws Exception {
-        mDatabase.close();
-        mDatabaseFile.delete();
-    }
-
-    private void dbSetUp() throws Exception {
-        File dbDir = getContext().getDir(this.getClass().getName(), Context.MODE_PRIVATE);
-        mDatabaseFile = new File(dbDir, DB_NAME);
-        if (mDatabaseFile.exists()) {
-            mDatabaseFile.delete();
-        }
-        mDatabase = SQLiteDatabase.openOrCreateDatabase(mDatabaseFile.getPath(), null, null);
-        assertNotNull(mDatabase);
-        mDatabase.setVersion(CURRENT_DATABASE_VERSION);
-    }
-
-    @SmallTest
-    public void testEnableWriteAheadLogging() {
-        mDatabase.disableWriteAheadLogging();
-        assertNull(mDatabase.mConnectionPool);
-        mDatabase.enableWriteAheadLogging();
-        DatabaseConnectionPool pool = mDatabase.mConnectionPool;
-        assertNotNull(pool);
-        // make the same call again and make sure the pool already setup is not re-created
-        mDatabase.enableWriteAheadLogging();
-        assertEquals(pool, mDatabase.mConnectionPool);
-    }
-
-    @SmallTest
-    public void testDisableWriteAheadLogging() {
-        mDatabase.execSQL("create table test (i int);");
-        mDatabase.enableWriteAheadLogging();
-        assertNotNull(mDatabase.mConnectionPool);
-        // get a pooled database connection
-        SQLiteDatabase db = mDatabase.getDbConnection("select * from test");
-        assertNotNull(db);
-        assertFalse(mDatabase.equals(db));
-        assertTrue(db.isOpen());
-        // disable WAL - which should close connection pool and all pooled connections
-        mDatabase.disableWriteAheadLogging();
-        assertNull(mDatabase.mConnectionPool);
-        assertFalse(db.isOpen());
-    }
-
-    @SmallTest
-    public void testCursorsWithClosedDbConnAfterDisableWriteAheadLogging() {
-        mDatabase.disableWriteAheadLogging();
-        mDatabase.beginTransactionNonExclusive();
-        mDatabase.execSQL("create table test (i int);");
-        mDatabase.execSQL("insert into test values(1);");
-        mDatabase.setTransactionSuccessful();
-        mDatabase.endTransaction();
-        mDatabase.enableWriteAheadLogging();
-        assertNotNull(mDatabase.mConnectionPool);
-        assertEquals(0, mDatabase.mConnectionPool.getSize());
-        assertEquals(0, mDatabase.mConnectionPool.getFreePoolSize());
-        // get a cursor which should use pooled database connection
-        Cursor c = mDatabase.rawQuery("select * from test", null);
-        assertEquals(1, c.getCount());
-        assertEquals(1, mDatabase.mConnectionPool.getSize());
-        assertEquals(1, mDatabase.mConnectionPool.getFreePoolSize());
-        SQLiteDatabase db = mDatabase.mConnectionPool.getConnectionList().get(0);
-        assertTrue(mDatabase.mConnectionPool.isDatabaseObjFree(db));
-        // disable WAL - which should close connection pool and all pooled connections
-        mDatabase.disableWriteAheadLogging();
-        assertNull(mDatabase.mConnectionPool);
-        assertFalse(db.isOpen());
-        // cursor data should still be accessible because it is fetching data from CursorWindow
-        c.moveToNext();
-        assertEquals(1, c.getInt(0));
-        c.requery();
-        assertEquals(1, c.getCount());
-        c.moveToNext();
-        assertEquals(1, c.getInt(0));
-        c.close();
-    }
-
-    /**
-     * a transaction should be started before a standalone-update/insert/delete statement
-     */
-    @SmallTest
-    public void testStartXactBeforeUpdateSql() throws InterruptedException {
-        runTestForStartXactBeforeUpdateSql(INSERT);
-        runTestForStartXactBeforeUpdateSql(UPDATE);
-        runTestForStartXactBeforeUpdateSql(DELETE);
-    }
-    private void runTestForStartXactBeforeUpdateSql(int stmtType) throws InterruptedException {
-        createTableAndClearCache();
-
-        ContentValues values = new ContentValues();
-        // make some changes to data in TEST_TABLE
-        for (int i = 0; i < 5; i++) {
-            values.put("i", i);
-            values.put("j", "i" + System.currentTimeMillis());
-            mDatabase.insert(TEST_TABLE, null, values);
-            switch (stmtType) {
-                case UPDATE:
-                    values.put("j", "u" + System.currentTimeMillis());
-                    mDatabase.update(TEST_TABLE, values, "i = " + i, null);
-                    break;
-                case DELETE:
-                    mDatabase.delete(TEST_TABLE, "i = 1", null);
-                    break;
-            }
-        }
-        // do a query. even though query uses a different database connection,
-        // it should still see the above changes to data because the above standalone
-        // insert/update/deletes are done in transactions automatically.
-        String sql = "select count(*) from " + TEST_TABLE;
-        SQLiteStatement stmt = mDatabase.compileStatement(sql);
-        final int expectedValue = (stmtType == DELETE) ? 4 : 5;
-        assertEquals(expectedValue, stmt.simpleQueryForLong());
-        stmt.close();
-        Cursor c = mDatabase.rawQuery(sql, null);
-        assertEquals(1, c.getCount());
-        c.moveToFirst();
-        assertEquals(expectedValue, c.getLong(0));
-        c.close();
-
-        // do 5 more changes in a transaction but do a query before and after the commit
-        mDatabase.beginTransaction();
-        for (int i = 10; i < 15; i++) {
-            values.put("i", i);
-            values.put("j", "i" + System.currentTimeMillis());
-            mDatabase.insert(TEST_TABLE, null, values);
-            switch (stmtType) {
-                case UPDATE:
-                    values.put("j", "u" + System.currentTimeMillis());
-                    mDatabase.update(TEST_TABLE, values, "i = " + i, null);
-                    break;
-                case DELETE:
-                    mDatabase.delete(TEST_TABLE, "i = 1", null);
-                    break;
-            }
-        }
-        mDatabase.setTransactionSuccessful();
-        // do a query before commit - should still have 5 rows
-        // this query should run in a different thread to force it to use a different database
-        // connection
-        Thread t = new Thread() {
-            @Override public void run() {
-                String sql = "select count(*) from " + TEST_TABLE;
-                SQLiteStatement stmt = getDb().compileStatement(sql);
-                assertEquals(expectedValue, stmt.simpleQueryForLong());
-                stmt.close();
-                Cursor c = getDb().rawQuery(sql, null);
-                assertEquals(1, c.getCount());
-                c.moveToFirst();
-                assertEquals(expectedValue, c.getLong(0));
-                c.close();
-            }
-        };
-        t.start();
-        // wait until the above thread is done
-        t.join();
-        // commit and then query. should see changes from the transaction
-        mDatabase.endTransaction();
-        stmt = mDatabase.compileStatement(sql);
-        final int expectedValue2 = (stmtType == DELETE) ? 9 : 10;
-        assertEquals(expectedValue2, stmt.simpleQueryForLong());
-        stmt.close();
-        c = mDatabase.rawQuery(sql, null);
-        assertEquals(1, c.getCount());
-        c.moveToFirst();
-        assertEquals(expectedValue2, c.getLong(0));
-        c.close();
-    }
-    private synchronized SQLiteDatabase getDb() {
-        return mDatabase;
-    }
-
-    /**
-     * Test to ensure that readers are able to read the database data (old versions)
-     * EVEN WHEN the writer is in a transaction on the same database.
-     *<p>
-     * This test starts 1 Writer and 2 Readers and sets up connection pool for readers
-     * by calling the method {@link SQLiteDatabase#enableWriteAheadLogging()}.
-     * <p>
-     * Writer does the following in a tight loop
-     * <pre>
-     *     begin transaction
-     *     insert into table_1
-     *     insert into table_2
-     *     commit
-     * </pre>
-     * <p>
-     * As long a the writer is alive, Readers do the following in a tight loop at the same time
-     * <pre>
-     *     Reader_K does "select count(*) from table_K"  where K = 1 or 2
-     * </pre>
-     * <p>
-     * The test is run for TIME_TO_RUN_WAL_TEST_FOR sec.
-     * <p>
-     * The test is repeated for different connection-pool-sizes (1..3)
-     * <p>
-     * And at the end of of each test, the following statistics are printed
-     * <ul>
-     *    <li>connection-pool-size</li>
-     *    <li>number-of-transactions by writer</li>
-     *    <li>number of reads by reader_K while the writer is IN or NOT-IN xaction</li>
-     * </ul>
-     */
-    @LargeTest
-    @Suppress // run this test only if you need to collect the numbers from this test
-    public void testConcurrencyEffectsOfConnPool() throws Exception {
-        // run the test with sqlite WAL enable
-        runConnectionPoolTest(true);
-
-        // run the same test WITHOUT sqlite WAL enabled
-        runConnectionPoolTest(false);
-    }
-
-    private void runConnectionPoolTest(boolean useWal) throws Exception {
-        int M = 3;
-        StringBuilder[] buff = new StringBuilder[M];
-        for (int i = 0; i < M; i++) {
-            if (useWal) {
-                // set up connection pool
-                mDatabase.enableWriteAheadLogging();
-                mDatabase.mConnectionPool.setMaxPoolSize(i + 1);
-            } else {
-                mDatabase.disableWriteAheadLogging();
-            }
-            mDatabase.execSQL("CREATE TABLE t1 (i int, j int);");
-            mDatabase.execSQL("CREATE TABLE t2 (i int, j int);");
-            mDatabase.beginTransaction();
-            for (int k = 0; k < 5; k++) {
-                mDatabase.execSQL("insert into t1 values(?,?);", new String[] {k+"", k+""});
-                mDatabase.execSQL("insert into t2 values(?,?);", new String[] {k+"", k+""});
-            }
-            mDatabase.setTransactionSuccessful();
-            mDatabase.endTransaction();
-
-            // start a writer
-            Writer w = new Writer(mDatabase);
-
-            // initialize an array of counters to be passed to the readers
-            Reader r1 = new Reader(mDatabase, "t1", w, 0);
-            Reader r2 = new Reader(mDatabase, "t2", w, 1);
-            w.start();
-            r1.start();
-            r2.start();
-
-            // wait for all threads to die
-            w.join();
-            r1.join();
-            r2.join();
-
-            // print the stats
-            int[][] counts = getCounts();
-            buff[i] = new StringBuilder();
-            buff[i].append("connpool-size = ");
-            buff[i].append(i + 1);
-            buff[i].append(", num xacts by writer = ");
-            buff[i].append(getNumXacts());
-            buff[i].append(", num-reads-in-xact/NOT-in-xact by reader1 = ");
-            buff[i].append(counts[0][1] + "/" + counts[0][0]);
-            buff[i].append(", by reader2 = ");
-            buff[i].append(counts[1][1] + "/" + counts[1][0]);
-
-            Log.i(TAG, "done testing for conn-pool-size of " + (i+1));
-
-            dbTeardown();
-            dbSetUp();
-        }
-        Log.i(TAG, "duration of test " + TIME_TO_RUN_WAL_TEST_FOR + " sec");
-        for (int i = 0; i < M; i++) {
-            Log.i(TAG, buff[i].toString());
-        }
-    }
-
-    private boolean inXact = false;
-    private int numXacts;
-    private static final int TIME_TO_RUN_WAL_TEST_FOR = 15; // num sec this test should run
-    private int[][] counts = new int[2][2];
-
-    private synchronized boolean inXact() {
-        return inXact;
-    }
-
-    private synchronized void setInXactFlag(boolean flag) {
-        inXact = flag;
-    }
-
-    private synchronized void setCounts(int readerNum, int[] numReads) {
-        counts[readerNum][0] = numReads[0];
-        counts[readerNum][1] = numReads[1];
-    }
-
-    private synchronized int[][] getCounts() {
-        return counts;
-    }
-
-    private synchronized void setNumXacts(int num) {
-        numXacts = num;
-    }
-
-    private synchronized int getNumXacts() {
-        return numXacts;
-    }
-
-    private class Writer extends Thread {
-        private SQLiteDatabase db = null;
-        public Writer(SQLiteDatabase db) {
-            this.db = db;
-        }
-        @Override public void run() {
-            // in a loop, for N sec, do the following
-            //    BEGIN transaction
-            //    insert into table t1, t2
-            //    Commit
-            long now = System.currentTimeMillis();
-            int k;
-            for (k = 0;(System.currentTimeMillis() - now) / 1000 < TIME_TO_RUN_WAL_TEST_FOR; k++) {
-                db.beginTransactionNonExclusive();
-                setInXactFlag(true);
-                for (int i = 0; i < 10; i++) {
-                    db.execSQL("insert into t1 values(?,?);", new String[] {i+"", i+""});
-                    db.execSQL("insert into t2 values(?,?);", new String[] {i+"", i+""});
-                }
-                db.setTransactionSuccessful();
-                setInXactFlag(false);
-                db.endTransaction();
-            }
-            setNumXacts(k);
-        }
-    }
-
-    private class Reader extends Thread {
-        private SQLiteDatabase db = null;
-        private String table = null;
-        private Writer w = null;
-        private int readerNum;
-        private int[] numReads = new int[2];
-        public Reader(SQLiteDatabase db, String table, Writer w, int readerNum) {
-            this.db = db;
-            this.table = table;
-            this.w = w;
-            this.readerNum = readerNum;
-        }
-        @Override public void run() {
-            // while the write is alive, in a loop do the query on a table
-            while (w.isAlive()) {
-                for (int i = 0; i < 10; i++) {
-                    DatabaseUtils.longForQuery(db, "select count(*) from " + this.table, null);
-                    // update count of reads
-                    numReads[inXact() ? 1 : 0] += 1;
-                }
-            }
-            setCounts(readerNum, numReads);
-        }
-    }
-
-    public static class ClassToTestSqlCompilationAndCaching extends SQLiteProgram {
-        private ClassToTestSqlCompilationAndCaching(SQLiteDatabase db, String sql) {
-            super(db, sql);
-        }
-        public static ClassToTestSqlCompilationAndCaching create(SQLiteDatabase db, String sql) {
-            db.lock();
-            try {
-                return new ClassToTestSqlCompilationAndCaching(db, sql);
-            } finally {
-                db.unlock();
-            }
-        }
-    }
-
-    @SmallTest
-    public void testLruCachingOfSqliteCompiledSqlObjs() {
-        createTableAndClearCache();
-        // set cache size
-        int N = SQLiteDatabase.MAX_SQL_CACHE_SIZE;
-        mDatabase.setMaxSqlCacheSize(N);
-
-        // do N+1 queries - and when the 0th entry is removed from LRU cache due to the
-        // insertion of (N+1)th entry, make sure 0th entry is closed
-        ArrayList<Integer> stmtObjs = new ArrayList<Integer>();
-        ArrayList<String> sqlStrings = new ArrayList<String>();
-        int stmt0 = 0;
-        for (int i = 0; i < N+1; i++) {
-            String s = "insert into test values(" + i + ",?);";
-            sqlStrings.add(s);
-            ClassToTestSqlCompilationAndCaching c =
-                    ClassToTestSqlCompilationAndCaching.create(mDatabase, s);
-            int n = c.getSqlStatementId();
-            stmtObjs.add(i, n);
-            if (i == 0) {
-                // save the statementId of this obj. we want to make sure it is thrown out of
-                // the cache at the end of this test.
-                stmt0 = n;
-            }
-            c.close();
-        }
-        // is 0'th entry out of the cache? it should be in the list of statementIds
-        // corresponding to the pre-compiled sql statements to be finalized.
-        assertTrue(mDatabase.getQueuedUpStmtList().contains(stmt0));
-        for (int i = 1; i < N+1; i++) {
-            SQLiteCompiledSql compSql = mDatabase.getCompiledStatementForSql(sqlStrings.get(i));
-            assertNotNull(compSql);
-            assertTrue(stmtObjs.contains(compSql.nStatement));
-        }
-    }
-
-    @MediumTest
-    public void testDbCloseReleasingAllCachedSql() {
-        mDatabase.execSQL("CREATE TABLE test (_id INTEGER PRIMARY KEY, text1 TEXT, text2 TEXT, " +
-                "num1 INTEGER, num2 INTEGER, image BLOB);");
-        final String statement = "DELETE FROM test WHERE _id=?;";
-        SQLiteStatement statementDoNotClose = mDatabase.compileStatement(statement);
-        statementDoNotClose.bindLong(1, 1);
-        /* do not close statementDoNotClose object.
-         * That should leave it in SQLiteDatabase.mPrograms.
-         * mDatabase.close() in tearDown() should release it.
-         */
-    }
-
-    private void createTableAndClearCache() {
-        mDatabase.disableWriteAheadLogging();
-        mDatabase.execSQL("DROP TABLE IF EXISTS " + TEST_TABLE);
-        mDatabase.execSQL("CREATE TABLE " + TEST_TABLE + " (i int, j int);");
-        mDatabase.enableWriteAheadLogging();
-        mDatabase.lock();
-        // flush the above statement from cache and close all the pending statements to be released
-        mDatabase.deallocCachedSqlStatements();
-        mDatabase.closePendingStatements();
-        mDatabase.unlock();
-        assertEquals(0, mDatabase.getQueuedUpStmtList().size());
-    }
-
-    /**
-     * test to make sure the statement finalizations are not done right away but
-     * piggy-backed onto the next sql statement execution on the same database.
-     */
-    @SmallTest
-    public void testStatementClose() {
-        createTableAndClearCache();
-        // fill up statement cache in mDatabase
-        int N = SQLiteDatabase.MAX_SQL_CACHE_SIZE;
-        mDatabase.setMaxSqlCacheSize(N);
-        SQLiteStatement stmt;
-        int stmt0Id = 0;
-        for (int i = 0; i < N; i ++) {
-            ClassToTestSqlCompilationAndCaching c =
-                    ClassToTestSqlCompilationAndCaching.create(mDatabase,
-                            "insert into test values(" + i + ", ?);");
-            // keep track of 0th entry
-            if (i == 0) {
-                stmt0Id = c.getSqlStatementId();
-            }
-            c.close();
-        }
-
-        // add one more to the cache - and the above 'stmt0Id' should fall out of cache
-        ClassToTestSqlCompilationAndCaching stmt1 =
-                ClassToTestSqlCompilationAndCaching.create(mDatabase,
-                        "insert into test values(100, ?);");
-        stmt1.close();
-
-        // the above close() should have queuedUp the statement for finalization
-        ArrayList<Integer> statementIds = mDatabase.getQueuedUpStmtList();
-        assertTrue(statementIds.contains(stmt0Id));
-
-        // execute something to see if this statement gets finalized
-        mDatabase.execSQL("delete from test where i = 10;");
-        statementIds = mDatabase.getQueuedUpStmtList();
-        assertFalse(statementIds.contains(stmt0Id));
-    }
-
-    /**
-     * same as above - except that the statement to be finalized is from Thread # 1.
-     * and it is eventually finalized in Thread # 2 when it executes a SQL statement.
-     * @throws InterruptedException
-     */
-    @LargeTest
-    public void testStatementCloseDiffThread() throws InterruptedException {
-        createTableAndClearCache();
-        final int N = SQLiteDatabase.MAX_SQL_CACHE_SIZE;
-        mDatabase.setMaxSqlCacheSize(N);
-        // fill up statement cache in mDatabase in a thread
-        Thread t1 = new Thread() {
-            @Override public void run() {
-                SQLiteStatement stmt;
-                for (int i = 0; i < N; i++) {
-                    ClassToTestSqlCompilationAndCaching c =
-                        ClassToTestSqlCompilationAndCaching.create(getDb(),
-                                "insert into test values(" + i + ", ?);");
-                    // keep track of 0th entry
-                    if (i == 0) {
-                        stmt0Id = c.getSqlStatementId();
-                    }
-                    c.close();
-                }
-            }
-        };
-        t1.start();
-        // wait for the thread to finish
-        t1.join();
-        // mDatabase shouldn't have any statements to be released
-        assertEquals(0, mDatabase.getQueuedUpStmtList().size());
-
-        // add one more to the cache - and the above 'stmt0Id' should fall out of cache
-        // just for the heck of it, do it in a separate thread
-        Thread t2 = new Thread() {
-            @Override public void run() {
-                ClassToTestSqlCompilationAndCaching stmt1 =
-                    ClassToTestSqlCompilationAndCaching.create(getDb(),
-                            "insert into test values(100, ?);");
-                stmt1.bindLong(1, 1);
-                stmt1.close();
-            }
-        };
-        t2.start();
-        t2.join();
-
-        // close() in the above thread should have queuedUp the stmt0Id for finalization
-        ArrayList<Integer> statementIds = getDb().getQueuedUpStmtList();
-        assertTrue(statementIds.contains(getStmt0Id()));
-        assertEquals(1, statementIds.size());
-
-        // execute something to see if this statement gets finalized
-        // again do it in a separate thread
-        Thread t3 = new Thread() {
-            @Override public void run() {
-                getDb().execSQL("delete from test where i = 10;");
-            }
-        };
-        t3.start();
-        t3.join();
-
-        // is the statement finalized?
-        statementIds = getDb().getQueuedUpStmtList();
-        assertFalse(statementIds.contains(getStmt0Id()));
-    }
-
-    private volatile int stmt0Id = 0;
-    private synchronized int getStmt0Id() {
-        return this.stmt0Id;
-    }
-
-    /**
-     * same as above - except that the queue of statements to be finalized are finalized
-     * by database close() operation.
-     */
-    @LargeTest
-    public void testStatementCloseByDbClose() throws InterruptedException {
-        createTableAndClearCache();
-        // fill up statement cache in mDatabase in a thread
-        Thread t1 = new Thread() {
-            @Override public void run() {
-                int N = SQLiteDatabase.MAX_SQL_CACHE_SIZE;
-                getDb().setMaxSqlCacheSize(N);
-                SQLiteStatement stmt;
-                for (int i = 0; i < N; i ++) {
-                    ClassToTestSqlCompilationAndCaching c =
-                            ClassToTestSqlCompilationAndCaching.create(getDb(),
-                                    "insert into test values(" + i + ", ?);");
-                    // keep track of 0th entry
-                    if (i == 0) {
-                        stmt0Id = c.getSqlStatementId();
-                    }
-                    c.close();
-                }
-            }
-        };
-        t1.start();
-        // wait for the thread to finish
-        t1.join();
-
-        // add one more to the cache - and the above 'stmt0Id' should fall out of cache
-        // just for the heck of it, do it in a separate thread
-        Thread t2 = new Thread() {
-            @Override public void run() {
-                ClassToTestSqlCompilationAndCaching stmt1 =
-                        ClassToTestSqlCompilationAndCaching.create(getDb(),
-                                "insert into test values(100, ?);");
-                stmt1.bindLong(1, 1);
-                stmt1.close();
-            }
-        };
-        t2.start();
-        t2.join();
-
-        // close() in the above thread should have queuedUp the statement for finalization
-        ArrayList<Integer> statementIds = getDb().getQueuedUpStmtList();
-        assertTrue(getStmt0Id() > 0);
-        assertTrue(statementIds.contains(stmt0Id));
-        assertEquals(1, statementIds.size());
-
-        // close the database. everything from mClosedStatementIds in mDatabase
-        // should be finalized and cleared from the list
-        // again do it in a separate thread
-        Thread t3 = new Thread() {
-            @Override public void run() {
-                getDb().close();
-            }
-        };
-        t3.start();
-        t3.join();
-
-        // check mClosedStatementIds in mDatabase. it should be empty
-        statementIds = getDb().getQueuedUpStmtList();
-        assertEquals(0, statementIds.size());
-    }
-
-    /**
-     * This test tests usage execSQL() to begin transaction works in the following way
-     *   Thread #1 does
-     *       execSQL("begin transaction");
-     *       insert()
-     *   Thread # 2
-     *       query()
-     *   Thread#1 ("end transaction")
-     * Thread # 2 query will execute - because java layer will not have locked the SQLiteDatabase
-     * object and sqlite will consider this query to be part of the transaction.
-     *
-     * but if thread # 1 uses beginTransaction() instead of execSQL() to start transaction,
-     * then Thread # 2's query will have been blocked by java layer
-     * until Thread#1 ends transaction.
-     *
-     * @throws InterruptedException
-     */
-    @SmallTest
-    public void testExecSqlToStartAndEndTransaction() throws InterruptedException {
-        runExecSqlToStartAndEndTransaction("END");
-        // same as above, instead now do "COMMIT" or "ROLLBACK" instead of "END" transaction
-        runExecSqlToStartAndEndTransaction("COMMIT");
-        runExecSqlToStartAndEndTransaction("ROLLBACK");
-    }
-    private void runExecSqlToStartAndEndTransaction(String str) throws InterruptedException {
-        createTableAndClearCache();
-        // disable WAL just so queries and updates use the same database connection
-        mDatabase.disableWriteAheadLogging();
-        mDatabase.execSQL("BEGIN transaction");
-        // even though mDatabase.beginTransaction() is not called to start transaction,
-        // mDatabase connection should now be in transaction as a result of
-        // mDatabase.execSQL("BEGIN transaction")
-        // but mDatabase.mLock should not be held by any thread
-        assertTrue(mDatabase.inTransaction());
-        assertFalse(mDatabase.isDbLockedByCurrentThread());
-        assertFalse(mDatabase.isDbLockedByOtherThreads());
-        assertTrue(mDatabase.amIInTransaction());
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        assertTrue(mDatabase.inTransaction());
-        assertFalse(mDatabase.isDbLockedByCurrentThread());
-        assertFalse(mDatabase.isDbLockedByOtherThreads());
-        assertTrue(mDatabase.amIInTransaction());
-        Thread t = new Thread() {
-            @Override public void run() {
-                assertTrue(mDatabase.amIInTransaction());
-                assertEquals(999, DatabaseUtils.longForQuery(getDb(),
-                        "select j from " + TEST_TABLE + " WHERE i = 10", null));
-                assertTrue(getDb().inTransaction());
-                assertFalse(getDb().isDbLockedByCurrentThread());
-                assertFalse(getDb().isDbLockedByOtherThreads());
-                assertTrue(mDatabase.amIInTransaction());
-            }
-        };
-        t.start();
-        t.join();
-        assertTrue(mDatabase.amIInTransaction());
-        assertTrue(mDatabase.inTransaction());
-        assertFalse(mDatabase.isDbLockedByCurrentThread());
-        assertFalse(mDatabase.isDbLockedByOtherThreads());
-        mDatabase.execSQL(str);
-        assertFalse(mDatabase.amIInTransaction());
-        assertFalse(mDatabase.inTransaction());
-        assertFalse(mDatabase.isDbLockedByCurrentThread());
-        assertFalse(mDatabase.isDbLockedByOtherThreads());
-    }
-
-    /**
-     * test the following
-     * http://b/issue?id=2871037
-     *          Cursor cursor = db.query(...);
-     *          // with WAL enabled, the above uses a pooled database connection
-     *          db.beginTransaction()
-     *          try {
-     *            db.insert(......);
-     *            cursor.requery();
-     *            // since the cursor uses pooled database connection, the above requery
-     *            // will not return the results that were inserted above since the insert is
-     *            // done using main database connection AND the transaction is not committed yet.
-     *            // fix is to make the above cursor use the main database connection - and NOT
-     *            // the pooled database connection
-     *            db.setTransactionSuccessful()
-     *          } finally {
-     *            db.endTransaction()
-     *          }
-     *
-     * @throws InterruptedException
-     */
-    @SmallTest
-    public void testTransactionAndWalInterplay1() throws InterruptedException {
-        createTableAndClearCache();
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        String sql = "select * from " + TEST_TABLE;
-        Cursor c = mDatabase.rawQuery(sql, null);
-        // should have 1 row in the table
-        assertEquals(1, c.getCount());
-        mDatabase.beginTransactionNonExclusive();
-        try {
-            mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(100, 9909);");
-            assertEquals(2, DatabaseUtils.longForQuery(mDatabase,
-                    "select count(*) from " + TEST_TABLE, null));
-            // requery on the previously opened cursor
-            // cursor should now use the main database connection and see 2 rows
-            c.requery();
-            assertEquals(2, c.getCount());
-            mDatabase.setTransactionSuccessful();
-        } finally {
-            mDatabase.endTransaction();
-        }
-        c.close();
-
-        // do the same test but now do the requery in a separate thread.
-        createTableAndClearCache();
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        final Cursor c1 = mDatabase.rawQuery("select count(*) from " + TEST_TABLE, null);
-        // should have 1 row in the table
-        assertEquals(1, c1.getCount());
-        mDatabase.beginTransactionNonExclusive();
-        try {
-            mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(100, 9909);");
-            assertEquals(2, DatabaseUtils.longForQuery(mDatabase,
-                    "select count(*) from " + TEST_TABLE, null));
-            // query in a different thread. that causes the cursor to use a pooled connection
-            // and since this thread hasn't committed its changes, the cursor should still see only
-            // 1 row
-            Thread t = new Thread() {
-                @Override public void run() {
-                    c1.requery();
-                    assertEquals(1, c1.getCount());
-                }
-            };
-            t.start();
-            t.join();
-            // should be 2 rows now - including the the row inserted above
-            mDatabase.setTransactionSuccessful();
-        } finally {
-            mDatabase.endTransaction();
-        }
-        c1.close();
-    }
-
-    /**
-     * This test is same as {@link #testTransactionAndWalInterplay1()} except the following:
-     * instead of mDatabase.beginTransactionNonExclusive(), use execSQL("BEGIN transaction")
-     * and instead of mDatabase.endTransaction(), use execSQL("END");
-     */
-    @SmallTest
-    public void testTransactionAndWalInterplay2() throws InterruptedException {
-        createTableAndClearCache();
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        String sql = "select * from " + TEST_TABLE;
-        Cursor c = mDatabase.rawQuery(sql, null);
-        // should have 1 row in the table
-        assertEquals(1, c.getCount());
-        mDatabase.execSQL("BEGIN transaction");
-        try {
-            mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(100, 9909);");
-            assertEquals(2, DatabaseUtils.longForQuery(mDatabase,
-                    "select count(*) from " + TEST_TABLE, null));
-            // requery on the previously opened cursor
-            // cursor should now use the main database connection and see 2 rows
-            c.requery();
-            assertEquals(2, c.getCount());
-        } finally {
-            mDatabase.execSQL("commit;");
-        }
-        c.close();
-
-        // do the same test but now do the requery in a separate thread.
-        createTableAndClearCache();
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        final Cursor c1 = mDatabase.rawQuery("select count(*) from " + TEST_TABLE, null);
-        // should have 1 row in the table
-        assertEquals(1, c1.getCount());
-        mDatabase.execSQL("BEGIN transaction");
-        try {
-            mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(100, 9909);");
-            assertEquals(2, DatabaseUtils.longForQuery(mDatabase,
-                    "select count(*) from " + TEST_TABLE, null));
-            // query in a different thread. but since the transaction is started using
-            // execSQ() instead of beginTransaction(), cursor's query is considered part of
-            // the same transaction - and hence it should see the above inserted row
-            Thread t = new Thread() {
-                @Override public void run() {
-                    c1.requery();
-                    assertEquals(1, c1.getCount());
-                }
-            };
-            t.start();
-            t.join();
-            // should be 2 rows now - including the the row inserted above
-        } finally {
-            mDatabase.execSQL("commit");
-        }
-        c1.close();
-    }
-
-    /**
-     * This test is same as {@link #testTransactionAndWalInterplay2()} except the following:
-     * instead of committing the data, do rollback and make sure the data seen by the query
-     * within the transaction is now gone.
-     */
-    @SmallTest
-    public void testTransactionAndWalInterplay3() {
-        createTableAndClearCache();
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        String sql = "select * from " + TEST_TABLE;
-        Cursor c = mDatabase.rawQuery(sql, null);
-        // should have 1 row in the table
-        assertEquals(1, c.getCount());
-        mDatabase.execSQL("BEGIN transaction");
-        try {
-            mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(100, 9909);");
-            assertEquals(2, DatabaseUtils.longForQuery(mDatabase,
-                    "select count(*) from " + TEST_TABLE, null));
-            // requery on the previously opened cursor
-            // cursor should now use the main database connection and see 2 rows
-            c.requery();
-            assertEquals(2, c.getCount());
-        } finally {
-            // rollback the change
-            mDatabase.execSQL("rollback;");
-        }
-        // since the change is rolled back, do the same query again and should now find only 1 row
-        c.requery();
-        assertEquals(1, c.getCount());
-        assertEquals(1, DatabaseUtils.longForQuery(mDatabase,
-                "select count(*) from " + TEST_TABLE, null));
-        c.close();
-    }
-
-    @SmallTest
-    public void testAttachDb() {
-        String newDb = "/sdcard/mydata.db";
-        File f = new File(newDb);
-        if (f.exists()) {
-            f.delete();
-        }
-        assertFalse(f.exists());
-        SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(newDb, null);
-        db.execSQL("create table test1 (i int);");
-        db.execSQL("insert into test1 values(1);");
-        db.execSQL("insert into test1 values(11);");
-        Cursor c = null;
-        try {
-            c = db.rawQuery("select * from test1", null);
-            int count = c.getCount();
-            Log.i(TAG, "count: " + count);
-            assertEquals(2, count);
-        } finally {
-            c.close();
-            db.close();
-            c = null;
-        }
-
-        mDatabase.execSQL("attach database ? as newDb" , new String[]{newDb});
-        Cursor c1 = null;
-        try {
-            c1 = mDatabase.rawQuery("select * from newDb.test1", null);
-            assertEquals(2, c1.getCount());
-        } catch (Exception e) {
-            fail("unexpected exception: " + e.getMessage());
-        } finally {
-            if (c1 != null) {
-                c1.close();
-            }
-        }
-        List<Pair<String, String>> dbs = mDatabase.getAttachedDbs();
-        for (Pair<String, String> p: dbs) {
-            Log.i(TAG, "attached dbs: " + p.first + " : " + p.second);
-        }
-        assertEquals(2, dbs.size());
-     }
-
-    /**
-     * http://b/issue?id=2943028
-     * SQLiteOpenHelper maintains a Singleton even if it is in bad state.
-     */
-    @SmallTest
-    public void testCloseAndReopen() {
-        mDatabase.close();
-        TestOpenHelper helper = new TestOpenHelper(getContext(), DB_NAME, null,
-                CURRENT_DATABASE_VERSION, new DefaultDatabaseErrorHandler());
-        mDatabase = helper.getWritableDatabase();
-        createTableAndClearCache();
-        mDatabase.execSQL("INSERT into " + TEST_TABLE + " values(10, 999);");
-        Cursor c = mDatabase.query(TEST_TABLE, new String[]{"i", "j"}, null, null, null, null, null);
-        assertEquals(1, c.getCount());
-        c.close();
-        mDatabase.close();
-        assertFalse(mDatabase.isOpen());
-        mDatabase = helper.getReadableDatabase();
-        assertTrue(mDatabase.isOpen());
-        c = mDatabase.query(TEST_TABLE, new String[]{"i", "j"}, null, null, null, null, null);
-        assertEquals(1, c.getCount());
-        c.close();
-    }
-    private class TestOpenHelper extends SQLiteOpenHelper {
-        public TestOpenHelper(Context context, String name, CursorFactory factory, int version,
-                DatabaseErrorHandler errorHandler) {
-            super(context, name, factory, version, errorHandler);
-        }
-        @Override public void onCreate(SQLiteDatabase db) {}
-        @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {}
-    }
-}
diff --git a/core/tests/coretests/src/android/database/sqlite/SQLiteStatementTest.java b/core/tests/coretests/src/android/database/sqlite/SQLiteStatementTest.java
deleted file mode 100644
index 955336a..0000000
--- a/core/tests/coretests/src/android/database/sqlite/SQLiteStatementTest.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.database.sqlite;
-
-import android.content.Context;
-import android.test.AndroidTestCase;
-import android.test.suitebuilder.annotation.LargeTest;
-import android.test.suitebuilder.annotation.SmallTest;
-
-import java.io.File;
-import java.util.Random;
-import java.util.concurrent.locks.ReentrantLock;
-
-public class SQLiteStatementTest extends AndroidTestCase {
-    private SQLiteDatabase mDatabase;
-    private File mDatabaseFile;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        File dbDir = getContext().getDir(this.getClass().getName(), Context.MODE_PRIVATE);
-        mDatabaseFile = new File(dbDir, "database_test.db");
-        if (mDatabaseFile.exists()) {
-            mDatabaseFile.delete();
-        }
-        mDatabase = SQLiteDatabase.openOrCreateDatabase(mDatabaseFile.getPath(), null);
-        assertNotNull(mDatabase);
-    }
-
-    @Override
-    protected void tearDown() throws Exception {
-        mDatabase.close();
-        mDatabaseFile.delete();
-        super.tearDown();
-    }
-
-    /**
-     * Start 2 threads to repeatedly execute the above SQL statement.
-     * Even though 2 threads are executing the same SQL, they each should get their own copy of
-     * prepared SQL statement id and there SHOULD NOT be an error from sqlite or android.
-     * @throws InterruptedException thrown if the test threads started by this test are interrupted
-     */
-    @LargeTest
-    public void testUseOfSameSqlStatementBy2Threads() throws InterruptedException {
-        mDatabase.execSQL("CREATE TABLE test_pstmt (i INTEGER PRIMARY KEY, j text);");
-        final String stmt = "SELECT * FROM test_pstmt WHERE i = ?";
-        class RunStmtThread extends Thread {
-            @Override public void run() {
-                // do it enough times to make sure there are no corner cases going untested
-                for (int i = 0; i < 1000; i++) {
-                    SQLiteStatement s1 = mDatabase.compileStatement(stmt);
-                    s1.bindLong(1, i);
-                    s1.execute();
-                    s1.close();
-                 }
-            }
-        }
-        RunStmtThread t1 = new RunStmtThread();
-        t1.start();
-        RunStmtThread t2 = new RunStmtThread();
-        t2.start();
-         while (t1.isAlive() || t2.isAlive()) {
-             Thread.sleep(10);
-         }
-     }
-
-    /**
-     * A simple test: start 2 threads to repeatedly execute the same {@link SQLiteStatement}.
-     * The 2 threads take turns to use the {@link SQLiteStatement}; i.e., it is NOT in use
-     * by both the threads at the same time.
-     *
-     * @throws InterruptedException thrown if the test threads started by this test are interrupted
-     */
-    @LargeTest
-    public void testUseOfSameSqliteStatementBy2Threads() throws InterruptedException {
-        mDatabase.execSQL("CREATE TABLE test_pstmt (i INTEGER PRIMARY KEY, j text);");
-        final String stmt = "SELECT * FROM test_pstmt WHERE i = ?";
-        final SQLiteStatement s1 = mDatabase.compileStatement(stmt);
-        class RunStmtThread extends Thread {
-            @Override public void run() {
-                // do it enough times to make sure there are no corner cases going untested
-                for (int i = 0; i < 1000; i++) {
-                    lock();
-                    try {
-                        s1.bindLong(1, i);
-                        s1.execute();
-                    } finally {
-                        unlock();
-                    }
-                    Thread.yield();
-                }
-            }
-        }
-        RunStmtThread t1 = new RunStmtThread();
-        t1.start();
-        RunStmtThread t2 = new RunStmtThread();
-        t2.start();
-        while (t1.isAlive() || t2.isAlive()) {
-            Thread.sleep(10);
-        }
-    }
-    /** Synchronize on this when accessing the SqliteStatemet in the above */
-    private final ReentrantLock mLock = new ReentrantLock(true);
-    private void lock() {
-        mLock.lock();
-    }
-    private void unlock() {
-        mLock.unlock();
-    }
-
-    /**
-     * Tests the following: a {@link SQLiteStatement} object should not refer to a
-     * pre-compiled SQL statement id except in during the period of binding the arguments
-     * and executing the SQL statement.
-     */
-    @LargeTest
-    public void testReferenceToPrecompiledStatementId() {
-        mDatabase.execSQL("create table t (i int, j text);");
-        verifyReferenceToPrecompiledStatementId(false);
-        verifyReferenceToPrecompiledStatementId(true);
-
-        // a small stress test to make sure there are no side effects of
-        // the acquire & release of pre-compiled statement id by SQLiteStatement object.
-        for (int i = 0; i < 100; i++) {
-            verifyReferenceToPrecompiledStatementId(false);
-            verifyReferenceToPrecompiledStatementId(true);
-        }
-    }
-
-    @SuppressWarnings("deprecation")
-    private void verifyReferenceToPrecompiledStatementId(boolean wal) {
-        if (wal) {
-            mDatabase.enableWriteAheadLogging();
-        } else {
-            mDatabase.disableWriteAheadLogging();
-        }
-        // test with INSERT statement - doesn't use connection pool, if WAL is set
-        SQLiteStatement stmt = mDatabase.compileStatement("insert into t values(?,?);");
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        // sql statement should not be compiled yet
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        int colValue = new Random().nextInt();
-        stmt.bindLong(1, colValue);
-        // verify that the sql statement is still not compiled
-        assertEquals(0, stmt.getSqlStatementId());
-        // should still be using the mDatabase connection - verify
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        stmt.bindString(2, "blah" + colValue);
-        // verify that the sql statement is still not compiled
-        assertEquals(0, stmt.getSqlStatementId());
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        stmt.executeInsert();
-        // now that the statement is executed, pre-compiled statement should be released
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        stmt.close();
-        // pre-compiled SQL statement should still remain released from this object
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        // but the database handle should still be the same
-        assertEquals(mDatabase, stmt.mDatabase);
-
-        // test with a SELECT statement - uses connection pool if WAL is set
-        stmt = mDatabase.compileStatement("select i from t where j=?;");
-        // sql statement should not be compiled yet
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        stmt.bindString(1, "blah" + colValue);
-        // verify that the sql statement is still not compiled
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        // execute the statement
-        Long l = stmt.simpleQueryForLong();
-        assertEquals(colValue, l.intValue());
-        // now that the statement is executed, pre-compiled statement should be released
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-        stmt.close();
-        // pre-compiled SQL statement should still remain released from this object
-        assertEquals(0, stmt.nStatement);
-        assertEquals(0, stmt.getSqlStatementId());
-        // but the database handle should still remain attached to the statement
-        assertEquals(mDatabase.mNativeHandle, stmt.nHandle);
-        assertEquals(mDatabase, stmt.mDatabase);
-    }
-}
diff --git a/core/tests/coretests/src/android/database/sqlite/SQLiteUnfinalizedExceptionTest.java b/core/tests/coretests/src/android/database/sqlite/SQLiteUnfinalizedExceptionTest.java
deleted file mode 100644
index cd2005d..0000000
--- a/core/tests/coretests/src/android/database/sqlite/SQLiteUnfinalizedExceptionTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.database.sqlite;
-
-import android.content.Context;
-import android.database.sqlite.SQLiteDatabaseTest.ClassToTestSqlCompilationAndCaching;
-import android.test.AndroidTestCase;
-import android.test.suitebuilder.annotation.SmallTest;
-
-import java.io.File;
-
-public class SQLiteUnfinalizedExceptionTest extends AndroidTestCase {
-    private SQLiteDatabase mDatabase;
-    private File mDatabaseFile;
-    private static final String TABLE_NAME = "testCursor";
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        File dbDir = getContext().getDir(this.getClass().getName(), Context.MODE_PRIVATE);
-        mDatabaseFile = new File(dbDir, "UnfinalizedExceptionTest.db");
-        if (mDatabaseFile.exists()) {
-            mDatabaseFile.delete();
-        }
-        mDatabase = SQLiteDatabase.openOrCreateDatabase(mDatabaseFile.getPath(), null);
-        assertNotNull(mDatabase);
-    }
-
-    @Override
-    protected void tearDown() throws Exception {
-        mDatabase.close();
-        mDatabaseFile.delete();
-        super.tearDown();
-    }
-
-    @SmallTest
-    public void testUnfinalizedExceptionNotExcpected() {
-        mDatabase.execSQL("CREATE TABLE " + TABLE_NAME + " (i int, j int);");
-        // the above statement should be in SQLiteDatabase.mPrograms
-        // and should automatically be finalized when database is closed
-        mDatabase.lock();
-        try {
-            mDatabase.closeDatabase();
-        } finally {
-            mDatabase.unlock();
-        }
-    }
-
-    @SmallTest
-    public void testUnfinalizedException() {
-        mDatabase.execSQL("CREATE TABLE " + TABLE_NAME + " (i int, j int);");
-        mDatabase.lock();
-        mDatabase.closePendingStatements(); // clears the above from finalizer queue in mdatabase
-        mDatabase.unlock();
-        ClassToTestSqlCompilationAndCaching.create(mDatabase, "select * from "  + TABLE_NAME);
-        // since the above is NOT closed, closing database should fail
-        mDatabase.lock();
-        try {
-            mDatabase.closeDatabase();
-            fail("exception expected");
-        } catch (SQLiteUnfinalizedObjectsException e) {
-            // expected
-        } finally {
-            mDatabase.unlock();
-        }
-    }
-}