internal static sqlite3_stmt GetSqliteStatement(string sql, sqlite3 db)
 {
     sqlite3_stmt statement;
     int rc= raw.sqlite3_prepare_v2(db, sql, out statement);
     VerifySQLiteResponse(rc, raw.SQLITE_OK, db);
     return statement;
 }

        internal static void Bind(sqlite3 db, sqlite3_stmt stm, int index, object value)
        {
            int rc = 0;

            if (value == null)
            {
                rc = raw.sqlite3_bind_null(stm, index);
            }
            else
            {
                if (IsSupportedInteger(value))
                {
                    rc = raw.sqlite3_bind_int64(stm, index, GetInteger(value));
                }
                else if (IsSupportedFloat(value))
                {
                    rc = raw.sqlite3_bind_double(stm, index, GetFloat(value));
                }
                else if (IsSupportedText(value))
                {
                    rc = raw.sqlite3_bind_text(stm, index, value.ToString());
                }
                else if (value is byte[])
                {
                    rc = raw.sqlite3_bind_blob(stm, index, (byte[])value);
                }
                else
                {
                    throw new SQLiteException("Unable to bind parameter with unsupported type: " + value.GetType().FullName);
                }
            }

            VerifySQLiteResponse(rc, raw.SQLITE_OK, db);
        }

 internal static void VerifySQLiteResponse(int result, int expectedResult, sqlite3 db)
 {
     if (result != expectedResult)
     {
         string sqliteErrorMessage = raw.sqlite3_errmsg(db);
         throw new SQLiteException(string.Format("Error executing SQLite command: '{0}'.", sqliteErrorMessage));
     }
 }

        private sqlite3_stmt BuildCommand(sqlite3 db, string sql, object[] paramArgs)
        {
            if (db == null) {
                throw new ArgumentNullException("db");
            }

            sqlite3_stmt command = null;
            try
            {
                if (!IsOpen) {
                    Open(Path);
                }

                lock(Cursor.StmtDisposeLock)
                {
                    LastErrorCode = raw.sqlite3_prepare_v2(db, sql, out command);
                }

                if (LastErrorCode != raw.SQLITE_OK || command == null)
                {
                    Log.E(TAG, "sqlite3_prepare_v2: " + LastErrorCode);
                }

                if (paramArgs != null && paramArgs.Length > 0 && command != null && LastErrorCode != raw.SQLITE_ERROR)
                {
                    command.bind(paramArgs);
                }
            }
            catch (Exception e)
            {
                Log.E(TAG, "Error when build a sql " + sql + " with params " + paramArgs, e);
                throw;
            }

            return command;
        }

        void OpenSqliteConnection(int flags, SymmetricKey encryptionKey, out sqlite3 db)
        {
            LastErrorCode = raw.sqlite3_open_v2(Path, out db, flags, null);
            if (LastErrorCode != raw.SQLITE_OK) {
                Path = null;
                var errMessage = "Failed to open SQLite storage engine at path {0}".Fmt(Path);
                throw new CouchbaseLiteException(errMessage, StatusCode.DbError);
            }

#if !__ANDROID__ && !NET_3_5 && VERBOSE
                var i = 0;
                var val = raw.sqlite3_compileoption_get(i);
                while (val != null)
                {
                    Log.V(TAG, "Sqlite Config: {0}".Fmt(val));
                    val = raw.sqlite3_compileoption_get(++i);
                }
#endif

            Log.D(TAG, "Open {0} (flags={1}{2})", Path, flags, (encryptionKey != null ? ", encryption key given" : ""));

            raw.sqlite3_create_collation(db, "JSON", null, CouchbaseSqliteJsonUnicodeCollationFunction.Compare);
            raw.sqlite3_create_collation(db, "JSON_ASCII", null, CouchbaseSqliteJsonAsciiCollationFunction.Compare);
            raw.sqlite3_create_collation(db, "JSON_RAW", null, CouchbaseSqliteJsonRawCollationFunction.Compare);
            raw.sqlite3_create_collation(db, "REVID", null, CouchbaseSqliteRevIdCollationFunction.Compare);
        }

 static public int sqlite3_wal_checkpoint(sqlite3 db, string dbName)
 {
     return _imp.sqlite3_wal_checkpoint(db.ptr, dbName);
 }

 static public int sqlite3_blob_open(sqlite3 db, string sdb, string table, string col, long rowid, int flags, out sqlite3_blob blob)
 {
     IntPtr p;
     int rc = _imp.sqlite3_blob_open(db.ptr, sdb, table, col, rowid, flags, out p);
     blob = new sqlite3_blob(p);
     return rc;
 }

        static public sqlite3_stmt sqlite3_next_stmt(sqlite3 db, sqlite3_stmt stmt)
        {
            IntPtr prev = IntPtr.Zero;
            if (stmt != null)
            {
                prev = stmt.ptr;
            }

            IntPtr p = _imp.sqlite3_next_stmt(db.ptr, prev);

            if (p == IntPtr.Zero)
            {
                return null;
            }
            else
            {
                return db.find_stmt(p);
            }
        }

 static public int sqlite3_exec(sqlite3 db, string sql)
 {
     string errmsg;
     return _imp.sqlite3_exec(db.ptr, sql, null, null, out errmsg);
 }

 static public string sqlite3_db_filename(sqlite3 db, string att)
 {
     return _imp.sqlite3_db_filename(db.ptr, att);
 }

 static public int sqlite3_db_readonly(sqlite3 db, string dbName)
 {
     return _imp.sqlite3_db_readonly(db.ptr, dbName);
 }

 static public string sqlite3_errmsg(sqlite3 db)
 {
     return _imp.sqlite3_errmsg(db.ptr);
 }

 static public int sqlite3_db_status(sqlite3 db, int op, out int current, out int highest, int resetFlg)
 {
     return _imp.sqlite3_db_status(db.ptr, op, out current, out highest, resetFlg);
 }

 static public int sqlite3_create_function(sqlite3 db, string name, int nArg, object v, delegate_function_aggregate_step func_step, delegate_function_aggregate_final func_final)
 {
     return _imp.sqlite3_create_function(db.ptr, name, nArg, v, func_step, func_final);
 }

 static public int sqlite3_prepare_v2(sqlite3 db, string sql, out sqlite3_stmt stmt, out string tail)
 {
     IntPtr p;
     int rc = _imp.sqlite3_prepare_v2(db.ptr, sql, out p, out tail);
     stmt = new sqlite3_stmt(p, db);
     return rc;
 }

 static public long sqlite3_last_insert_rowid(sqlite3 db)
 {
     return _imp.sqlite3_last_insert_rowid(db.ptr);
 }

        static public int sqlite3_table_column_metadata(sqlite3 db, string dbName, string tblName, string colName, out string dataType, out string collSeq, out int notNull, out int primaryKey, out int autoInc)
        {

            return _imp.sqlite3_table_column_metadata(db.ptr, dbName, tblName, colName, out dataType, out collSeq, out notNull, out primaryKey, out autoInc);
        }

 static public int sqlite3_total_changes(sqlite3 db)
 {
     return _imp.sqlite3_total_changes(db.ptr);
 }

 static public sqlite3_backup sqlite3_backup_init(sqlite3 destDb, string destName, sqlite3 sourceDb, string sourceName)
 {
     IntPtr p = _imp.sqlite3_backup_init(destDb.ptr, destName, sourceDb.ptr, sourceName);
     return new sqlite3_backup(p);
 }

 static public int sqlite3_get_autocommit(sqlite3 db)
 {
     return _imp.sqlite3_get_autocommit(db.ptr);
 }