int nStep, nSort, nIndex;  /* Statistics for most recent operation */
  int nVMStep;               /* Another statistic for most recent operation */
  int nTransaction;          /* Number of nested [transaction] methods */
  int openFlags;             /* Flags used to open.  (SQLITE_OPEN_URI) */
#ifdef SQLITE_TEST
  int bLegacyPrepare;        /* True to use sqlite3_prepare() */
#endif
  Tcl_DString dsErr;         /* Used for error messages (utf8Encoding) */
};

struct IncrblobChannel {
  sqlite3_blob *pBlob;      /* sqlite3 blob handle */
  SqliteDb *pDb;            /* Associated database connection */
  int iSeek;                /* Current seek offset */
  Tcl_Channel channel;      /* Channel identifier */
  IncrblobChannel *pNext;   /* Linked list of all open incrblob channels */
  IncrblobChannel *pPrev;   /* Linked list of all open incrblob channels */
};

/*
 ** Tcl UTF-8 encoding; loaded and tested on module init. Depending
 ** on unicode support detected, it is reset to NULL or kept until
 ** module gets unloaded.
 */
static Tcl_Encoding utf8Encoding = NULL;
static int utf8EncInit = 0;
TCL_DECLARE_MUTEX(utf8EncMutex);

/*
** Compute a string length that is limited to what can be stored in
** lower 30 bits of a 32-bit signed integer.
*/
static int strlen30(const char *z){
  const char *z2 = z;
  while( *z2 ){ z2++; }
  return 0x3fffffff & (int)(z2 - z);
}

#ifdef USE_TCL_STUBS
# define tclStubsPtr staticTclStubsPtr
static const TclStubs *tclStubsPtr = 0;
#endif

/*
 ** Error message converter.
 */
static const char *SQLITEDB_ERRMSG(SqliteDb *pDb){
  if( pDb!=NULL ){
    if( pDb->db!=NULL ){
      if( utf8Encoding!=NULL ){
        Tcl_DStringFree(&pDb->dsErr);
        Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_errmsg(pDb->db),
            -1, &pDb->dsErr);
        return Tcl_DStringValue(&pDb->dsErr);
      }
      return sqlite3_errmsg(pDb->db);
    }
    return "not a valid database";
  }
  return "unknown error";
}

#ifndef SQLITE_OMIT_INCRBLOB
/*
** Close all incrblob channels opened using database connection pDb.
** This is called when shutting down the database connection.
*/
static void closeIncrblobChannels(SqliteDb *pDb){

*/
static int SQLITE_TCLAPI incrblobClose(
  ClientData instanceData,
  Tcl_Interp *interp
){
  IncrblobChannel *p = (IncrblobChannel *)instanceData;
  int rc = sqlite3_blob_close(p->pBlob);
  SqliteDb *pDb = p->pDb;

  /* Remove the channel from the SqliteDb.pIncrblob list. */
  if( p->pNext ){
    p->pNext->pPrev = p->pPrev;
  }
  if( p->pPrev ){
    p->pPrev->pNext = p->pNext;
  }
  if( p->pDb->pIncrblob==p ){
    p->pDb->pIncrblob = p->pNext;
  }

  /* Free the IncrblobChannel structure */
  Tcl_Free((char *)p);

  if( rc!=SQLITE_OK ){
    Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
    return TCL_ERROR;
  }
  return TCL_OK;
}

/*
** Read data from an incremental blob channel.

  /* This variable is used to name the channels: "incrblob_[incr count]" */
  static int count = 0;
  char zChannel[64];

  rc = sqlite3_blob_open(db, zDb, zTable, zColumn, iRow, !isReadonly, &pBlob);
  if( rc!=SQLITE_OK ){
    Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
    return TCL_ERROR;
  }

  p = (IncrblobChannel *)Tcl_Alloc(sizeof(IncrblobChannel));
  p->iSeek = 0;
  p->pBlob = pBlob;

  }
  if( pDb->pWalHook ){
    Tcl_DecrRefCount(pDb->pWalHook);
  }
  if( pDb->pCollateNeeded ){
    Tcl_DecrRefCount(pDb->pCollateNeeded);
  }
  Tcl_DStringFree(&pDb->dsErr);
  Tcl_Free((char*)pDb);
}

/*
** This routine is called when a database file is locked while trying
** to execute SQL.
*/

  assert( pDb->pPreUpdateHook );
  assert( db==pDb->db );
  assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );

  pCmd = Tcl_DuplicateObj(pDb->pPreUpdateHook);
  Tcl_IncrRefCount(pCmd);
  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(azStr[(op-1)/9], -1));
  if( utf8Encoding!=NULL ){
    Tcl_DString ds;
    Tcl_ExternalToUtfDString(utf8Encoding, zDb, -1, &ds);
    Tcl_ListObjAppendElement(0, pCmd,
        Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds)));
    Tcl_DStringFree(&ds);
    Tcl_ExternalToUtfDString(utf8Encoding, zTbl, -1, &ds);
    Tcl_ListObjAppendElement(0, pCmd,
        Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds)));
    Tcl_DStringFree(&ds);
  }else{
    Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));
    Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));
  }
  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(iKey1));
  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(iKey2));
  Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  Tcl_DecrRefCount(pCmd);
}
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */

  assert( pDb->pUpdateHook );
  assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );

  pCmd = Tcl_DuplicateObj(pDb->pUpdateHook);
  Tcl_IncrRefCount(pCmd);
  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(azStr[(op-1)/9], -1));
  if( utf8Encoding!=NULL ){
    Tcl_DString ds;
    Tcl_ExternalToUtfDString(utf8Encoding, zDb, -1, &ds);
    Tcl_ListObjAppendElement(0, pCmd,
        Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds)));
    Tcl_DStringFree(&ds);
    Tcl_ExternalToUtfDString(utf8Encoding, zTbl, -1, &ds);
    Tcl_ListObjAppendElement(0, pCmd,
        Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds)));
    Tcl_DStringFree(&ds);
  }else{
    Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));
    Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));
  }
  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(rowid));
  Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  Tcl_DecrRefCount(pCmd);
}

static void tclCollateNeeded(
  void *pCtx,
  sqlite3 *db,
  int enc,
  const char *zName
){
  SqliteDb *pDb = (SqliteDb *)pCtx;
  Tcl_Obj *pScript = Tcl_DuplicateObj(pDb->pCollateNeeded);
  Tcl_IncrRefCount(pScript);
  if( utf8Encoding!=NULL ){
    Tcl_DString ds;
    Tcl_ExternalToUtfDString(utf8Encoding, zName, -1, &ds);
    Tcl_ListObjAppendElement(0, pScript,
        Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds)));
    Tcl_DStringFree(&ds);
  }else{
    Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(zName, -1));
  }
  Tcl_EvalObjEx(pDb->interp, pScript, 0);
  Tcl_DecrRefCount(pScript);
}

/*
** This routine is called to evaluate an SQL collation function implemented
** using TCL script.
*/
static int tclSqlCollate(
  void *pCtx,
  int nA,
  const void *zA,
  int nB,
  const void *zB
){
  SqlCollate *p = (SqlCollate *)pCtx;
  Tcl_Obj *pCmd;

  pCmd = Tcl_NewStringObj(p->zScript, -1);
  Tcl_IncrRefCount(pCmd);
  if( utf8Encoding!=NULL ){
    Tcl_DString dsA, dsB;
    Tcl_ExternalToUtfDString(utf8Encoding, (char*)zA, nA, &dsA);
    Tcl_ExternalToUtfDString(utf8Encoding, (char*)zB, nB, &dsB);
    Tcl_ListObjAppendElement(p->interp, pCmd,
        Tcl_NewStringObj(Tcl_DStringValue(&dsA), Tcl_DStringLength(&dsA)));
    Tcl_ListObjAppendElement(p->interp, pCmd,
        Tcl_NewStringObj(Tcl_DStringValue(&dsB), Tcl_DStringLength(&dsB)));
    Tcl_DStringFree(&dsA);
    Tcl_DStringFree(&dsB);
  }else{
    Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zA, nA));
    Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zB, nB));
  }
  Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
  Tcl_DecrRefCount(pCmd);
  return (atoi(Tcl_GetStringResult(p->interp)));
}

/*
** This routine is called to evaluate an SQL function implemented

    ** That way, when Tcl_EvalObjv() is run and shimmers the first element
    ** of the list to tclCmdNameType, that alternate representation will
    ** be preserved and reused on the next invocation.
    */
    Tcl_Obj **aArg;
    int nArg;
    if( Tcl_ListObjGetElements(p->interp, p->pScript, &nArg, &aArg) ){
resultError:
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_UtfToExternalDString(utf8Encoding, Tcl_GetStringResult(p->interp),
            -1, &ds);
        sqlite3_result_error(context, Tcl_DStringValue(&ds),
            Tcl_DStringLength(&ds));
        Tcl_DStringFree(&ds);
      }else{
        sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
      }
      return;
    }
    pCmd = Tcl_NewListObj(nArg, aArg);
    Tcl_IncrRefCount(pCmd);
    for(i=0; i<argc; i++){
      sqlite3_value *pIn = argv[i];
      Tcl_Obj *pVal;

        }
        case SQLITE_NULL: {
          pVal = Tcl_NewStringObj(p->pDb->zNull, -1);
          break;
        }
        default: {
          int bytes = sqlite3_value_bytes(pIn);
          if( utf8Encoding!=NULL ){
            Tcl_DString ds;
            Tcl_ExternalToUtfDString(utf8Encoding,
                (char *)sqlite3_value_text(pIn), bytes, &ds);
            pVal = Tcl_NewStringObj(Tcl_DStringValue(&ds),
                       Tcl_DStringLength(&ds));
            Tcl_DStringFree(&ds);
          }else{
            pVal = Tcl_NewStringObj((char *)sqlite3_value_text(pIn), bytes);
          }
          break;
        }
      }
      rc = Tcl_ListObjAppendElement(p->interp, pCmd, pVal);
      if( rc ){
        Tcl_DecrRefCount(pCmd);

        goto resultError;
      }
    }
    if( !p->useEvalObjv ){
      /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd
      ** is a list without a string representation.  To prevent this from
      ** happening, make sure pCmd has a valid string representation */
      Tcl_GetString(pCmd);
    }
    rc = Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
    Tcl_DecrRefCount(pCmd);
  }

  if( rc && rc!=TCL_RETURN ){
    goto resultError;
  }else{
    Tcl_Obj *pVar = Tcl_GetObjResult(p->interp);
    int n;
    u8 *data;
    const char *zType = (pVar->typePtr ? pVar->typePtr->name : "");
    char c = zType[0];
    int eType = p->eType;

      ** and try to rollback the transaction.
      **
      ** But it could also be that the user executed one or more BEGIN,
      ** COMMIT, SAVEPOINT, RELEASE or ROLLBACK commands that are confusing
      ** this method's logic. Not clear how this would be best handled.
      */
    if( rc!=TCL_ERROR ){
      Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
      rc = TCL_ERROR;
    }
    sqlite3_exec(pDb->db, "ROLLBACK", 0, 0, 0);
  }
  pDb->disableAuth--;

  return rc;

  int nVar = 0;                   /* Number of variables in statement */
  int iParm = 0;                  /* Next free entry in apParm */
  char c;
  int i;
  int needResultReset = 0;        /* Need to invoke Tcl_ResetResult() */
  int rc = SQLITE_OK;             /* Value to return */
  Tcl_Interp *interp = pDb->interp;
  Tcl_DString ds;

  *ppPreStmt = 0;

  /* Trim spaces from the start of zSql and calculate the remaining length. */
  while( (c = zSql[0])==' ' || c=='\t' || c=='\r' || c=='\n' ){ zSql++; }
  nSql = strlen30(zSql);

  /* If no prepared statement was found. Compile the SQL text. Also allocate
  ** a new SqlPreparedStmt structure.  */
  if( pPreStmt==0 ){
    int nByte;

    if( SQLITE_OK!=dbPrepare(pDb, zSql, &pStmt, pzOut) ){
      Tcl_SetObjResult(interp, Tcl_NewStringObj(SQLITEDB_ERRMSG(pDb), -1));
      return TCL_ERROR;
    }
    if( pStmt==0 ){
      if( SQLITE_OK!=sqlite3_errcode(pDb->db) ){
        /* A compile-time error in the statement. */
        Tcl_SetObjResult(interp, Tcl_NewStringObj(SQLITEDB_ERRMSG(pDb), -1));
        return TCL_ERROR;
      }else{
        /* The statement was a no-op.  Continue to the next statement
        ** in the SQL string.
        */
        return TCL_OK;
      }

#endif
  }
  assert( pPreStmt );
  assert( strlen30(pPreStmt->zSql)==pPreStmt->nSql );
  assert( 0==memcmp(pPreStmt->zSql, zSql, pPreStmt->nSql) );

  /* Bind values to parameters that begin with $ or : */
  Tcl_DStringInit(&ds);
  for(i=1; i<=nVar; i++){
    const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
    if( utf8Encoding!= NULL ){
      Tcl_DStringFree(&ds);
      Tcl_ExternalToUtfDString(utf8Encoding, zVar, -1, &ds);
      zVar = Tcl_DStringValue(&ds);
    }
    if( zVar!=0 && (zVar[0]=='$' || zVar[0]==':' || zVar[0]=='@') ){
      Tcl_Obj *pVar = Tcl_GetVar2Ex(interp, &zVar[1], 0, 0);
      if( pVar==0 && pDb->zBindFallback!=0 ){
        Tcl_Obj *pCmd;
        int rx;
        pCmd = Tcl_NewStringObj(pDb->zBindFallback, -1);
        Tcl_IncrRefCount(pCmd);

          Tcl_GetDoubleFromObj(interp, pVar, &r);
          sqlite3_bind_double(pStmt, i, r);
        }else if( (c=='w' && strcmp(zType,"wideInt")==0) ||
              (c=='i' && strcmp(zType,"int")==0) ){
          Tcl_WideInt v;
          Tcl_GetWideIntFromObj(interp, pVar, &v);
          sqlite3_bind_int64(pStmt, i, v);
        }else if( utf8Encoding!=NULL ){
          Tcl_DStringFree(&ds);
          Tcl_UtfToExternalDString(utf8Encoding, Tcl_GetString(pVar),
              pVar->length, &ds);
          sqlite3_bind_text(pStmt, i, Tcl_DStringValue(&ds),
              Tcl_DStringLength(&ds), SQLITE_TRANSIENT);
          Tcl_IncrRefCount(pVar);
          pPreStmt->apParm[iParm++] = pVar;
        }else{
          data = (unsigned char *)Tcl_GetString(pVar);
          sqlite3_bind_text(pStmt, i, (char *)data, pVar->length, SQLITE_STATIC);
          Tcl_IncrRefCount(pVar);
          pPreStmt->apParm[iParm++] = pVar;
        }
      }else{
        sqlite3_bind_null(pStmt, i);
      }
      if( needResultReset ) Tcl_ResetResult(pDb->interp);
    }
  }
  Tcl_DStringFree(&ds);
  pPreStmt->nParm = iParm;
  *ppPreStmt = pPreStmt;
  if( needResultReset && rc==TCL_OK ) Tcl_ResetResult(pDb->interp);

  return rc;
}

**   dbEvalRowInfo()
**   dbEvalColumnValue()
*/
typedef struct DbEvalContext DbEvalContext;
struct DbEvalContext {
  SqliteDb *pDb;                  /* Database handle */
  Tcl_Obj *pSql;                  /* Object holding string zSql */
  Tcl_DString dsSql;              /* Encoded SQL text */
  const char *zSql;               /* Remaining SQL to execute */
  SqlPreparedStmt *pPreStmt;      /* Current statement */
  int nCol;                       /* Number of columns returned by pStmt */
  int evalFlags;                  /* Flags used */
  Tcl_Obj *pArray;                /* Name of array variable */
  Tcl_Obj **apColName;            /* Array of column names */
};

  SqliteDb *pDb,                  /* Database handle */
  Tcl_Obj *pSql,                  /* Object containing SQL script */
  Tcl_Obj *pArray,                /* Name of Tcl array to set (*) element of */
  int evalFlags                   /* Flags controlling evaluation */
){
  memset(p, 0, sizeof(DbEvalContext));
  p->pDb = pDb;
  if( utf8Encoding!=NULL ){
    p->zSql = Tcl_UtfToExternalDString(utf8Encoding, Tcl_GetString(pSql),
                  pSql->length, &p->dsSql);
  }else{
    Tcl_DStringInit(&p->dsSql);
    p->zSql = Tcl_GetString(pSql);
  }
  p->pSql = pSql;
  Tcl_IncrRefCount(pSql);
  if( pArray ){
    p->pArray = pArray;
    Tcl_IncrRefCount(pArray);
  }
  p->evalFlags = evalFlags;

    int nCol;                     /* Number of columns returned by pStmt */
    Tcl_Obj **apColName = 0;      /* Array of column names */

    p->nCol = nCol = sqlite3_column_count(pStmt);
    if( nCol>0 && (papColName || p->pArray) ){
      apColName = (Tcl_Obj**)Tcl_Alloc( sizeof(Tcl_Obj*)*nCol );
      for(i=0; i<nCol; i++){
        if( utf8Encoding!=NULL ){
          Tcl_DString ds;
          Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_column_name(pStmt,i),
              -1, &ds);
          apColName[i] = Tcl_NewStringObj(Tcl_DStringValue(&ds),
                             Tcl_DStringLength(&ds));
          Tcl_DStringFree(&ds);
        }else{
          apColName[i] = Tcl_NewStringObj(sqlite3_column_name(pStmt,i), -1);
        }
        Tcl_IncrRefCount(apColName[i]);
      }
      p->apColName = apColName;
    }

    /* If results are being stored in an array variable, then create
    ** the array(*) entry for that array

          ** This only happens once. If there is a second SQLITE_SCHEMA
          ** error, the error will be returned to the caller. */
          p->zSql = zPrevSql;
          continue;
        }
#endif
        Tcl_SetObjResult(pDb->interp,
            Tcl_NewStringObj(SQLITEDB_ERRMSG(pDb), -1));
        return TCL_ERROR;
      }else{
        dbReleaseStmt(pDb, pPreStmt, 0);
      }
    }
  }

    dbReleaseStmt(p->pDb, p->pPreStmt, 0);
    p->pPreStmt = 0;
  }
  if( p->pArray ){
    Tcl_DecrRefCount(p->pArray);
    p->pArray = 0;
  }
  Tcl_DStringFree(&p->dsSql);
  Tcl_DecrRefCount(p->pSql);
  dbReleaseColumnNames(p);
}

/*
** Return a pointer to a Tcl_Obj structure with ref-count 0 that contains
** the value for the iCol'th column of the row currently pointed to by

    case SQLITE_FLOAT: {
      return Tcl_NewDoubleObj(sqlite3_column_double(pStmt, iCol));
    }
    case SQLITE_NULL: {
      return Tcl_NewStringObj(p->pDb->zNull, -1);
    }
  }
  if( utf8Encoding!=NULL ){
    Tcl_DString ds;
    Tcl_Obj *obj;
    Tcl_ExternalToUtfDString(utf8Encoding,
        (char*)sqlite3_column_text(pStmt, iCol), -1, &ds);
    obj = Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));
    Tcl_DStringFree(&ds);
    return obj;
  }
  return Tcl_NewStringObj((char*)sqlite3_column_text(pStmt, iCol), -1);
}

/*
** If using Tcl version 8.6 or greater, use the NR functions to avoid
** recursive evalution of scripts by the [db eval] and [db trans]
** commands. Even if the headers used while compiling the extension

    }else if( objc==4 ){
      zSrcDb = Tcl_GetString(objv[2]);
      zDestFile = Tcl_GetString(objv[3]);
    }else{
      Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? FILENAME");
      return TCL_ERROR;
    }
    if( utf8Encoding!=NULL ){
      Tcl_DString ds;
      Tcl_UtfToExternalDString(utf8Encoding, zDestFile, -1, &ds);
      rc = sqlite3_open_v2(Tcl_DStringValue(&ds), &pDest,
               SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE| pDb->openFlags, 0);
      Tcl_DStringFree(&ds);
    }else{
      rc = sqlite3_open_v2(zDestFile, &pDest,
               SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE| pDb->openFlags, 0);
    }
    if( rc!=SQLITE_OK ){
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_errmsg(pDest), -1, &ds);
        Tcl_AppendResult(interp, "cannot open target database: ",
             Tcl_DStringValue(&ds), (char*)0);
        Tcl_DStringFree(&ds);
      }else{
        Tcl_AppendResult(interp, "cannot open target database: ",
             sqlite3_errmsg(pDest), (char*)0);
      }
      sqlite3_close(pDest);
      return TCL_ERROR;
    }
    if( utf8Encoding!=NULL ){
      Tcl_DString ds;
      Tcl_UtfToExternalDString(utf8Encoding, zSrcDb, -1, &ds);
      pBackup = sqlite3_backup_init(pDest, "main", pDb->db,
                    Tcl_DStringValue(&ds));
      Tcl_DStringFree(&ds);
    }else{
      pBackup = sqlite3_backup_init(pDest, "main", pDb->db, zSrcDb);
    }
    if( pBackup==0 ){
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_errmsg(pDest), -1, &ds);
        Tcl_AppendResult(interp, "backup failed: ",
             Tcl_DStringValue(&ds), (char*)0);
        Tcl_DStringFree(&ds);
      }else{
        Tcl_AppendResult(interp, "backup failed: ",
             sqlite3_errmsg(pDest), (char*)0);
      }
      sqlite3_close(pDest);
      return TCL_ERROR;
    }
    while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
    sqlite3_backup_finish(pBackup);
    if( rc==SQLITE_DONE ){
      rc = TCL_OK;
    }else{
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_errmsg(pDest), -1, &ds);
        Tcl_AppendResult(interp, "backup failed: ",
             Tcl_DStringValue(&ds), (char*)0);
        Tcl_DStringFree(&ds);
      }else{
        Tcl_AppendResult(interp, "backup failed: ",
             sqlite3_errmsg(pDest), (char*)0);
      }
      rc = TCL_ERROR;
    }
    sqlite3_close(pDest);
    break;
  }

  /*    $db bind_fallback ?CALLBACK?

  ** that function is called, invoke SCRIPT to evaluate the function.
  */
  case DB_COLLATE: {
    SqlCollate *pCollate;
    char *zName;
    char *zScript;
    int nScript;
    Tcl_DString ds;
    if( objc!=4 ){
      Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");
      return TCL_ERROR;
    }
    zName = Tcl_GetString(objv[2]);
    if( utf8Encoding!=NULL ){
      Tcl_UtfToExternalDString(utf8Encoding, zName, -1, &ds);
      zName = Tcl_DStringValue(&ds);
    }else{
      Tcl_DStringInit(&ds);
    }
    zScript = Tcl_GetStringFromObj(objv[3], &nScript);
    pCollate = (SqlCollate*)Tcl_Alloc( sizeof(*pCollate) + nScript + 1 );
    if( pCollate==0 ) return TCL_ERROR;
    pCollate->interp = interp;
    pCollate->pNext = pDb->pCollate;
    pCollate->zScript = (char*)&pCollate[1];
    pDb->pCollate = pCollate;
    memcpy(pCollate->zScript, zScript, nScript+1);
    if( sqlite3_create_collation_v2(pDb->db, zName, SQLITE_UTF8,
        pCollate, tclSqlCollate, 0) ){
      Tcl_DStringFree(&ds);
      Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
      return TCL_ERROR;
    }
    Tcl_DStringFree(&ds);
    break;
  }

  /*
  **     $db collation_needed SCRIPT
  **
  ** Create a new SQL collation function called NAME.  Whenever

       strcmp(zConflict, "ignore"  ) != 0 &&
       strcmp(zConflict, "replace" ) != 0 ) {
      Tcl_AppendResult(interp, "Error: \"", zConflict,
            "\", conflict-algorithm must be one of: rollback, "
            "abort, fail, ignore, or replace", (char*)0);
      return TCL_ERROR;
    }
    if( utf8Encoding!=NULL ){
      Tcl_DString ds;
      Tcl_UtfToExternalDString(utf8Encoding, zTable, -1, &ds);
      zSql = sqlite3_mprintf("SELECT * FROM '%q'", Tcl_DStringValue(&ds));
      Tcl_DStringFree(&ds);
    }else{
      zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
    }
    if( zSql==0 ){
      Tcl_AppendResult(interp, "Error: no such table: ", zTable, (char*)0);
      return TCL_ERROR;
    }
    nByte = strlen30(zSql);
    rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    if( rc ){
      Tcl_AppendResult(interp, "Error: ", (char*)SQLITEDB_ERRMSG(pDb),
          (char*)0);
      nCol = 0;
    }else{
      nCol = sqlite3_column_count(pStmt);
    }
    sqlite3_finalize(pStmt);
    if( nCol==0 ) {
      return TCL_ERROR;
    }
    zSql = sqlite3_malloc( nByte + 50 + nCol*2 );
    if( zSql==0 ) {
      Tcl_AppendResult(interp, "Error: can't malloc()", (char*)0);
      return TCL_ERROR;
    }
    if( utf8Encoding!=NULL ){
      Tcl_DString ds;
      Tcl_UtfToExternalDString(utf8Encoding, zTable, -1, &ds);
      sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",
                       zConflict, Tcl_DStringValue(&ds));
      Tcl_DStringFree(&ds);
    }else{
      sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",
                       zConflict, zTable);
    }
    j = strlen30(zSql);
    for(i=1; i<nCol; i++){
      zSql[j++] = ',';
      zSql[j++] = '?';
    }
    zSql[j++] = ')';
    zSql[j] = 0;
    rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    if( rc ){
      Tcl_AppendResult(interp, "Error: ", (char*)SQLITEDB_ERRMSG(pDb),
          (char*)0);
      sqlite3_finalize(pStmt);
      return TCL_ERROR;
    }
    in = Tcl_OpenFileChannel(interp, zFile, "r", 0666);
    if( in==0 ){
      sqlite3_finalize(pStmt);
      return TCL_ERROR;

        break;
      }
      for(i=0; i<nCol; i++){
        /* check for null data, if so, bind as null */
        if( (azCol[i][0]==0) || (nNull>0 && strcmp(azCol[i], zNull)==0)
        ){
          sqlite3_bind_null(pStmt, i+1);
        }else if( utf8Encoding!=NULL ){
          Tcl_DString ds;
          Tcl_UtfToExternalDString(utf8Encoding, azCol[i], -1, &ds);
          sqlite3_bind_text(pStmt, i+1, Tcl_DStringValue(&ds),
              Tcl_DStringLength(&ds), SQLITE_TRANSIENT);
          Tcl_DStringFree(&ds);
        }else{
          sqlite3_bind_text(pStmt, i+1, azCol[i], strlen30(azCol[i]),
              SQLITE_STATIC);
        }
      }
      sqlite3_step(pStmt);
      rc = sqlite3_reset(pStmt);
      Tcl_DStringSetLength(&str, 0);
      if( rc!=SQLITE_OK ){
        Tcl_AppendResult(interp,"Error: ", (char*)SQLITEDB_ERRMSG(pDb),
            (char*)0);
        zCommit = "ROLLBACK";
        break;
      }
    }
    Tcl_DStringFree(&str);
    sqlite3_free(azCol);
    Tcl_Close(interp, in);

      int flags;
      if( len>0 ) memcpy(pData, pBA, len);
      if( isReadonly ){
        flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_READONLY;
      }else{
        flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE;
      }
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, (char*)zSchema, -1, &ds);
        xrc = sqlite3_deserialize(pDb->db, Tcl_DStringValue(&ds),
                  pData, len, len, flags);
        Tcl_DStringFree(&ds);
      } else {
        xrc = sqlite3_deserialize(pDb->db, zSchema, pData, len, len, flags);
      }
      if( xrc ){
        Tcl_AppendResult(interp, "unable to set MEMDB content", (char*)0);
        rc = TCL_ERROR;
      }
      if( mxSize>0 ){
        sqlite3_file_control(pDb->db, zSchema,SQLITE_FCNTL_SIZE_LIMIT,&mxSize);
      }

    int flags = SQLITE_UTF8;
    SqlFunc *pFunc;
    Tcl_Obj *pScript;
    char *zName;
    int nArg = -1;
    int i;
    int eType = SQLITE_NULL;
    Tcl_DString ds;
    if( objc<4 ){
      Tcl_WrongNumArgs(interp, 2, objv, "NAME ?SWITCHES? SCRIPT");
      return TCL_ERROR;
    }
    for(i=3; i<(objc-1); i++){
      const char *z = Tcl_GetString(objv[i]);
      int n = strlen30(z);

        );
        return TCL_ERROR;
      }
    }

    pScript = objv[objc-1];
    zName = Tcl_GetString(objv[2]);
    if( utf8Encoding!=NULL ){
      Tcl_UtfToExternalDString(utf8Encoding, zName, -1, &ds);
      zName = Tcl_DStringValue(&ds);
    }else{
      Tcl_DStringInit(&ds);
    }
    pFunc = findSqlFunc(pDb, zName);
    if( pFunc==0 ) return TCL_ERROR;
    if( pFunc->pScript ){
      Tcl_DecrRefCount(pFunc->pScript);
    }
    pFunc->pScript = pScript;
    Tcl_IncrRefCount(pScript);
    pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript);
    pFunc->eType = eType;
    rc = sqlite3_create_function_v2(pDb->db, zName, nArg, flags,
        pFunc, tclSqlFunc, 0, 0, 0);
    Tcl_DStringFree(&ds);
    if( rc!=SQLITE_OK ){
      rc = TCL_ERROR;
      Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
    }
    break;
  }

  /*
  **     $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
  */

      zDb = Tcl_GetString(objv[2]);
    }
    zTable = Tcl_GetString(objv[objc-3]);
    zColumn = Tcl_GetString(objv[objc-2]);
    rc = Tcl_GetWideIntFromObj(interp, objv[objc-1], &iRow);

    if( rc==TCL_OK ){
      if( utf8Encoding!=NULL ){
        Tcl_DString ds1, ds2, ds3;
        Tcl_UtfToExternalDString(utf8Encoding, zDb, -1, &ds1);
        Tcl_UtfToExternalDString(utf8Encoding, zTable, -1, &ds2);
        Tcl_UtfToExternalDString(utf8Encoding, zColumn, -1, &ds3);
        rc = createIncrblobChannel(
            interp, pDb, Tcl_DStringValue(&ds1), Tcl_DStringValue(&ds2),
            Tcl_DStringValue(&ds3), (sqlite3_int64)iRow, isReadonly
        );
        Tcl_DStringFree(&ds1);
        Tcl_DStringFree(&ds2);
        Tcl_DStringFree(&ds3);
      }else{
        rc = createIncrblobChannel(
            interp, pDb, zDb, zTable, zColumn, (sqlite3_int64)iRow, isReadonly
        );
      }
    }
#endif
    break;
  }

  /*
  **     $db interrupt

      Tcl_WrongNumArgs(interp, 2, objv, "KEY");
      return TCL_ERROR;
    }
#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
    pKey = Tcl_GetByteArrayFromObj(objv[2], &nKey);
    rc = sqlite3_rekey(pDb->db, pKey, nKey);
    if( rc ){
      if( utf8Encoding!=NULL){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_errstr(rc), -1, &ds);
        Tcl_AppendResult(interp, Tcl_DStringValue(&ds), (char*)0);
        Tcl_DStringFree(&ds);
      }else{
        Tcl_AppendResult(interp, sqlite3_errstr(rc), (char*)0);
      }
      rc = TCL_ERROR;
    }
#endif
    break;
  }

  /*    $db restore ?DATABASE? FILENAME

    }else if( objc==4 ){
      zDestDb = Tcl_GetString(objv[2]);
      zSrcFile = Tcl_GetString(objv[3]);
    }else{
      Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? FILENAME");
      return TCL_ERROR;
    }
    if( utf8Encoding!=NULL ){
      Tcl_DString ds;
      Tcl_UtfToExternalDString(utf8Encoding, zSrcFile, -1, &ds);
      rc = sqlite3_open_v2(Tcl_DStringValue(&ds), &pSrc,
               SQLITE_OPEN_READONLY | pDb->openFlags, 0);
      Tcl_DStringFree(&ds);
    }else{
      rc = sqlite3_open_v2(zSrcFile, &pSrc,
                           SQLITE_OPEN_READONLY | pDb->openFlags, 0);
    }
    if( rc!=SQLITE_OK ){
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, sqlite3_errmsg(pSrc), -1, &ds);
        Tcl_AppendResult(interp, "cannot open source database: ",
             Tcl_DStringValue(&ds), (char*)0);
        Tcl_DStringFree(&ds);
      }else{
        Tcl_AppendResult(interp, "cannot open source database: ",
             sqlite3_errmsg(pSrc), (char*)0);
      }
      sqlite3_close(pSrc);
      return TCL_ERROR;
    }
    if( utf8Encoding!=NULL ){
      Tcl_DString ds;
      Tcl_UtfToExternalDString(utf8Encoding, zDestDb, -1, &ds);
      pBackup = sqlite3_backup_init(pDb->db, Tcl_DStringValue(&ds), pSrc,
                    "main");
      Tcl_DStringFree(&ds);
    }else{
      pBackup = sqlite3_backup_init(pDb->db, zDestDb, pSrc, "main");
    }
    if( pBackup==0 ){
      Tcl_AppendResult(interp, "restore failed: ",
          (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
      sqlite3_close(pSrc);
      return TCL_ERROR;
    }
    while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
              || rc==SQLITE_BUSY ){
      if( rc==SQLITE_BUSY ){
        if( nTimeout++ >= 3 ) break;
        sqlite3_sleep(100);
      }
    }
    sqlite3_backup_finish(pBackup);
    if( rc==SQLITE_DONE ){
      rc = TCL_OK;
    }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
      Tcl_AppendResult(interp, "restore failed: source database busy",
                       (char*)0);
      rc = TCL_ERROR;
    }else{
      Tcl_AppendResult(interp, "restore failed: ",
          (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
      rc = TCL_ERROR;
    }
    sqlite3_close(pSrc);
    break;
  }

  /*

    sqlite3_int64 sz = 0;
    unsigned char *pData;
    if( objc!=2 && objc!=3 ){
      Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE?");
      rc = TCL_ERROR;
    }else{
      int needFree;
      if( utf8Encoding!=NULL ){
        Tcl_DString ds;
        Tcl_ExternalToUtfDString(utf8Encoding, (char*)zSchema, -1, &ds);
        pData = sqlite3_serialize(pDb->db, Tcl_DStringValue(&ds), &sz,
                    SQLITE_SERIALIZE_NOCOPY);
        Tcl_DStringFree(&ds);
      } else {
        pData = sqlite3_serialize(pDb->db, zSchema, &sz,
                    SQLITE_SERIALIZE_NOCOPY);
      }
      if( pData ){
        needFree = 0;
      }else{
        pData = sqlite3_serialize(pDb->db, zSchema, &sz, 0);
        needFree = 1;
      }
      Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pData,sz));

    pScript = objv[objc-1];

    /* Run the SQLite BEGIN command to open a transaction or savepoint. */
    pDb->disableAuth++;
    rc = sqlite3_exec(pDb->db, zBegin, 0, 0, 0);
    pDb->disableAuth--;
    if( rc!=SQLITE_OK ){
      Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
      return TCL_ERROR;
    }
    pDb->nTransaction++;

    /* If using NRE, schedule a callback to invoke the script pScript, then
    ** a second callback to commit (or rollback) the transaction or savepoint
    ** opened above. If not using NRE, evaluate the script directly, then

        xNotify = DbUnlockNotify;
        pNotifyArg = (void *)pDb;
        pDb->pUnlockNotify = objv[2];
        Tcl_IncrRefCount(pDb->pUnlockNotify);
      }

      if( sqlite3_unlock_notify(pDb->db, xNotify, pNotifyArg) ){
        Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
        rc = TCL_ERROR;
      }
    }
#endif
    break;
  }

        }

        if( rc==SQLITE_OK ){
          Tcl_Obj *pObj;
          pObj = Tcl_NewStringObj((char*)sqlite3_value_text(pValue), -1);
          Tcl_SetObjResult(interp, pObj);
        }else{
          Tcl_AppendResult(interp, (char*)SQLITEDB_ERRMSG(pDb), (char*)0);
          return TCL_ERROR;
        }
      }
    }
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
    break;
  }

      Tcl_AppendResult(interp, "unknown option: ", zArg, (char*)0);
      return TCL_ERROR;
    }
  }
  zErrMsg = 0;
  p = (SqliteDb*)Tcl_Alloc( sizeof(*p) );
  memset(p, 0, sizeof(*p));
  Tcl_DStringInit(&p->dsErr);
  if( zFile==0 ) zFile = "";
  zFile = Tcl_TranslateFileName(interp, zFile, &translatedFilename);
  if( utf8Encoding!=NULL ){
    Tcl_DString ds1, ds2;
    Tcl_UtfToExternalDString(utf8Encoding, zFile, -1, &ds1);
    if ( zVfs!=NULL ){
      Tcl_UtfToExternalDString(utf8Encoding, zVfs, -1, &ds2);
      zVfs = Tcl_DStringValue(&ds2);
    }
    rc = sqlite3_open_v2(Tcl_DStringValue(&ds1), &p->db, flags, zVfs);
    Tcl_DStringFree(&ds1);
    if( zVfs!=NULL ){
      Tcl_DStringFree(&ds2);
    }
  }else{
    rc = sqlite3_open_v2(zFile, &p->db, flags, zVfs);
  }
  Tcl_DStringFree(&translatedFilename);
  if( p->db ){
    if( SQLITE_OK!=sqlite3_errcode(p->db) ){
      zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));
      sqlite3_close(p->db);
      p->db = 0;
    }
  }else{
    zErrMsg = sqlite3_mprintf("%s", sqlite3_errstr(rc));
  }
#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
  if( p->db ){
    sqlite3_key(p->db, pKey, nKey);
  }
#endif
  if( p->db==0 ){
    if( utf8Encoding!=NULL && zErrMsg ){
      Tcl_DString ds;
      Tcl_ExternalToUtfDString(utf8Encoding, zErrMsg, -1, &ds);
      Tcl_AppendResult(interp, Tcl_DStringValue(&ds), (char*)0);
      Tcl_DStringFree(&ds);
    }else{
      Tcl_AppendResult(interp, zErrMsg, (char*)0);
    }
    Tcl_Free((char*)p);
    sqlite3_free(zErrMsg);
    return TCL_ERROR;
  }
  p->maxStmt = NUM_PREPARED_STMTS;
  p->openFlags = flags & SQLITE_OPEN_URI;
  p->interp = interp;

    /* The "sqlite" alias is undocumented.  It is here only to support
    ** legacy scripts.  All new scripts should use only the "sqlite3"
    ** command. */
    Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0);
#endif
    rc = Tcl_PkgProvideEx(interp, "sqlite3", PACKAGE_VERSION, NULL);
  }
  if( !utf8EncInit ){
    Tcl_Encoding enc;
    Tcl_MutexLock(&utf8EncMutex);
    if( ++utf8EncInit>1 ){
      goto utf8EncInitDone;
    }
    enc = Tcl_GetEncoding(NULL, "utf-8");
    /*
     ** Try to detect the level of UTF-8 support in the Tcl core.
     */
    if( enc!=NULL ){
      const char probe1[] = { 0xF0, 0x9F, 0x98, 0x82 };
      const char probe1sp[] = { 0xED, 0xA0, 0xBD, 0xED, 0xB8, 0x82 };
      Tcl_DString ds;
      Tcl_ExternalToUtfDString(enc, probe1, sizeof(probe1), &ds);
      if( Tcl_DStringLength(&ds)==sizeof(probe1) &&
          memcmp(probe1, Tcl_DStringValue(&ds), sizeof(probe1))==0 ){
        /*
         ** Tcl core supports full Unicode.
         */
        Tcl_FreeEncoding(enc);
      }else if( Tcl_DStringLength(&ds)==sizeof(probe1sp) &&
          memcmp(probe1sp, Tcl_DStringValue(&ds), sizeof(probe1sp))==0 ){
        /*
         ** Tcl core supports full Unicode using surrogate pairs,
         ** keep utf8Encoding for conversion to/from 4 byte UTF-8 sequences.
         */
        utf8Encoding = enc;
      }else{
        /*
         ** Tcl core supports BMP only, let SQLite handle corner cases.
         */
        Tcl_FreeEncoding(enc);
      }
      Tcl_DStringFree(&ds);
    }
utf8EncInitDone:
    Tcl_MutexUnlock(&utf8EncMutex);
  }
  return rc;
}

DLLEXPORT int Sqlite3_Unload(Tcl_Interp *interp, int flags){
  Tcl_MutexLock(&utf8EncMutex);
  if( --utf8EncInit<1 ){
    if( utf8Encoding!=NULL ){
      Tcl_FreeEncoding(utf8Encoding);
      utf8Encoding = NULL;
    }
    utf8EncInit = 0;
  }
  Tcl_MutexUnlock(&utf8EncMutex);
  return TCL_OK;
}

DLLEXPORT int Tclsqlite3_Init(Tcl_Interp *interp){
  return Sqlite3_Init(interp);
}

DLLEXPORT int Tclsqlite3_Unload(Tcl_Interp *interp, int flags){
  return Sqlite3_Unload(interp, flags);
}

/* Because it accesses the file-system and uses persistent state, SQLite
** is not considered appropriate for safe interpreters.  Hence, we cause
** the _SafeInit() interfaces return TCL_ERROR.
*/
DLLEXPORT int Sqlite3_SafeInit(Tcl_Interp *interp){ return TCL_ERROR; }
DLLEXPORT int Sqlite3_SafeUnload(Tcl_Interp *interp, int flags){return TCL_ERROR;}



#ifndef SQLITE_3_SUFFIX_ONLY
int Sqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
int Tclsqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
int Sqlite_Unload(Tcl_Interp *interp, int flags){
  return SqLite3_Unload(interp, flags);
}
int Tclsqlite_Unload(Tcl_Interp *interp, int flags){
  return Sqlite3_Unload(interp, flags);
}
#endif

/*
** If the TCLSH macro is defined, add code to make a stand-alone program.
*/
#if defined(TCLSH)