SQLite Android Bindings

            long connectionPtr, long statementPtr, CursorWindow win,
            int startPos, int requiredPos, boolean countAllRows);
    private static native int nativeGetDbLookaside(long connectionPtr);
    private static native void nativeCancel(long connectionPtr);
    private static native void nativeResetCancel(long connectionPtr, boolean cancelable);

    private static native boolean nativeHasCodec();
    private static native void nativeEnableLoadExtension(long connectionPtr, boolean enable);

    public static boolean hasCodec(){ return nativeHasCodec(); }

    private SQLiteConnection(SQLiteConnectionPool pool,
            SQLiteDatabaseConfiguration configuration,
            int connectionId, boolean primaryConnection) {
        mPool = pool;
        mConfiguration = new SQLiteDatabaseConfiguration(configuration);

        mConnectionPtr = nativeOpen(mConfiguration.path, mConfiguration.openFlags,
                mConfiguration.label,
                SQLiteDebug.DEBUG_SQL_STATEMENTS, SQLiteDebug.DEBUG_SQL_TIME);

        setPageSize();
        setForeignKeyModeFromConfiguration();
        setJournalSizeLimit();
        setAutoCheckpointInterval();
        if( !nativeHasCodec() ){
            setWalModeFromConfiguration();
            setLocaleFromConfiguration();
        }
        setLoadExtensionFromConfiguration();

        // Register custom functions.
        final int functionCount = mConfiguration.customFunctions.size();
        for (int i = 0; i < functionCount; i++) {
            SQLiteCustomFunction function = mConfiguration.customFunctions.get(i);
            nativeRegisterCustomFunction(mConnectionPtr, function);
        }

                setSyncMode(SQLiteGlobal.getWALSyncMode());
            } else {
                setJournalMode(SQLiteGlobal.getDefaultJournalMode());
                setSyncMode(SQLiteGlobal.getDefaultSyncMode());
            }
        }
    }

    // NOTE: Extension for sqlite.org bindings
    private void setLoadExtensionFromConfiguration() {
        if ((mConfiguration.openFlags & SQLiteDatabase.ENABLE_LOAD_EXTENSION) != 0) {
            nativeEnableLoadExtension(mConnectionPtr, true);
        } else {
            nativeEnableLoadExtension(mConnectionPtr, false);
        }
    }

    private void setSyncMode(String newValue) {
        String value = executeForString("PRAGMA synchronous", null, null);
        if (!canonicalizeSyncMode(value).equalsIgnoreCase(
                canonicalizeSyncMode(newValue))) {
            execute("PRAGMA synchronous=" + newValue, null, null);
        }

        // Remember what changed.
        boolean foreignKeyModeChanged = configuration.foreignKeyConstraintsEnabled
                != mConfiguration.foreignKeyConstraintsEnabled;
        boolean walModeChanged = ((configuration.openFlags ^ mConfiguration.openFlags)
                & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0;
        boolean localeChanged = !configuration.locale.equals(mConfiguration.locale);
        // NOTE: Extension for sqlite.org bindings
        boolean loadExtSqlChanged = ((configuration.openFlags ^ mConfiguration.openFlags)
                & SQLiteDatabase.ENABLE_LOAD_EXTENSION) != 0;

        // Update configuration parameters.
        mConfiguration.updateParametersFrom(configuration);

        // Update prepared statement cache size.
        /* mPreparedStatementCache.resize(configuration.maxSqlCacheSize); */

            setWalModeFromConfiguration();
        }

        // Update locale.
        if (localeChanged) {
            setLocaleFromConfiguration();
        }

        // Update LOAD_EXTENSIONS support (sqlite.org extension)
        if (loadExtSqlChanged) {
            setLoadExtensionFromConfiguration();
        }
    }

    // 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;

import org.sqlite.os.OperationCanceledException;
import android.text.TextUtils;
import android.util.EventLog;
import android.util.Log;
import android.util.Pair;
import android.util.Printer;



import java.io.File;
import java.io.FileFilter;
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.Map.Entry;
import java.util.WeakHashMap;

/**

     * Write-ahead logging cannot be used with read-only databases so the value of
     * this flag is ignored if the database is opened read-only.
     *
     * @see #enableWriteAheadLogging
     */
    public static final int ENABLE_WRITE_AHEAD_LOGGING = 0x20000000;

    /**
     * NOTE: THIS IS AN ADDITION TO THE INTERFACE FOR THE SQLITE.ORG BINDINGS.
     *
     * Open flag: Flag for {@link #openDatabase} to specify that loadable extensions
     * should be allowed via SQL or API.
     *
     * @see #enableLoadExtension
     */
    public static final int ENABLE_LOAD_EXTENSION = 0x01000000;

    /**
     * Absolute max value that can be set by {@link #setMaxSqlCacheSize(int)}.
     *
     * 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;

    public boolean isWriteAheadLoggingEnabled() {
        synchronized (mLock) {
            throwIfNotOpenLocked();

            return (mConfigurationLocked.openFlags & ENABLE_WRITE_AHEAD_LOGGING) != 0;
        }
    }

    /**
     * NOTE: THIS IS AN ADDITION TO THE INTERFACE FOR THE SQLITE.ORG BINDINGS.
     *
     * This method will enable the Load_Extension SQL function and related API call.
     *
     * Note that it is more efficient to enable this as part of the open flags.
     *
     * @return true if successful or already enabled.
     * @see #ENABLE_LOAD_EXTENSION
     */
    public boolean enableLoadExtension() {
        synchronized (mLock) {
            throwIfNotOpenLocked();

            if ((mConfigurationLocked.openFlags & ENABLE_LOAD_EXTENSION) != 0) {
                return true;
            }

            mConfigurationLocked.openFlags |= ENABLE_LOAD_EXTENSION;
            try {
                mConnectionPoolLocked.reconfigure(mConfigurationLocked);
            } catch (RuntimeException ex) {
                mConfigurationLocked.openFlags &= ~ENABLE_LOAD_EXTENSION;
                throw ex;
            }
        }
        return true;
    }

    /**
     * NOTE: THIS IS AN ADDITION TO THE INTERFACE FOR THE SQLITE.ORG BINDINGS.
     *
     * This method will disable the Load_Extension SQL function and related API call.
     *
     * @return true if successful or already enabled.
     *
     * @see #enableLoadExtension()
     * @see #ENABLE_LOAD_EXTENSION
     */
    public void disableLoadExtension() {
        synchronized (mLock) {
            throwIfNotOpenLocked();

            if ((mConfigurationLocked.openFlags & ENABLE_LOAD_EXTENSION) == 0) {
                return;
            }

            mConfigurationLocked.openFlags &= ~ENABLE_LOAD_EXTENSION;
            try {
                mConnectionPoolLocked.reconfigure(mConfigurationLocked);
            } catch (RuntimeException ex) {
                mConfigurationLocked.openFlags |= ENABLE_LOAD_EXTENSION;
                throw ex;
            }
        }
    }

    /**
     * NOTE: THIS IS AN ADDITION TO THE INTERFACE FOR THE SQLITE.ORG BINDINGS.
     *
     * Returns true if loading extensions has been enabled for this database.
     *
     * @return True if loading extensions has been enabled for this database.
     *
     * @see #enableLoadExtension()
     * @see #ENABLE_LOAD_EXTENSION
     */
    public boolean isLoadExtensionEnabled() {
        synchronized (mLock) {
            throwIfNotOpenLocked();

            return (mConfigurationLocked.openFlags & ENABLE_LOAD_EXTENSION) != 0;
        }
    }

    /**
     * Collect statistics about all open databases in the current process.
     * Used by bug report.
     */
    static ArrayList<DbStats> getDbStats() {
        ArrayList<DbStats> dbStatsList = new ArrayList<DbStats>();

    if (cancelable) {
        sqlite3_progress_handler(connection->db, 4, sqliteProgressHandlerCallback,
                connection);
    } else {
        sqlite3_progress_handler(connection->db, 0, NULL, NULL);
    }
}

/** NOTE: Extension for sqlite.org bindings */
static void nativeEnableLoadExtension(JNIEnv* env, jobject clazz, jlong connectionPtr, jboolean enable) {
    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
    sqlite3_enable_load_extension(connection->db, enable ? 1 : 0);
}

static jboolean nativeHasCodec(JNIEnv* env, jobject clazz){
#ifdef SQLITE_HAS_CODEC
  return true;
#else
  return false;
#endif

            (void*)nativeExecuteForCursorWindow },
    { "nativeGetDbLookaside", "(J)I",
            (void*)nativeGetDbLookaside },
    { "nativeCancel", "(J)V",
            (void*)nativeCancel },
    { "nativeResetCancel", "(JZ)V",
            (void*)nativeResetCancel },
    { "nativeEnableLoadExtension", "(JZ)V",
            (void*)nativeEnableLoadExtension },

    { "nativeHasCodec", "()Z", (void*)nativeHasCodec },
};

#define FIND_CLASS(var, className) \
        var = env->FindClass(className); \
        LOG_FATAL_IF(! var, "Unable to find class " className);