** conversions. The only error that can occur here is a malloc() failure.  */  if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc) ||      createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc) ||      createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc) ||      (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0   ){    assert( sqlite3MallocFailed() );    db->magic = SQLITE_MAGIC_CLOSED;    goto opendb_out;  }  /* Also add a UTF-8 case-insensitive collation sequence. */  createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc);  /* Set flags on the built-in collating sequences */  db->pDfltColl->type = SQLITE_COLL_BINARY;  pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);  if( pColl ){    pColl->type = SQLITE_COLL_NOCASE;  }  /* Open the backend database driver */  rc = sqlite3BtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);  if( rc!=SQLITE_OK ){    sqlite3Error(db, rc, 0);    db->magic = SQLITE_MAGIC_CLOSED;    goto opendb_out;  }  db->aDb[0].pSchema = sqlite3SchemaGet(db->aDb[0].pBt);  db->aDb[1].pSchema = sqlite3SchemaGet(0);  if( db->aDb[0].pSchema ){    ENC(db) = SQLITE_UTF8;  }  /* The default safety_level for the main database is 'full'; for the temp  ** database it is 'NONE'. This matches the pager layer defaults.    */  db->aDb[0].zName = "main";  db->aDb[0].safety_level = 3;#ifndef SQLITE_OMIT_TEMPDB  db->aDb[1].zName = "temp";  db->aDb[1].safety_level = 1;#endif  /* Register all built-in functions, but do not attempt to read the  ** database schema yet. This is delayed until the first time the database  ** is accessed.  */  if( !sqlite3MallocFailed() ){    sqlite3RegisterBuiltinFunctions(db);    sqlite3Error(db, SQLITE_OK, 0);  }  db->magic = SQLITE_MAGIC_OPEN;opendb_out:  if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){    sqlite3_close(db);    db = 0;  }  *ppDb = db;  return sqlite3ApiExit(0, rc);}/*** Open a new database handle.*/int sqlite3_open(  const char *zFilename,   sqlite3 **ppDb ){  return openDatabase(zFilename, ppDb);}#ifndef SQLITE_OMIT_UTF16/*** Open a new database handle.*/int sqlite3_open16(  const void *zFilename,   sqlite3 **ppDb){  char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */  int rc = SQLITE_OK;  sqlite3_value *pVal;  assert( zFilename );  assert( ppDb );  *ppDb = 0;  pVal = sqlite3ValueNew();  sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);  if( zFilename8 ){    rc = openDatabase(zFilename8, ppDb);    if( rc==SQLITE_OK && *ppDb ){      rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);      if( rc!=SQLITE_OK ){        sqlite3_close(*ppDb);        *ppDb = 0;      }    }  }  sqlite3ValueFree(pVal);  return sqlite3ApiExit(0, rc);}#endif /* SQLITE_OMIT_UTF16 *//*** The following routine destroys a virtual machine that is created by** the sqlite3_compile() routine. The integer returned is an SQLITE_** success/failure code that describes the result of executing the virtual** machine.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_finalize(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    rc = SQLITE_OK;  }else{    rc = sqlite3VdbeFinalize((Vdbe*)pStmt);  }  return rc;}/*** Terminate the current execution of an SQL statement and reset it** back to its starting state so that it can be reused. A success code from** the prior execution is returned.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_reset(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    rc = SQLITE_OK;  }else{    rc = sqlite3VdbeReset((Vdbe*)pStmt);    sqlite3VdbeMakeReady((Vdbe*)pStmt, -1, 0, 0, 0);  }  return rc;}/*** Register a new collation sequence with the database handle db.*/int sqlite3_create_collation(  sqlite3* db,   const char *zName,   int enc,   void* pCtx,  int(*xCompare)(void*,int,const void*,int,const void*)){  int rc;  assert( !sqlite3MallocFailed() );  rc = createCollation(db, zName, enc, pCtx, xCompare);  return sqlite3ApiExit(db, rc);}#ifndef SQLITE_OMIT_UTF16/*** Register a new collation sequence with the database handle db.*/int sqlite3_create_collation16(  sqlite3* db,   const char *zName,   int enc,   void* pCtx,  int(*xCompare)(void*,int,const void*,int,const void*)){  int rc = SQLITE_OK;  char *zName8;   assert( !sqlite3MallocFailed() );  zName8 = sqlite3utf16to8(zName, -1);  if( zName8 ){    rc = createCollation(db, zName8, enc, pCtx, xCompare);    sqliteFree(zName8);  }  return sqlite3ApiExit(db, rc);}#endif /* SQLITE_OMIT_UTF16 *//*** Register a collation sequence factory callback with the database handle** db. Replace any previously installed collation sequence factory.*/int sqlite3_collation_needed(  sqlite3 *db,   void *pCollNeededArg,   void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)){  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  db->xCollNeeded = xCollNeeded;  db->xCollNeeded16 = 0;  db->pCollNeededArg = pCollNeededArg;  return SQLITE_OK;}#ifndef SQLITE_OMIT_UTF16/*** Register a collation sequence factory callback with the database handle** db. Replace any previously installed collation sequence factory.*/int sqlite3_collation_needed16(  sqlite3 *db,   void *pCollNeededArg,   void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)){  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  db->xCollNeeded = 0;  db->xCollNeeded16 = xCollNeeded16;  db->pCollNeededArg = pCollNeededArg;  return SQLITE_OK;}#endif /* SQLITE_OMIT_UTF16 */#ifndef SQLITE_OMIT_GLOBALRECOVER/*** This function is now an anachronism. It used to be used to recover from a** malloc() failure, but SQLite now does this automatically.*/int sqlite3_global_recover(){  return SQLITE_OK;}#endif/*** Test to see whether or not the database connection is in autocommit** mode.  Return TRUE if it is and FALSE if not.  Autocommit mode is on** by default.  Autocommit is disabled by a BEGIN statement and reenabled** by the next COMMIT or ROLLBACK.********* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE *******/int sqlite3_get_autocommit(sqlite3 *db){  return db->autoCommit;}#ifdef SQLITE_DEBUG/*** The following routine is subtituted for constant SQLITE_CORRUPT in** debugging builds.  This provides a way to set a breakpoint for when** corruption is first detected.*/int sqlite3Corrupt(void){  return SQLITE_CORRUPT;}#endif#ifndef SQLITE_OMIT_SHARED_CACHE/*** Enable or disable the shared pager and schema features for the** current thread.**** This routine should only be called when there are no open** database connections.*/int sqlite3_enable_shared_cache(int enable){  ThreadData *pTd = sqlite3ThreadData();  if( pTd ){    /* It is only legal to call sqlite3_enable_shared_cache() when there    ** are no currently open b-trees that were opened by the calling thread.    ** This condition is only easy to detect if the shared-cache were     ** previously enabled (and is being disabled).     */    if( pTd->pBtree && !enable ){      assert( pTd->useSharedData );      return SQLITE_MISUSE;    }    pTd->useSharedData = enable;    sqlite3ReleaseThreadData();  }  return sqlite3ApiExit(0, SQLITE_OK);}#endif/*** This is a convenience routine that makes sure that all thread-specific** data for this thread has been deallocated.*/void sqlite3_thread_cleanup(void){  ThreadData *pTd = sqlite3OsThreadSpecificData(0);  if( pTd ){    memset(pTd, 0, sizeof(*pTd));    sqlite3OsThreadSpecificData(-1);  }}/*** Return meta information about a specific column of a database table.** See comment in sqlite3.h (sqlite.h.in) for details.*/#ifdef SQLITE_ENABLE_COLUMN_METADATAint sqlite3_table_column_metadata(  sqlite3 *db,                /* Connection handle */  const char *zDbName,        /* Database name or NULL */  const char *zTableName,     /* Table name */  const char *zColumnName,    /* Column name */  char const **pzDataType,    /* OUTPUT: Declared data type */  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */  int *pAutoinc               /* OUTPUT: True if colums is auto-increment */){  int rc;  char *zErrMsg = 0;  Table *pTab = 0;  Column *pCol = 0;  int iCol;  char const *zDataType = 0;  char const *zCollSeq = 0;  int notnull = 0;  int primarykey = 0;  int autoinc = 0;  /* Ensure the database schema has been loaded */  if( sqlite3SafetyOn(db) ){    return SQLITE_MISUSE;  }  rc = sqlite3Init(db, &zErrMsg);  if( SQLITE_OK!=rc ){    goto error_out;  }  /* Locate the table in question */  pTab = sqlite3FindTable(db, zTableName, zDbName);  if( !pTab || pTab->pSelect ){    pTab = 0;    goto error_out;  }  /* Find the column for which info is requested */  if( sqlite3IsRowid(zColumnName) ){    iCol = pTab->iPKey;    if( iCol>=0 ){      pCol = &pTab->aCol[iCol];    }  }else{    for(iCol=0; iCol<pTab->nCol; iCol++){      pCol = &pTab->aCol[iCol];      if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){        break;      }    }    if( iCol==pTab->nCol ){      pTab = 0;      goto error_out;    }  }  /* The following block stores the meta information that will be returned  ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey  ** and autoinc. At this point there are two possibilities:  **   **     1. The specified column name was rowid", "oid" or "_rowid_"   **        and there is no explicitly declared IPK column.   **  **     2. The table is not a view and the column name identified an   **        explicitly declared column. Copy meta information from *pCol.  */   if( pCol ){    zDataType = pCol->zType;    zCollSeq = pCol->zColl;    notnull = (pCol->notNull?1:0);    primarykey  = (pCol->isPrimKey?1:0);    autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);  }else{    zDataType = "INTEGER";    primarykey = 1;  }  if( !zCollSeq ){    zCollSeq = "BINARY";  }error_out:  if( sqlite3SafetyOff(db) ){    rc = SQLITE_MISUSE;  }  /* Whether the function call succeeded or failed, set the output parameters  ** to whatever their local counterparts contain. If an error did occur,  ** this has the effect of zeroing all output parameters.  */  if( pzDataType ) *pzDataType = zDataType;  if( pzCollSeq ) *pzCollSeq = zCollSeq;  if( pNotNull ) *pNotNull = notnull;  if( pPrimaryKey ) *pPrimaryKey = primarykey;  if( pAutoinc ) *pAutoinc = autoinc;  if( SQLITE_OK==rc && !pTab ){    sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".",         zColumnName, 0);    rc = SQLITE_ERROR;  }  sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);  sqliteFree(zErrMsg);  return sqlite3ApiExit(db, rc);}#endif