"Fossies" - the Fresh Open Source Software Archive

Member "sqlite-autoconf-3320300/tea/generic/tclsqlite3.c" (18 Jun 2020, 126318 Bytes) of package /linux/misc/sqlite-autoconf-3320300.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "tclsqlite3.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 3250100_vs_3250200.

    1 #ifdef USE_SYSTEM_SQLITE
    2 # include <sqlite3.h>
    3 #else
    4 #include "sqlite3.c"
    5 #endif
    6 /*
    7 ** 2001 September 15
    8 **
    9 ** The author disclaims copyright to this source code.  In place of
   10 ** a legal notice, here is a blessing:
   11 **
   12 **    May you do good and not evil.
   13 **    May you find forgiveness for yourself and forgive others.
   14 **    May you share freely, never taking more than you give.
   15 **
   16 *************************************************************************
   17 ** A TCL Interface to SQLite.  Append this file to sqlite3.c and
   18 ** compile the whole thing to build a TCL-enabled version of SQLite.
   19 **
   20 ** Compile-time options:
   21 **
   22 **  -DTCLSH         Add a "main()" routine that works as a tclsh.
   23 **
   24 **  -DTCLSH_INIT_PROC=name
   25 **
   26 **                  Invoke name(interp) to initialize the Tcl interpreter.
   27 **                  If name(interp) returns a non-NULL string, then run
   28 **                  that string as a Tcl script to launch the application.
   29 **                  If name(interp) returns NULL, then run the regular
   30 **                  tclsh-emulator code.
   31 */
   32 #ifdef TCLSH_INIT_PROC
   33 # define TCLSH 1
   34 #endif
   35 
   36 /*
   37 ** If requested, include the SQLite compiler options file for MSVC.
   38 */
   39 #if defined(INCLUDE_MSVC_H)
   40 # include "msvc.h"
   41 #endif
   42 
   43 #if defined(INCLUDE_SQLITE_TCL_H)
   44 # include "sqlite_tcl.h"
   45 #else
   46 # include "tcl.h"
   47 # ifndef SQLITE_TCLAPI
   48 #  define SQLITE_TCLAPI
   49 # endif
   50 #endif
   51 #include <errno.h>
   52 
   53 /*
   54 ** Some additional include files are needed if this file is not
   55 ** appended to the amalgamation.
   56 */
   57 #ifndef SQLITE_AMALGAMATION
   58 # include "sqlite3.h"
   59 # include <stdlib.h>
   60 # include <string.h>
   61 # include <assert.h>
   62   typedef unsigned char u8;
   63 #endif
   64 #include <ctype.h>
   65 
   66 /* Used to get the current process ID */
   67 #if !defined(_WIN32)
   68 # include <signal.h>
   69 # include <unistd.h>
   70 # define GETPID getpid
   71 #elif !defined(_WIN32_WCE)
   72 # ifndef SQLITE_AMALGAMATION
   73 #  ifndef WIN32_LEAN_AND_MEAN
   74 #   define WIN32_LEAN_AND_MEAN
   75 #  endif
   76 #  include <windows.h>
   77 # endif
   78 # include <io.h>
   79 # define isatty(h) _isatty(h)
   80 # define GETPID (int)GetCurrentProcessId
   81 #endif
   82 
   83 /*
   84  * Windows needs to know which symbols to export.  Unix does not.
   85  * BUILD_sqlite should be undefined for Unix.
   86  */
   87 #ifdef BUILD_sqlite
   88 #undef TCL_STORAGE_CLASS
   89 #define TCL_STORAGE_CLASS DLLEXPORT
   90 #endif /* BUILD_sqlite */
   91 
   92 #define NUM_PREPARED_STMTS 10
   93 #define MAX_PREPARED_STMTS 100
   94 
   95 /* Forward declaration */
   96 typedef struct SqliteDb SqliteDb;
   97 
   98 /*
   99 ** New SQL functions can be created as TCL scripts.  Each such function
  100 ** is described by an instance of the following structure.
  101 **
  102 ** Variable eType may be set to SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT,
  103 ** SQLITE_BLOB or SQLITE_NULL. If it is SQLITE_NULL, then the implementation
  104 ** attempts to determine the type of the result based on the Tcl object.
  105 ** If it is SQLITE_TEXT or SQLITE_BLOB, then a text (sqlite3_result_text())
  106 ** or blob (sqlite3_result_blob()) is returned. If it is SQLITE_INTEGER
  107 ** or SQLITE_FLOAT, then an attempt is made to return an integer or float
  108 ** value, falling back to float and then text if this is not possible.
  109 */
  110 typedef struct SqlFunc SqlFunc;
  111 struct SqlFunc {
  112   Tcl_Interp *interp;   /* The TCL interpret to execute the function */
  113   Tcl_Obj *pScript;     /* The Tcl_Obj representation of the script */
  114   SqliteDb *pDb;        /* Database connection that owns this function */
  115   int useEvalObjv;      /* True if it is safe to use Tcl_EvalObjv */
  116   int eType;            /* Type of value to return */
  117   char *zName;          /* Name of this function */
  118   SqlFunc *pNext;       /* Next function on the list of them all */
  119 };
  120 
  121 /*
  122 ** New collation sequences function can be created as TCL scripts.  Each such
  123 ** function is described by an instance of the following structure.
  124 */
  125 typedef struct SqlCollate SqlCollate;
  126 struct SqlCollate {
  127   Tcl_Interp *interp;   /* The TCL interpret to execute the function */
  128   char *zScript;        /* The script to be run */
  129   SqlCollate *pNext;    /* Next function on the list of them all */
  130 };
  131 
  132 /*
  133 ** Prepared statements are cached for faster execution.  Each prepared
  134 ** statement is described by an instance of the following structure.
  135 */
  136 typedef struct SqlPreparedStmt SqlPreparedStmt;
  137 struct SqlPreparedStmt {
  138   SqlPreparedStmt *pNext;  /* Next in linked list */
  139   SqlPreparedStmt *pPrev;  /* Previous on the list */
  140   sqlite3_stmt *pStmt;     /* The prepared statement */
  141   int nSql;                /* chars in zSql[] */
  142   const char *zSql;        /* Text of the SQL statement */
  143   int nParm;               /* Size of apParm array */
  144   Tcl_Obj **apParm;        /* Array of referenced object pointers */
  145 };
  146 
  147 typedef struct IncrblobChannel IncrblobChannel;
  148 
  149 /*
  150 ** There is one instance of this structure for each SQLite database
  151 ** that has been opened by the SQLite TCL interface.
  152 **
  153 ** If this module is built with SQLITE_TEST defined (to create the SQLite
  154 ** testfixture executable), then it may be configured to use either
  155 ** sqlite3_prepare_v2() or sqlite3_prepare() to prepare SQL statements.
  156 ** If SqliteDb.bLegacyPrepare is true, sqlite3_prepare() is used.
  157 */
  158 struct SqliteDb {
  159   sqlite3 *db;               /* The "real" database structure. MUST BE FIRST */
  160   Tcl_Interp *interp;        /* The interpreter used for this database */
  161   char *zBusy;               /* The busy callback routine */
  162   char *zCommit;             /* The commit hook callback routine */
  163   char *zTrace;              /* The trace callback routine */
  164   char *zTraceV2;            /* The trace_v2 callback routine */
  165   char *zProfile;            /* The profile callback routine */
  166   char *zProgress;           /* The progress callback routine */
  167   char *zBindFallback;       /* Callback to invoke on a binding miss */
  168   char *zAuth;               /* The authorization callback routine */
  169   int disableAuth;           /* Disable the authorizer if it exists */
  170   char *zNull;               /* Text to substitute for an SQL NULL value */
  171   SqlFunc *pFunc;            /* List of SQL functions */
  172   Tcl_Obj *pUpdateHook;      /* Update hook script (if any) */
  173   Tcl_Obj *pPreUpdateHook;   /* Pre-update hook script (if any) */
  174   Tcl_Obj *pRollbackHook;    /* Rollback hook script (if any) */
  175   Tcl_Obj *pWalHook;         /* WAL hook script (if any) */
  176   Tcl_Obj *pUnlockNotify;    /* Unlock notify script (if any) */
  177   SqlCollate *pCollate;      /* List of SQL collation functions */
  178   int rc;                    /* Return code of most recent sqlite3_exec() */
  179   Tcl_Obj *pCollateNeeded;   /* Collation needed script */
  180   SqlPreparedStmt *stmtList; /* List of prepared statements*/
  181   SqlPreparedStmt *stmtLast; /* Last statement in the list */
  182   int maxStmt;               /* The next maximum number of stmtList */
  183   int nStmt;                 /* Number of statements in stmtList */
  184   IncrblobChannel *pIncrblob;/* Linked list of open incrblob channels */
  185   int nStep, nSort, nIndex;  /* Statistics for most recent operation */
  186   int nVMStep;               /* Another statistic for most recent operation */
  187   int nTransaction;          /* Number of nested [transaction] methods */
  188   int openFlags;             /* Flags used to open.  (SQLITE_OPEN_URI) */
  189 #ifdef SQLITE_TEST
  190   int bLegacyPrepare;        /* True to use sqlite3_prepare() */
  191 #endif
  192 };
  193 
  194 struct IncrblobChannel {
  195   sqlite3_blob *pBlob;      /* sqlite3 blob handle */
  196   SqliteDb *pDb;            /* Associated database connection */
  197   int iSeek;                /* Current seek offset */
  198   Tcl_Channel channel;      /* Channel identifier */
  199   IncrblobChannel *pNext;   /* Linked list of all open incrblob channels */
  200   IncrblobChannel *pPrev;   /* Linked list of all open incrblob channels */
  201 };
  202 
  203 /*
  204 ** Compute a string length that is limited to what can be stored in
  205 ** lower 30 bits of a 32-bit signed integer.
  206 */
  207 static int strlen30(const char *z){
  208   const char *z2 = z;
  209   while( *z2 ){ z2++; }
  210   return 0x3fffffff & (int)(z2 - z);
  211 }
  212 
  213 
  214 #ifndef SQLITE_OMIT_INCRBLOB
  215 /*
  216 ** Close all incrblob channels opened using database connection pDb.
  217 ** This is called when shutting down the database connection.
  218 */
  219 static void closeIncrblobChannels(SqliteDb *pDb){
  220   IncrblobChannel *p;
  221   IncrblobChannel *pNext;
  222 
  223   for(p=pDb->pIncrblob; p; p=pNext){
  224     pNext = p->pNext;
  225 
  226     /* Note: Calling unregister here call Tcl_Close on the incrblob channel,
  227     ** which deletes the IncrblobChannel structure at *p. So do not
  228     ** call Tcl_Free() here.
  229     */
  230     Tcl_UnregisterChannel(pDb->interp, p->channel);
  231   }
  232 }
  233 
  234 /*
  235 ** Close an incremental blob channel.
  236 */
  237 static int SQLITE_TCLAPI incrblobClose(
  238   ClientData instanceData,
  239   Tcl_Interp *interp
  240 ){
  241   IncrblobChannel *p = (IncrblobChannel *)instanceData;
  242   int rc = sqlite3_blob_close(p->pBlob);
  243   sqlite3 *db = p->pDb->db;
  244 
  245   /* Remove the channel from the SqliteDb.pIncrblob list. */
  246   if( p->pNext ){
  247     p->pNext->pPrev = p->pPrev;
  248   }
  249   if( p->pPrev ){
  250     p->pPrev->pNext = p->pNext;
  251   }
  252   if( p->pDb->pIncrblob==p ){
  253     p->pDb->pIncrblob = p->pNext;
  254   }
  255 
  256   /* Free the IncrblobChannel structure */
  257   Tcl_Free((char *)p);
  258 
  259   if( rc!=SQLITE_OK ){
  260     Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
  261     return TCL_ERROR;
  262   }
  263   return TCL_OK;
  264 }
  265 
  266 /*
  267 ** Read data from an incremental blob channel.
  268 */
  269 static int SQLITE_TCLAPI incrblobInput(
  270   ClientData instanceData,
  271   char *buf,
  272   int bufSize,
  273   int *errorCodePtr
  274 ){
  275   IncrblobChannel *p = (IncrblobChannel *)instanceData;
  276   int nRead = bufSize;         /* Number of bytes to read */
  277   int nBlob;                   /* Total size of the blob */
  278   int rc;                      /* sqlite error code */
  279 
  280   nBlob = sqlite3_blob_bytes(p->pBlob);
  281   if( (p->iSeek+nRead)>nBlob ){
  282     nRead = nBlob-p->iSeek;
  283   }
  284   if( nRead<=0 ){
  285     return 0;
  286   }
  287 
  288   rc = sqlite3_blob_read(p->pBlob, (void *)buf, nRead, p->iSeek);
  289   if( rc!=SQLITE_OK ){
  290     *errorCodePtr = rc;
  291     return -1;
  292   }
  293 
  294   p->iSeek += nRead;
  295   return nRead;
  296 }
  297 
  298 /*
  299 ** Write data to an incremental blob channel.
  300 */
  301 static int SQLITE_TCLAPI incrblobOutput(
  302   ClientData instanceData,
  303   CONST char *buf,
  304   int toWrite,
  305   int *errorCodePtr
  306 ){
  307   IncrblobChannel *p = (IncrblobChannel *)instanceData;
  308   int nWrite = toWrite;        /* Number of bytes to write */
  309   int nBlob;                   /* Total size of the blob */
  310   int rc;                      /* sqlite error code */
  311 
  312   nBlob = sqlite3_blob_bytes(p->pBlob);
  313   if( (p->iSeek+nWrite)>nBlob ){
  314     *errorCodePtr = EINVAL;
  315     return -1;
  316   }
  317   if( nWrite<=0 ){
  318     return 0;
  319   }
  320 
  321   rc = sqlite3_blob_write(p->pBlob, (void *)buf, nWrite, p->iSeek);
  322   if( rc!=SQLITE_OK ){
  323     *errorCodePtr = EIO;
  324     return -1;
  325   }
  326 
  327   p->iSeek += nWrite;
  328   return nWrite;
  329 }
  330 
  331 /*
  332 ** Seek an incremental blob channel.
  333 */
  334 static int SQLITE_TCLAPI incrblobSeek(
  335   ClientData instanceData,
  336   long offset,
  337   int seekMode,
  338   int *errorCodePtr
  339 ){
  340   IncrblobChannel *p = (IncrblobChannel *)instanceData;
  341 
  342   switch( seekMode ){
  343     case SEEK_SET:
  344       p->iSeek = offset;
  345       break;
  346     case SEEK_CUR:
  347       p->iSeek += offset;
  348       break;
  349     case SEEK_END:
  350       p->iSeek = sqlite3_blob_bytes(p->pBlob) + offset;
  351       break;
  352 
  353     default: assert(!"Bad seekMode");
  354   }
  355 
  356   return p->iSeek;
  357 }
  358 
  359 
  360 static void SQLITE_TCLAPI incrblobWatch(
  361   ClientData instanceData,
  362   int mode
  363 ){
  364   /* NO-OP */
  365 }
  366 static int SQLITE_TCLAPI incrblobHandle(
  367   ClientData instanceData,
  368   int dir,
  369   ClientData *hPtr
  370 ){
  371   return TCL_ERROR;
  372 }
  373 
  374 static Tcl_ChannelType IncrblobChannelType = {
  375   "incrblob",                        /* typeName                             */
  376   TCL_CHANNEL_VERSION_2,             /* version                              */
  377   incrblobClose,                     /* closeProc                            */
  378   incrblobInput,                     /* inputProc                            */
  379   incrblobOutput,                    /* outputProc                           */
  380   incrblobSeek,                      /* seekProc                             */
  381   0,                                 /* setOptionProc                        */
  382   0,                                 /* getOptionProc                        */
  383   incrblobWatch,                     /* watchProc (this is a no-op)          */
  384   incrblobHandle,                    /* getHandleProc (always returns error) */
  385   0,                                 /* close2Proc                           */
  386   0,                                 /* blockModeProc                        */
  387   0,                                 /* flushProc                            */
  388   0,                                 /* handlerProc                          */
  389   0,                                 /* wideSeekProc                         */
  390 };
  391 
  392 /*
  393 ** Create a new incrblob channel.
  394 */
  395 static int createIncrblobChannel(
  396   Tcl_Interp *interp,
  397   SqliteDb *pDb,
  398   const char *zDb,
  399   const char *zTable,
  400   const char *zColumn,
  401   sqlite_int64 iRow,
  402   int isReadonly
  403 ){
  404   IncrblobChannel *p;
  405   sqlite3 *db = pDb->db;
  406   sqlite3_blob *pBlob;
  407   int rc;
  408   int flags = TCL_READABLE|(isReadonly ? 0 : TCL_WRITABLE);
  409 
  410   /* This variable is used to name the channels: "incrblob_[incr count]" */
  411   static int count = 0;
  412   char zChannel[64];
  413 
  414   rc = sqlite3_blob_open(db, zDb, zTable, zColumn, iRow, !isReadonly, &pBlob);
  415   if( rc!=SQLITE_OK ){
  416     Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
  417     return TCL_ERROR;
  418   }
  419 
  420   p = (IncrblobChannel *)Tcl_Alloc(sizeof(IncrblobChannel));
  421   p->iSeek = 0;
  422   p->pBlob = pBlob;
  423 
  424   sqlite3_snprintf(sizeof(zChannel), zChannel, "incrblob_%d", ++count);
  425   p->channel = Tcl_CreateChannel(&IncrblobChannelType, zChannel, p, flags);
  426   Tcl_RegisterChannel(interp, p->channel);
  427 
  428   /* Link the new channel into the SqliteDb.pIncrblob list. */
  429   p->pNext = pDb->pIncrblob;
  430   p->pPrev = 0;
  431   if( p->pNext ){
  432     p->pNext->pPrev = p;
  433   }
  434   pDb->pIncrblob = p;
  435   p->pDb = pDb;
  436 
  437   Tcl_SetResult(interp, (char *)Tcl_GetChannelName(p->channel), TCL_VOLATILE);
  438   return TCL_OK;
  439 }
  440 #else  /* else clause for "#ifndef SQLITE_OMIT_INCRBLOB" */
  441   #define closeIncrblobChannels(pDb)
  442 #endif
  443 
  444 /*
  445 ** Look at the script prefix in pCmd.  We will be executing this script
  446 ** after first appending one or more arguments.  This routine analyzes
  447 ** the script to see if it is safe to use Tcl_EvalObjv() on the script
  448 ** rather than the more general Tcl_EvalEx().  Tcl_EvalObjv() is much
  449 ** faster.
  450 **
  451 ** Scripts that are safe to use with Tcl_EvalObjv() consists of a
  452 ** command name followed by zero or more arguments with no [...] or $
  453 ** or {...} or ; to be seen anywhere.  Most callback scripts consist
  454 ** of just a single procedure name and they meet this requirement.
  455 */
  456 static int safeToUseEvalObjv(Tcl_Interp *interp, Tcl_Obj *pCmd){
  457   /* We could try to do something with Tcl_Parse().  But we will instead
  458   ** just do a search for forbidden characters.  If any of the forbidden
  459   ** characters appear in pCmd, we will report the string as unsafe.
  460   */
  461   const char *z;
  462   int n;
  463   z = Tcl_GetStringFromObj(pCmd, &n);
  464   while( n-- > 0 ){
  465     int c = *(z++);
  466     if( c=='$' || c=='[' || c==';' ) return 0;
  467   }
  468   return 1;
  469 }
  470 
  471 /*
  472 ** Find an SqlFunc structure with the given name.  Or create a new
  473 ** one if an existing one cannot be found.  Return a pointer to the
  474 ** structure.
  475 */
  476 static SqlFunc *findSqlFunc(SqliteDb *pDb, const char *zName){
  477   SqlFunc *p, *pNew;
  478   int nName = strlen30(zName);
  479   pNew = (SqlFunc*)Tcl_Alloc( sizeof(*pNew) + nName + 1 );
  480   pNew->zName = (char*)&pNew[1];
  481   memcpy(pNew->zName, zName, nName+1);
  482   for(p=pDb->pFunc; p; p=p->pNext){
  483     if( sqlite3_stricmp(p->zName, pNew->zName)==0 ){
  484       Tcl_Free((char*)pNew);
  485       return p;
  486     }
  487   }
  488   pNew->interp = pDb->interp;
  489   pNew->pDb = pDb;
  490   pNew->pScript = 0;
  491   pNew->pNext = pDb->pFunc;
  492   pDb->pFunc = pNew;
  493   return pNew;
  494 }
  495 
  496 /*
  497 ** Free a single SqlPreparedStmt object.
  498 */
  499 static void dbFreeStmt(SqlPreparedStmt *pStmt){
  500 #ifdef SQLITE_TEST
  501   if( sqlite3_sql(pStmt->pStmt)==0 ){
  502     Tcl_Free((char *)pStmt->zSql);
  503   }
  504 #endif
  505   sqlite3_finalize(pStmt->pStmt);
  506   Tcl_Free((char *)pStmt);
  507 }
  508 
  509 /*
  510 ** Finalize and free a list of prepared statements
  511 */
  512 static void flushStmtCache(SqliteDb *pDb){
  513   SqlPreparedStmt *pPreStmt;
  514   SqlPreparedStmt *pNext;
  515 
  516   for(pPreStmt = pDb->stmtList; pPreStmt; pPreStmt=pNext){
  517     pNext = pPreStmt->pNext;
  518     dbFreeStmt(pPreStmt);
  519   }
  520   pDb->nStmt = 0;
  521   pDb->stmtLast = 0;
  522   pDb->stmtList = 0;
  523 }
  524 
  525 /*
  526 ** TCL calls this procedure when an sqlite3 database command is
  527 ** deleted.
  528 */
  529 static void SQLITE_TCLAPI DbDeleteCmd(void *db){
  530   SqliteDb *pDb = (SqliteDb*)db;
  531   flushStmtCache(pDb);
  532   closeIncrblobChannels(pDb);
  533   sqlite3_close(pDb->db);
  534   while( pDb->pFunc ){
  535     SqlFunc *pFunc = pDb->pFunc;
  536     pDb->pFunc = pFunc->pNext;
  537     assert( pFunc->pDb==pDb );
  538     Tcl_DecrRefCount(pFunc->pScript);
  539     Tcl_Free((char*)pFunc);
  540   }
  541   while( pDb->pCollate ){
  542     SqlCollate *pCollate = pDb->pCollate;
  543     pDb->pCollate = pCollate->pNext;
  544     Tcl_Free((char*)pCollate);
  545   }
  546   if( pDb->zBusy ){
  547     Tcl_Free(pDb->zBusy);
  548   }
  549   if( pDb->zTrace ){
  550     Tcl_Free(pDb->zTrace);
  551   }
  552   if( pDb->zTraceV2 ){
  553     Tcl_Free(pDb->zTraceV2);
  554   }
  555   if( pDb->zProfile ){
  556     Tcl_Free(pDb->zProfile);
  557   }
  558   if( pDb->zBindFallback ){
  559     Tcl_Free(pDb->zBindFallback);
  560   }
  561   if( pDb->zAuth ){
  562     Tcl_Free(pDb->zAuth);
  563   }
  564   if( pDb->zNull ){
  565     Tcl_Free(pDb->zNull);
  566   }
  567   if( pDb->pUpdateHook ){
  568     Tcl_DecrRefCount(pDb->pUpdateHook);
  569   }
  570   if( pDb->pPreUpdateHook ){
  571     Tcl_DecrRefCount(pDb->pPreUpdateHook);
  572   }
  573   if( pDb->pRollbackHook ){
  574     Tcl_DecrRefCount(pDb->pRollbackHook);
  575   }
  576   if( pDb->pWalHook ){
  577     Tcl_DecrRefCount(pDb->pWalHook);
  578   }
  579   if( pDb->pCollateNeeded ){
  580     Tcl_DecrRefCount(pDb->pCollateNeeded);
  581   }
  582   Tcl_Free((char*)pDb);
  583 }
  584 
  585 /*
  586 ** This routine is called when a database file is locked while trying
  587 ** to execute SQL.
  588 */
  589 static int DbBusyHandler(void *cd, int nTries){
  590   SqliteDb *pDb = (SqliteDb*)cd;
  591   int rc;
  592   char zVal[30];
  593 
  594   sqlite3_snprintf(sizeof(zVal), zVal, "%d", nTries);
  595   rc = Tcl_VarEval(pDb->interp, pDb->zBusy, " ", zVal, (char*)0);
  596   if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
  597     return 0;
  598   }
  599   return 1;
  600 }
  601 
  602 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  603 /*
  604 ** This routine is invoked as the 'progress callback' for the database.
  605 */
  606 static int DbProgressHandler(void *cd){
  607   SqliteDb *pDb = (SqliteDb*)cd;
  608   int rc;
  609 
  610   assert( pDb->zProgress );
  611   rc = Tcl_Eval(pDb->interp, pDb->zProgress);
  612   if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
  613     return 1;
  614   }
  615   return 0;
  616 }
  617 #endif
  618 
  619 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
  620     !defined(SQLITE_OMIT_DEPRECATED)
  621 /*
  622 ** This routine is called by the SQLite trace handler whenever a new
  623 ** block of SQL is executed.  The TCL script in pDb->zTrace is executed.
  624 */
  625 static void DbTraceHandler(void *cd, const char *zSql){
  626   SqliteDb *pDb = (SqliteDb*)cd;
  627   Tcl_DString str;
  628 
  629   Tcl_DStringInit(&str);
  630   Tcl_DStringAppend(&str, pDb->zTrace, -1);
  631   Tcl_DStringAppendElement(&str, zSql);
  632   Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));
  633   Tcl_DStringFree(&str);
  634   Tcl_ResetResult(pDb->interp);
  635 }
  636 #endif
  637 
  638 #ifndef SQLITE_OMIT_TRACE
  639 /*
  640 ** This routine is called by the SQLite trace_v2 handler whenever a new
  641 ** supported event is generated.  Unsupported event types are ignored.
  642 ** The TCL script in pDb->zTraceV2 is executed, with the arguments for
  643 ** the event appended to it (as list elements).
  644 */
  645 static int DbTraceV2Handler(
  646   unsigned type, /* One of the SQLITE_TRACE_* event types. */
  647   void *cd,      /* The original context data pointer. */
  648   void *pd,      /* Primary event data, depends on event type. */
  649   void *xd       /* Extra event data, depends on event type. */
  650 ){
  651   SqliteDb *pDb = (SqliteDb*)cd;
  652   Tcl_Obj *pCmd;
  653 
  654   switch( type ){
  655     case SQLITE_TRACE_STMT: {
  656       sqlite3_stmt *pStmt = (sqlite3_stmt *)pd;
  657       char *zSql = (char *)xd;
  658 
  659       pCmd = Tcl_NewStringObj(pDb->zTraceV2, -1);
  660       Tcl_IncrRefCount(pCmd);
  661       Tcl_ListObjAppendElement(pDb->interp, pCmd,
  662                                Tcl_NewWideIntObj((Tcl_WideInt)pStmt));
  663       Tcl_ListObjAppendElement(pDb->interp, pCmd,
  664                                Tcl_NewStringObj(zSql, -1));
  665       Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  666       Tcl_DecrRefCount(pCmd);
  667       Tcl_ResetResult(pDb->interp);
  668       break;
  669     }
  670     case SQLITE_TRACE_PROFILE: {
  671       sqlite3_stmt *pStmt = (sqlite3_stmt *)pd;
  672       sqlite3_int64 ns = *(sqlite3_int64*)xd;
  673 
  674       pCmd = Tcl_NewStringObj(pDb->zTraceV2, -1);
  675       Tcl_IncrRefCount(pCmd);
  676       Tcl_ListObjAppendElement(pDb->interp, pCmd,
  677                                Tcl_NewWideIntObj((Tcl_WideInt)pStmt));
  678       Tcl_ListObjAppendElement(pDb->interp, pCmd,
  679                                Tcl_NewWideIntObj((Tcl_WideInt)ns));
  680       Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  681       Tcl_DecrRefCount(pCmd);
  682       Tcl_ResetResult(pDb->interp);
  683       break;
  684     }
  685     case SQLITE_TRACE_ROW: {
  686       sqlite3_stmt *pStmt = (sqlite3_stmt *)pd;
  687 
  688       pCmd = Tcl_NewStringObj(pDb->zTraceV2, -1);
  689       Tcl_IncrRefCount(pCmd);
  690       Tcl_ListObjAppendElement(pDb->interp, pCmd,
  691                                Tcl_NewWideIntObj((Tcl_WideInt)pStmt));
  692       Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  693       Tcl_DecrRefCount(pCmd);
  694       Tcl_ResetResult(pDb->interp);
  695       break;
  696     }
  697     case SQLITE_TRACE_CLOSE: {
  698       sqlite3 *db = (sqlite3 *)pd;
  699 
  700       pCmd = Tcl_NewStringObj(pDb->zTraceV2, -1);
  701       Tcl_IncrRefCount(pCmd);
  702       Tcl_ListObjAppendElement(pDb->interp, pCmd,
  703                                Tcl_NewWideIntObj((Tcl_WideInt)db));
  704       Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  705       Tcl_DecrRefCount(pCmd);
  706       Tcl_ResetResult(pDb->interp);
  707       break;
  708     }
  709   }
  710   return SQLITE_OK;
  711 }
  712 #endif
  713 
  714 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
  715     !defined(SQLITE_OMIT_DEPRECATED)
  716 /*
  717 ** This routine is called by the SQLite profile handler after a statement
  718 ** SQL has executed.  The TCL script in pDb->zProfile is evaluated.
  719 */
  720 static void DbProfileHandler(void *cd, const char *zSql, sqlite_uint64 tm){
  721   SqliteDb *pDb = (SqliteDb*)cd;
  722   Tcl_DString str;
  723   char zTm[100];
  724 
  725   sqlite3_snprintf(sizeof(zTm)-1, zTm, "%lld", tm);
  726   Tcl_DStringInit(&str);
  727   Tcl_DStringAppend(&str, pDb->zProfile, -1);
  728   Tcl_DStringAppendElement(&str, zSql);
  729   Tcl_DStringAppendElement(&str, zTm);
  730   Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));
  731   Tcl_DStringFree(&str);
  732   Tcl_ResetResult(pDb->interp);
  733 }
  734 #endif
  735 
  736 /*
  737 ** This routine is called when a transaction is committed.  The
  738 ** TCL script in pDb->zCommit is executed.  If it returns non-zero or
  739 ** if it throws an exception, the transaction is rolled back instead
  740 ** of being committed.
  741 */
  742 static int DbCommitHandler(void *cd){
  743   SqliteDb *pDb = (SqliteDb*)cd;
  744   int rc;
  745 
  746   rc = Tcl_Eval(pDb->interp, pDb->zCommit);
  747   if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
  748     return 1;
  749   }
  750   return 0;
  751 }
  752 
  753 static void DbRollbackHandler(void *clientData){
  754   SqliteDb *pDb = (SqliteDb*)clientData;
  755   assert(pDb->pRollbackHook);
  756   if( TCL_OK!=Tcl_EvalObjEx(pDb->interp, pDb->pRollbackHook, 0) ){
  757     Tcl_BackgroundError(pDb->interp);
  758   }
  759 }
  760 
  761 /*
  762 ** This procedure handles wal_hook callbacks.
  763 */
  764 static int DbWalHandler(
  765   void *clientData,
  766   sqlite3 *db,
  767   const char *zDb,
  768   int nEntry
  769 ){
  770   int ret = SQLITE_OK;
  771   Tcl_Obj *p;
  772   SqliteDb *pDb = (SqliteDb*)clientData;
  773   Tcl_Interp *interp = pDb->interp;
  774   assert(pDb->pWalHook);
  775 
  776   assert( db==pDb->db );
  777   p = Tcl_DuplicateObj(pDb->pWalHook);
  778   Tcl_IncrRefCount(p);
  779   Tcl_ListObjAppendElement(interp, p, Tcl_NewStringObj(zDb, -1));
  780   Tcl_ListObjAppendElement(interp, p, Tcl_NewIntObj(nEntry));
  781   if( TCL_OK!=Tcl_EvalObjEx(interp, p, 0)
  782    || TCL_OK!=Tcl_GetIntFromObj(interp, Tcl_GetObjResult(interp), &ret)
  783   ){
  784     Tcl_BackgroundError(interp);
  785   }
  786   Tcl_DecrRefCount(p);
  787 
  788   return ret;
  789 }
  790 
  791 #if defined(SQLITE_TEST) && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
  792 static void setTestUnlockNotifyVars(Tcl_Interp *interp, int iArg, int nArg){
  793   char zBuf[64];
  794   sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", iArg);
  795   Tcl_SetVar(interp, "sqlite_unlock_notify_arg", zBuf, TCL_GLOBAL_ONLY);
  796   sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nArg);
  797   Tcl_SetVar(interp, "sqlite_unlock_notify_argcount", zBuf, TCL_GLOBAL_ONLY);
  798 }
  799 #else
  800 # define setTestUnlockNotifyVars(x,y,z)
  801 #endif
  802 
  803 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
  804 static void DbUnlockNotify(void **apArg, int nArg){
  805   int i;
  806   for(i=0; i<nArg; i++){
  807     const int flags = (TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
  808     SqliteDb *pDb = (SqliteDb *)apArg[i];
  809     setTestUnlockNotifyVars(pDb->interp, i, nArg);
  810     assert( pDb->pUnlockNotify);
  811     Tcl_EvalObjEx(pDb->interp, pDb->pUnlockNotify, flags);
  812     Tcl_DecrRefCount(pDb->pUnlockNotify);
  813     pDb->pUnlockNotify = 0;
  814   }
  815 }
  816 #endif
  817 
  818 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
  819 /*
  820 ** Pre-update hook callback.
  821 */
  822 static void DbPreUpdateHandler(
  823   void *p,
  824   sqlite3 *db,
  825   int op,
  826   const char *zDb,
  827   const char *zTbl,
  828   sqlite_int64 iKey1,
  829   sqlite_int64 iKey2
  830 ){
  831   SqliteDb *pDb = (SqliteDb *)p;
  832   Tcl_Obj *pCmd;
  833   static const char *azStr[] = {"DELETE", "INSERT", "UPDATE"};
  834 
  835   assert( (SQLITE_DELETE-1)/9 == 0 );
  836   assert( (SQLITE_INSERT-1)/9 == 1 );
  837   assert( (SQLITE_UPDATE-1)/9 == 2 );
  838   assert( pDb->pPreUpdateHook );
  839   assert( db==pDb->db );
  840   assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
  841 
  842   pCmd = Tcl_DuplicateObj(pDb->pPreUpdateHook);
  843   Tcl_IncrRefCount(pCmd);
  844   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(azStr[(op-1)/9], -1));
  845   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));
  846   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));
  847   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(iKey1));
  848   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(iKey2));
  849   Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  850   Tcl_DecrRefCount(pCmd);
  851 }
  852 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
  853 
  854 static void DbUpdateHandler(
  855   void *p,
  856   int op,
  857   const char *zDb,
  858   const char *zTbl,
  859   sqlite_int64 rowid
  860 ){
  861   SqliteDb *pDb = (SqliteDb *)p;
  862   Tcl_Obj *pCmd;
  863   static const char *azStr[] = {"DELETE", "INSERT", "UPDATE"};
  864 
  865   assert( (SQLITE_DELETE-1)/9 == 0 );
  866   assert( (SQLITE_INSERT-1)/9 == 1 );
  867   assert( (SQLITE_UPDATE-1)/9 == 2 );
  868 
  869   assert( pDb->pUpdateHook );
  870   assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
  871 
  872   pCmd = Tcl_DuplicateObj(pDb->pUpdateHook);
  873   Tcl_IncrRefCount(pCmd);
  874   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(azStr[(op-1)/9], -1));
  875   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));
  876   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));
  877   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(rowid));
  878   Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
  879   Tcl_DecrRefCount(pCmd);
  880 }
  881 
  882 static void tclCollateNeeded(
  883   void *pCtx,
  884   sqlite3 *db,
  885   int enc,
  886   const char *zName
  887 ){
  888   SqliteDb *pDb = (SqliteDb *)pCtx;
  889   Tcl_Obj *pScript = Tcl_DuplicateObj(pDb->pCollateNeeded);
  890   Tcl_IncrRefCount(pScript);
  891   Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(zName, -1));
  892   Tcl_EvalObjEx(pDb->interp, pScript, 0);
  893   Tcl_DecrRefCount(pScript);
  894 }
  895 
  896 /*
  897 ** This routine is called to evaluate an SQL collation function implemented
  898 ** using TCL script.
  899 */
  900 static int tclSqlCollate(
  901   void *pCtx,
  902   int nA,
  903   const void *zA,
  904   int nB,
  905   const void *zB
  906 ){
  907   SqlCollate *p = (SqlCollate *)pCtx;
  908   Tcl_Obj *pCmd;
  909 
  910   pCmd = Tcl_NewStringObj(p->zScript, -1);
  911   Tcl_IncrRefCount(pCmd);
  912   Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zA, nA));
  913   Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zB, nB));
  914   Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
  915   Tcl_DecrRefCount(pCmd);
  916   return (atoi(Tcl_GetStringResult(p->interp)));
  917 }
  918 
  919 /*
  920 ** This routine is called to evaluate an SQL function implemented
  921 ** using TCL script.
  922 */
  923 static void tclSqlFunc(sqlite3_context *context, int argc, sqlite3_value**argv){
  924   SqlFunc *p = sqlite3_user_data(context);
  925   Tcl_Obj *pCmd;
  926   int i;
  927   int rc;
  928 
  929   if( argc==0 ){
  930     /* If there are no arguments to the function, call Tcl_EvalObjEx on the
  931     ** script object directly.  This allows the TCL compiler to generate
  932     ** bytecode for the command on the first invocation and thus make
  933     ** subsequent invocations much faster. */
  934     pCmd = p->pScript;
  935     Tcl_IncrRefCount(pCmd);
  936     rc = Tcl_EvalObjEx(p->interp, pCmd, 0);
  937     Tcl_DecrRefCount(pCmd);
  938   }else{
  939     /* If there are arguments to the function, make a shallow copy of the
  940     ** script object, lappend the arguments, then evaluate the copy.
  941     **
  942     ** By "shallow" copy, we mean only the outer list Tcl_Obj is duplicated.
  943     ** The new Tcl_Obj contains pointers to the original list elements.
  944     ** That way, when Tcl_EvalObjv() is run and shimmers the first element
  945     ** of the list to tclCmdNameType, that alternate representation will
  946     ** be preserved and reused on the next invocation.
  947     */
  948     Tcl_Obj **aArg;
  949     int nArg;
  950     if( Tcl_ListObjGetElements(p->interp, p->pScript, &nArg, &aArg) ){
  951       sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
  952       return;
  953     }
  954     pCmd = Tcl_NewListObj(nArg, aArg);
  955     Tcl_IncrRefCount(pCmd);
  956     for(i=0; i<argc; i++){
  957       sqlite3_value *pIn = argv[i];
  958       Tcl_Obj *pVal;
  959 
  960       /* Set pVal to contain the i'th column of this row. */
  961       switch( sqlite3_value_type(pIn) ){
  962         case SQLITE_BLOB: {
  963           int bytes = sqlite3_value_bytes(pIn);
  964           pVal = Tcl_NewByteArrayObj(sqlite3_value_blob(pIn), bytes);
  965           break;
  966         }
  967         case SQLITE_INTEGER: {
  968           sqlite_int64 v = sqlite3_value_int64(pIn);
  969           if( v>=-2147483647 && v<=2147483647 ){
  970             pVal = Tcl_NewIntObj((int)v);
  971           }else{
  972             pVal = Tcl_NewWideIntObj(v);
  973           }
  974           break;
  975         }
  976         case SQLITE_FLOAT: {
  977           double r = sqlite3_value_double(pIn);
  978           pVal = Tcl_NewDoubleObj(r);
  979           break;
  980         }
  981         case SQLITE_NULL: {
  982           pVal = Tcl_NewStringObj(p->pDb->zNull, -1);
  983           break;
  984         }
  985         default: {
  986           int bytes = sqlite3_value_bytes(pIn);
  987           pVal = Tcl_NewStringObj((char *)sqlite3_value_text(pIn), bytes);
  988           break;
  989         }
  990       }
  991       rc = Tcl_ListObjAppendElement(p->interp, pCmd, pVal);
  992       if( rc ){
  993         Tcl_DecrRefCount(pCmd);
  994         sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
  995         return;
  996       }
  997     }
  998     if( !p->useEvalObjv ){
  999       /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd
 1000       ** is a list without a string representation.  To prevent this from
 1001       ** happening, make sure pCmd has a valid string representation */
 1002       Tcl_GetString(pCmd);
 1003     }
 1004     rc = Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
 1005     Tcl_DecrRefCount(pCmd);
 1006   }
 1007 
 1008   if( rc && rc!=TCL_RETURN ){
 1009     sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
 1010   }else{
 1011     Tcl_Obj *pVar = Tcl_GetObjResult(p->interp);
 1012     int n;
 1013     u8 *data;
 1014     const char *zType = (pVar->typePtr ? pVar->typePtr->name : "");
 1015     char c = zType[0];
 1016     int eType = p->eType;
 1017 
 1018     if( eType==SQLITE_NULL ){
 1019       if( c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0 ){
 1020         /* Only return a BLOB type if the Tcl variable is a bytearray and
 1021         ** has no string representation. */
 1022         eType = SQLITE_BLOB;
 1023       }else if( (c=='b' && strcmp(zType,"boolean")==0)
 1024              || (c=='w' && strcmp(zType,"wideInt")==0)
 1025              || (c=='i' && strcmp(zType,"int")==0) 
 1026       ){
 1027         eType = SQLITE_INTEGER;
 1028       }else if( c=='d' && strcmp(zType,"double")==0 ){
 1029         eType = SQLITE_FLOAT;
 1030       }else{
 1031         eType = SQLITE_TEXT;
 1032       }
 1033     }
 1034 
 1035     switch( eType ){
 1036       case SQLITE_BLOB: {
 1037         data = Tcl_GetByteArrayFromObj(pVar, &n);
 1038         sqlite3_result_blob(context, data, n, SQLITE_TRANSIENT);
 1039         break;
 1040       }
 1041       case SQLITE_INTEGER: {
 1042         Tcl_WideInt v;
 1043         if( TCL_OK==Tcl_GetWideIntFromObj(0, pVar, &v) ){
 1044           sqlite3_result_int64(context, v);
 1045           break;
 1046         }
 1047         /* fall-through */
 1048       }
 1049       case SQLITE_FLOAT: {
 1050         double r;
 1051         if( TCL_OK==Tcl_GetDoubleFromObj(0, pVar, &r) ){
 1052           sqlite3_result_double(context, r);
 1053           break;
 1054         }
 1055         /* fall-through */
 1056       }
 1057       default: {
 1058         data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);
 1059         sqlite3_result_text(context, (char *)data, n, SQLITE_TRANSIENT);
 1060         break;
 1061       }
 1062     }
 1063 
 1064   }
 1065 }
 1066 
 1067 #ifndef SQLITE_OMIT_AUTHORIZATION
 1068 /*
 1069 ** This is the authentication function.  It appends the authentication
 1070 ** type code and the two arguments to zCmd[] then invokes the result
 1071 ** on the interpreter.  The reply is examined to determine if the
 1072 ** authentication fails or succeeds.
 1073 */
 1074 static int auth_callback(
 1075   void *pArg,
 1076   int code,
 1077   const char *zArg1,
 1078   const char *zArg2,
 1079   const char *zArg3,
 1080   const char *zArg4
 1081 #ifdef SQLITE_USER_AUTHENTICATION
 1082   ,const char *zArg5
 1083 #endif
 1084 ){
 1085   const char *zCode;
 1086   Tcl_DString str;
 1087   int rc;
 1088   const char *zReply;
 1089   /* EVIDENCE-OF: R-38590-62769 The first parameter to the authorizer
 1090   ** callback is a copy of the third parameter to the
 1091   ** sqlite3_set_authorizer() interface.
 1092   */
 1093   SqliteDb *pDb = (SqliteDb*)pArg;
 1094   if( pDb->disableAuth ) return SQLITE_OK;
 1095 
 1096   /* EVIDENCE-OF: R-56518-44310 The second parameter to the callback is an
 1097   ** integer action code that specifies the particular action to be
 1098   ** authorized. */
 1099   switch( code ){
 1100     case SQLITE_COPY              : zCode="SQLITE_COPY"; break;
 1101     case SQLITE_CREATE_INDEX      : zCode="SQLITE_CREATE_INDEX"; break;
 1102     case SQLITE_CREATE_TABLE      : zCode="SQLITE_CREATE_TABLE"; break;
 1103     case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break;
 1104     case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break;
 1105     case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break;
 1106     case SQLITE_CREATE_TEMP_VIEW  : zCode="SQLITE_CREATE_TEMP_VIEW"; break;
 1107     case SQLITE_CREATE_TRIGGER    : zCode="SQLITE_CREATE_TRIGGER"; break;
 1108     case SQLITE_CREATE_VIEW       : zCode="SQLITE_CREATE_VIEW"; break;
 1109     case SQLITE_DELETE            : zCode="SQLITE_DELETE"; break;
 1110     case SQLITE_DROP_INDEX        : zCode="SQLITE_DROP_INDEX"; break;
 1111     case SQLITE_DROP_TABLE        : zCode="SQLITE_DROP_TABLE"; break;
 1112     case SQLITE_DROP_TEMP_INDEX   : zCode="SQLITE_DROP_TEMP_INDEX"; break;
 1113     case SQLITE_DROP_TEMP_TABLE   : zCode="SQLITE_DROP_TEMP_TABLE"; break;
 1114     case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break;
 1115     case SQLITE_DROP_TEMP_VIEW    : zCode="SQLITE_DROP_TEMP_VIEW"; break;
 1116     case SQLITE_DROP_TRIGGER      : zCode="SQLITE_DROP_TRIGGER"; break;
 1117     case SQLITE_DROP_VIEW         : zCode="SQLITE_DROP_VIEW"; break;
 1118     case SQLITE_INSERT            : zCode="SQLITE_INSERT"; break;
 1119     case SQLITE_PRAGMA            : zCode="SQLITE_PRAGMA"; break;
 1120     case SQLITE_READ              : zCode="SQLITE_READ"; break;
 1121     case SQLITE_SELECT            : zCode="SQLITE_SELECT"; break;
 1122     case SQLITE_TRANSACTION       : zCode="SQLITE_TRANSACTION"; break;
 1123     case SQLITE_UPDATE            : zCode="SQLITE_UPDATE"; break;
 1124     case SQLITE_ATTACH            : zCode="SQLITE_ATTACH"; break;
 1125     case SQLITE_DETACH            : zCode="SQLITE_DETACH"; break;
 1126     case SQLITE_ALTER_TABLE       : zCode="SQLITE_ALTER_TABLE"; break;
 1127     case SQLITE_REINDEX           : zCode="SQLITE_REINDEX"; break;
 1128     case SQLITE_ANALYZE           : zCode="SQLITE_ANALYZE"; break;
 1129     case SQLITE_CREATE_VTABLE     : zCode="SQLITE_CREATE_VTABLE"; break;
 1130     case SQLITE_DROP_VTABLE       : zCode="SQLITE_DROP_VTABLE"; break;
 1131     case SQLITE_FUNCTION          : zCode="SQLITE_FUNCTION"; break;
 1132     case SQLITE_SAVEPOINT         : zCode="SQLITE_SAVEPOINT"; break;
 1133     case SQLITE_RECURSIVE         : zCode="SQLITE_RECURSIVE"; break;
 1134     default                       : zCode="????"; break;
 1135   }
 1136   Tcl_DStringInit(&str);
 1137   Tcl_DStringAppend(&str, pDb->zAuth, -1);
 1138   Tcl_DStringAppendElement(&str, zCode);
 1139   Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");
 1140   Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");
 1141   Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");
 1142   Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");
 1143 #ifdef SQLITE_USER_AUTHENTICATION
 1144   Tcl_DStringAppendElement(&str, zArg5 ? zArg5 : "");
 1145 #endif
 1146   rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str));
 1147   Tcl_DStringFree(&str);
 1148   zReply = rc==TCL_OK ? Tcl_GetStringResult(pDb->interp) : "SQLITE_DENY";
 1149   if( strcmp(zReply,"SQLITE_OK")==0 ){
 1150     rc = SQLITE_OK;
 1151   }else if( strcmp(zReply,"SQLITE_DENY")==0 ){
 1152     rc = SQLITE_DENY;
 1153   }else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){
 1154     rc = SQLITE_IGNORE;
 1155   }else{
 1156     rc = 999;
 1157   }
 1158   return rc;
 1159 }
 1160 #endif /* SQLITE_OMIT_AUTHORIZATION */
 1161 
 1162 /*
 1163 ** This routine reads a line of text from FILE in, stores
 1164 ** the text in memory obtained from malloc() and returns a pointer
 1165 ** to the text.  NULL is returned at end of file, or if malloc()
 1166 ** fails.
 1167 **
 1168 ** The interface is like "readline" but no command-line editing
 1169 ** is done.
 1170 **
 1171 ** copied from shell.c from '.import' command
 1172 */
 1173 static char *local_getline(char *zPrompt, FILE *in){
 1174   char *zLine;
 1175   int nLine;
 1176   int n;
 1177 
 1178   nLine = 100;
 1179   zLine = malloc( nLine );
 1180   if( zLine==0 ) return 0;
 1181   n = 0;
 1182   while( 1 ){
 1183     if( n+100>nLine ){
 1184       nLine = nLine*2 + 100;
 1185       zLine = realloc(zLine, nLine);
 1186       if( zLine==0 ) return 0;
 1187     }
 1188     if( fgets(&zLine[n], nLine - n, in)==0 ){
 1189       if( n==0 ){
 1190         free(zLine);
 1191         return 0;
 1192       }
 1193       zLine[n] = 0;
 1194       break;
 1195     }
 1196     while( zLine[n] ){ n++; }
 1197     if( n>0 && zLine[n-1]=='\n' ){
 1198       n--;
 1199       zLine[n] = 0;
 1200       break;
 1201     }
 1202   }
 1203   zLine = realloc( zLine, n+1 );
 1204   return zLine;
 1205 }
 1206 
 1207 
 1208 /*
 1209 ** This function is part of the implementation of the command:
 1210 **
 1211 **   $db transaction [-deferred|-immediate|-exclusive] SCRIPT
 1212 **
 1213 ** It is invoked after evaluating the script SCRIPT to commit or rollback
 1214 ** the transaction or savepoint opened by the [transaction] command.
 1215 */
 1216 static int SQLITE_TCLAPI DbTransPostCmd(
 1217   ClientData data[],                   /* data[0] is the Sqlite3Db* for $db */
 1218   Tcl_Interp *interp,                  /* Tcl interpreter */
 1219   int result                           /* Result of evaluating SCRIPT */
 1220 ){
 1221   static const char *const azEnd[] = {
 1222     "RELEASE _tcl_transaction",        /* rc==TCL_ERROR, nTransaction!=0 */
 1223     "COMMIT",                          /* rc!=TCL_ERROR, nTransaction==0 */
 1224     "ROLLBACK TO _tcl_transaction ; RELEASE _tcl_transaction",
 1225     "ROLLBACK"                         /* rc==TCL_ERROR, nTransaction==0 */
 1226   };
 1227   SqliteDb *pDb = (SqliteDb*)data[0];
 1228   int rc = result;
 1229   const char *zEnd;
 1230 
 1231   pDb->nTransaction--;
 1232   zEnd = azEnd[(rc==TCL_ERROR)*2 + (pDb->nTransaction==0)];
 1233 
 1234   pDb->disableAuth++;
 1235   if( sqlite3_exec(pDb->db, zEnd, 0, 0, 0) ){
 1236       /* This is a tricky scenario to handle. The most likely cause of an
 1237       ** error is that the exec() above was an attempt to commit the
 1238       ** top-level transaction that returned SQLITE_BUSY. Or, less likely,
 1239       ** that an IO-error has occurred. In either case, throw a Tcl exception
 1240       ** and try to rollback the transaction.
 1241       **
 1242       ** But it could also be that the user executed one or more BEGIN,
 1243       ** COMMIT, SAVEPOINT, RELEASE or ROLLBACK commands that are confusing
 1244       ** this method's logic. Not clear how this would be best handled.
 1245       */
 1246     if( rc!=TCL_ERROR ){
 1247       Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);
 1248       rc = TCL_ERROR;
 1249     }
 1250     sqlite3_exec(pDb->db, "ROLLBACK", 0, 0, 0);
 1251   }
 1252   pDb->disableAuth--;
 1253 
 1254   return rc;
 1255 }
 1256 
 1257 /*
 1258 ** Unless SQLITE_TEST is defined, this function is a simple wrapper around
 1259 ** sqlite3_prepare_v2(). If SQLITE_TEST is defined, then it uses either
 1260 ** sqlite3_prepare_v2() or legacy interface sqlite3_prepare(), depending
 1261 ** on whether or not the [db_use_legacy_prepare] command has been used to
 1262 ** configure the connection.
 1263 */
 1264 static int dbPrepare(
 1265   SqliteDb *pDb,                  /* Database object */
 1266   const char *zSql,               /* SQL to compile */
 1267   sqlite3_stmt **ppStmt,          /* OUT: Prepared statement */
 1268   const char **pzOut              /* OUT: Pointer to next SQL statement */
 1269 ){
 1270   unsigned int prepFlags = 0;
 1271 #ifdef SQLITE_TEST
 1272   if( pDb->bLegacyPrepare ){
 1273     return sqlite3_prepare(pDb->db, zSql, -1, ppStmt, pzOut);
 1274   }
 1275 #endif
 1276   /* If the statement cache is large, use the SQLITE_PREPARE_PERSISTENT
 1277   ** flags, which uses less lookaside memory.  But if the cache is small,
 1278   ** omit that flag to make full use of lookaside */
 1279   if( pDb->maxStmt>5 ) prepFlags = SQLITE_PREPARE_PERSISTENT;
 1280 
 1281   return sqlite3_prepare_v3(pDb->db, zSql, -1, prepFlags, ppStmt, pzOut);
 1282 }
 1283 
 1284 /*
 1285 ** Search the cache for a prepared-statement object that implements the
 1286 ** first SQL statement in the buffer pointed to by parameter zIn. If
 1287 ** no such prepared-statement can be found, allocate and prepare a new
 1288 ** one. In either case, bind the current values of the relevant Tcl
 1289 ** variables to any $var, :var or @var variables in the statement. Before
 1290 ** returning, set *ppPreStmt to point to the prepared-statement object.
 1291 **
 1292 ** Output parameter *pzOut is set to point to the next SQL statement in
 1293 ** buffer zIn, or to the '\0' byte at the end of zIn if there is no
 1294 ** next statement.
 1295 **
 1296 ** If successful, TCL_OK is returned. Otherwise, TCL_ERROR is returned
 1297 ** and an error message loaded into interpreter pDb->interp.
 1298 */
 1299 static int dbPrepareAndBind(
 1300   SqliteDb *pDb,                  /* Database object */
 1301   char const *zIn,                /* SQL to compile */
 1302   char const **pzOut,             /* OUT: Pointer to next SQL statement */
 1303   SqlPreparedStmt **ppPreStmt     /* OUT: Object used to cache statement */
 1304 ){
 1305   const char *zSql = zIn;         /* Pointer to first SQL statement in zIn */
 1306   sqlite3_stmt *pStmt = 0;        /* Prepared statement object */
 1307   SqlPreparedStmt *pPreStmt;      /* Pointer to cached statement */
 1308   int nSql;                       /* Length of zSql in bytes */
 1309   int nVar = 0;                   /* Number of variables in statement */
 1310   int iParm = 0;                  /* Next free entry in apParm */
 1311   char c;
 1312   int i;
 1313   int needResultReset = 0;        /* Need to invoke Tcl_ResetResult() */
 1314   int rc = SQLITE_OK;             /* Value to return */
 1315   Tcl_Interp *interp = pDb->interp;
 1316 
 1317   *ppPreStmt = 0;
 1318 
 1319   /* Trim spaces from the start of zSql and calculate the remaining length. */
 1320   while( (c = zSql[0])==' ' || c=='\t' || c=='\r' || c=='\n' ){ zSql++; }
 1321   nSql = strlen30(zSql);
 1322 
 1323   for(pPreStmt = pDb->stmtList; pPreStmt; pPreStmt=pPreStmt->pNext){
 1324     int n = pPreStmt->nSql;
 1325     if( nSql>=n
 1326         && memcmp(pPreStmt->zSql, zSql, n)==0
 1327         && (zSql[n]==0 || zSql[n-1]==';')
 1328     ){
 1329       pStmt = pPreStmt->pStmt;
 1330       *pzOut = &zSql[pPreStmt->nSql];
 1331 
 1332       /* When a prepared statement is found, unlink it from the
 1333       ** cache list.  It will later be added back to the beginning
 1334       ** of the cache list in order to implement LRU replacement.
 1335       */
 1336       if( pPreStmt->pPrev ){
 1337         pPreStmt->pPrev->pNext = pPreStmt->pNext;
 1338       }else{
 1339         pDb->stmtList = pPreStmt->pNext;
 1340       }
 1341       if( pPreStmt->pNext ){
 1342         pPreStmt->pNext->pPrev = pPreStmt->pPrev;
 1343       }else{
 1344         pDb->stmtLast = pPreStmt->pPrev;
 1345       }
 1346       pDb->nStmt--;
 1347       nVar = sqlite3_bind_parameter_count(pStmt);
 1348       break;
 1349     }
 1350   }
 1351 
 1352   /* If no prepared statement was found. Compile the SQL text. Also allocate
 1353   ** a new SqlPreparedStmt structure.  */
 1354   if( pPreStmt==0 ){
 1355     int nByte;
 1356 
 1357     if( SQLITE_OK!=dbPrepare(pDb, zSql, &pStmt, pzOut) ){
 1358       Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3_errmsg(pDb->db), -1));
 1359       return TCL_ERROR;
 1360     }
 1361     if( pStmt==0 ){
 1362       if( SQLITE_OK!=sqlite3_errcode(pDb->db) ){
 1363         /* A compile-time error in the statement. */
 1364         Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3_errmsg(pDb->db), -1));
 1365         return TCL_ERROR;
 1366       }else{
 1367         /* The statement was a no-op.  Continue to the next statement
 1368         ** in the SQL string.
 1369         */
 1370         return TCL_OK;
 1371       }
 1372     }
 1373 
 1374     assert( pPreStmt==0 );
 1375     nVar = sqlite3_bind_parameter_count(pStmt);
 1376     nByte = sizeof(SqlPreparedStmt) + nVar*sizeof(Tcl_Obj *);
 1377     pPreStmt = (SqlPreparedStmt*)Tcl_Alloc(nByte);
 1378     memset(pPreStmt, 0, nByte);
 1379 
 1380     pPreStmt->pStmt = pStmt;
 1381     pPreStmt->nSql = (int)(*pzOut - zSql);
 1382     pPreStmt->zSql = sqlite3_sql(pStmt);
 1383     pPreStmt->apParm = (Tcl_Obj **)&pPreStmt[1];
 1384 #ifdef SQLITE_TEST
 1385     if( pPreStmt->zSql==0 ){
 1386       char *zCopy = Tcl_Alloc(pPreStmt->nSql + 1);
 1387       memcpy(zCopy, zSql, pPreStmt->nSql);
 1388       zCopy[pPreStmt->nSql] = '\0';
 1389       pPreStmt->zSql = zCopy;
 1390     }
 1391 #endif
 1392   }
 1393   assert( pPreStmt );
 1394   assert( strlen30(pPreStmt->zSql)==pPreStmt->nSql );
 1395   assert( 0==memcmp(pPreStmt->zSql, zSql, pPreStmt->nSql) );
 1396 
 1397   /* Bind values to parameters that begin with $ or : */
 1398   for(i=1; i<=nVar; i++){
 1399     const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
 1400     if( zVar!=0 && (zVar[0]=='$' || zVar[0]==':' || zVar[0]=='@') ){
 1401       Tcl_Obj *pVar = Tcl_GetVar2Ex(interp, &zVar[1], 0, 0);
 1402       if( pVar==0 && pDb->zBindFallback!=0 ){
 1403         Tcl_Obj *pCmd;
 1404         int rx;
 1405         pCmd = Tcl_NewStringObj(pDb->zBindFallback, -1);
 1406         Tcl_IncrRefCount(pCmd);
 1407         Tcl_ListObjAppendElement(interp, pCmd, Tcl_NewStringObj(zVar,-1));
 1408         if( needResultReset ) Tcl_ResetResult(interp);
 1409         needResultReset = 1;
 1410         rx = Tcl_EvalObjEx(interp, pCmd, TCL_EVAL_DIRECT);
 1411         Tcl_DecrRefCount(pCmd);
 1412         if( rx==TCL_OK ){
 1413           pVar = Tcl_GetObjResult(interp);
 1414         }else if( rx==TCL_ERROR ){
 1415           rc = TCL_ERROR;
 1416           break;
 1417         }else{
 1418           pVar = 0;
 1419         }
 1420       }
 1421       if( pVar ){
 1422         int n;
 1423         u8 *data;
 1424         const char *zType = (pVar->typePtr ? pVar->typePtr->name : "");
 1425         c = zType[0];
 1426         if( zVar[0]=='@' ||
 1427            (c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0) ){
 1428           /* Load a BLOB type if the Tcl variable is a bytearray and
 1429           ** it has no string representation or the host
 1430           ** parameter name begins with "@". */
 1431           data = Tcl_GetByteArrayFromObj(pVar, &n);
 1432           sqlite3_bind_blob(pStmt, i, data, n, SQLITE_STATIC);
 1433           Tcl_IncrRefCount(pVar);
 1434           pPreStmt->apParm[iParm++] = pVar;
 1435         }else if( c=='b' && strcmp(zType,"boolean")==0 ){
 1436           Tcl_GetIntFromObj(interp, pVar, &n);
 1437           sqlite3_bind_int(pStmt, i, n);
 1438         }else if( c=='d' && strcmp(zType,"double")==0 ){
 1439           double r;
 1440           Tcl_GetDoubleFromObj(interp, pVar, &r);
 1441           sqlite3_bind_double(pStmt, i, r);
 1442         }else if( (c=='w' && strcmp(zType,"wideInt")==0) ||
 1443               (c=='i' && strcmp(zType,"int")==0) ){
 1444           Tcl_WideInt v;
 1445           Tcl_GetWideIntFromObj(interp, pVar, &v);
 1446           sqlite3_bind_int64(pStmt, i, v);
 1447         }else{
 1448           data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);
 1449           sqlite3_bind_text(pStmt, i, (char *)data, n, SQLITE_STATIC);
 1450           Tcl_IncrRefCount(pVar);
 1451           pPreStmt->apParm[iParm++] = pVar;
 1452         }
 1453       }else{
 1454         sqlite3_bind_null(pStmt, i);
 1455       }
 1456       if( needResultReset ) Tcl_ResetResult(pDb->interp);
 1457     }
 1458   }
 1459   pPreStmt->nParm = iParm;
 1460   *ppPreStmt = pPreStmt;
 1461   if( needResultReset && rc==TCL_OK ) Tcl_ResetResult(pDb->interp);
 1462 
 1463   return rc;
 1464 }
 1465 
 1466 /*
 1467 ** Release a statement reference obtained by calling dbPrepareAndBind().
 1468 ** There should be exactly one call to this function for each call to
 1469 ** dbPrepareAndBind().
 1470 **
 1471 ** If the discard parameter is non-zero, then the statement is deleted
 1472 ** immediately. Otherwise it is added to the LRU list and may be returned
 1473 ** by a subsequent call to dbPrepareAndBind().
 1474 */
 1475 static void dbReleaseStmt(
 1476   SqliteDb *pDb,                  /* Database handle */
 1477   SqlPreparedStmt *pPreStmt,      /* Prepared statement handle to release */
 1478   int discard                     /* True to delete (not cache) the pPreStmt */
 1479 ){
 1480   int i;
 1481 
 1482   /* Free the bound string and blob parameters */
 1483   for(i=0; i<pPreStmt->nParm; i++){
 1484     Tcl_DecrRefCount(pPreStmt->apParm[i]);
 1485   }
 1486   pPreStmt->nParm = 0;
 1487 
 1488   if( pDb->maxStmt<=0 || discard ){
 1489     /* If the cache is turned off, deallocated the statement */
 1490     dbFreeStmt(pPreStmt);
 1491   }else{
 1492     /* Add the prepared statement to the beginning of the cache list. */
 1493     pPreStmt->pNext = pDb->stmtList;
 1494     pPreStmt->pPrev = 0;
 1495     if( pDb->stmtList ){
 1496      pDb->stmtList->pPrev = pPreStmt;
 1497     }
 1498     pDb->stmtList = pPreStmt;
 1499     if( pDb->stmtLast==0 ){
 1500       assert( pDb->nStmt==0 );
 1501       pDb->stmtLast = pPreStmt;
 1502     }else{
 1503       assert( pDb->nStmt>0 );
 1504     }
 1505     pDb->nStmt++;
 1506 
 1507     /* If we have too many statement in cache, remove the surplus from
 1508     ** the end of the cache list.  */
 1509     while( pDb->nStmt>pDb->maxStmt ){
 1510       SqlPreparedStmt *pLast = pDb->stmtLast;
 1511       pDb->stmtLast = pLast->pPrev;
 1512       pDb->stmtLast->pNext = 0;
 1513       pDb->nStmt--;
 1514       dbFreeStmt(pLast);
 1515     }
 1516   }
 1517 }
 1518 
 1519 /*
 1520 ** Structure used with dbEvalXXX() functions:
 1521 **
 1522 **   dbEvalInit()
 1523 **   dbEvalStep()
 1524 **   dbEvalFinalize()
 1525 **   dbEvalRowInfo()
 1526 **   dbEvalColumnValue()
 1527 */
 1528 typedef struct DbEvalContext DbEvalContext;
 1529 struct DbEvalContext {
 1530   SqliteDb *pDb;                  /* Database handle */
 1531   Tcl_Obj *pSql;                  /* Object holding string zSql */
 1532   const char *zSql;               /* Remaining SQL to execute */
 1533   SqlPreparedStmt *pPreStmt;      /* Current statement */
 1534   int nCol;                       /* Number of columns returned by pStmt */
 1535   int evalFlags;                  /* Flags used */
 1536   Tcl_Obj *pArray;                /* Name of array variable */
 1537   Tcl_Obj **apColName;            /* Array of column names */
 1538 };
 1539 
 1540 #define SQLITE_EVAL_WITHOUTNULLS  0x00001  /* Unset array(*) for NULL */
 1541 
 1542 /*
 1543 ** Release any cache of column names currently held as part of
 1544 ** the DbEvalContext structure passed as the first argument.
 1545 */
 1546 static void dbReleaseColumnNames(DbEvalContext *p){
 1547   if( p->apColName ){
 1548     int i;
 1549     for(i=0; i<p->nCol; i++){
 1550       Tcl_DecrRefCount(p->apColName[i]);
 1551     }
 1552     Tcl_Free((char *)p->apColName);
 1553     p->apColName = 0;
 1554   }
 1555   p->nCol = 0;
 1556 }
 1557 
 1558 /*
 1559 ** Initialize a DbEvalContext structure.
 1560 **
 1561 ** If pArray is not NULL, then it contains the name of a Tcl array
 1562 ** variable. The "*" member of this array is set to a list containing
 1563 ** the names of the columns returned by the statement as part of each
 1564 ** call to dbEvalStep(), in order from left to right. e.g. if the names
 1565 ** of the returned columns are a, b and c, it does the equivalent of the
 1566 ** tcl command:
 1567 **
 1568 **     set ${pArray}(*) {a b c}
 1569 */
 1570 static void dbEvalInit(
 1571   DbEvalContext *p,               /* Pointer to structure to initialize */
 1572   SqliteDb *pDb,                  /* Database handle */
 1573   Tcl_Obj *pSql,                  /* Object containing SQL script */
 1574   Tcl_Obj *pArray,                /* Name of Tcl array to set (*) element of */
 1575   int evalFlags                   /* Flags controlling evaluation */
 1576 ){
 1577   memset(p, 0, sizeof(DbEvalContext));
 1578   p->pDb = pDb;
 1579   p->zSql = Tcl_GetString(pSql);
 1580   p->pSql = pSql;
 1581   Tcl_IncrRefCount(pSql);
 1582   if( pArray ){
 1583     p->pArray = pArray;
 1584     Tcl_IncrRefCount(pArray);
 1585   }
 1586   p->evalFlags = evalFlags;
 1587 }
 1588 
 1589 /*
 1590 ** Obtain information about the row that the DbEvalContext passed as the
 1591 ** first argument currently points to.
 1592 */
 1593 static void dbEvalRowInfo(
 1594   DbEvalContext *p,               /* Evaluation context */
 1595   int *pnCol,                     /* OUT: Number of column names */
 1596   Tcl_Obj ***papColName           /* OUT: Array of column names */
 1597 ){
 1598   /* Compute column names */
 1599   if( 0==p->apColName ){
 1600     sqlite3_stmt *pStmt = p->pPreStmt->pStmt;
 1601     int i;                        /* Iterator variable */
 1602     int nCol;                     /* Number of columns returned by pStmt */
 1603     Tcl_Obj **apColName = 0;      /* Array of column names */
 1604 
 1605     p->nCol = nCol = sqlite3_column_count(pStmt);
 1606     if( nCol>0 && (papColName || p->pArray) ){
 1607       apColName = (Tcl_Obj**)Tcl_Alloc( sizeof(Tcl_Obj*)*nCol );
 1608       for(i=0; i<nCol; i++){
 1609         apColName[i] = Tcl_NewStringObj(sqlite3_column_name(pStmt,i), -1);
 1610         Tcl_IncrRefCount(apColName[i]);
 1611       }
 1612       p->apColName = apColName;
 1613     }
 1614 
 1615     /* If results are being stored in an array variable, then create
 1616     ** the array(*) entry for that array
 1617     */
 1618     if( p->pArray ){
 1619       Tcl_Interp *interp = p->pDb->interp;
 1620       Tcl_Obj *pColList = Tcl_NewObj();
 1621       Tcl_Obj *pStar = Tcl_NewStringObj("*", -1);
 1622 
 1623       for(i=0; i<nCol; i++){
 1624         Tcl_ListObjAppendElement(interp, pColList, apColName[i]);
 1625       }
 1626       Tcl_IncrRefCount(pStar);
 1627       Tcl_ObjSetVar2(interp, p->pArray, pStar, pColList, 0);
 1628       Tcl_DecrRefCount(pStar);
 1629     }
 1630   }
 1631 
 1632   if( papColName ){
 1633     *papColName = p->apColName;
 1634   }
 1635   if( pnCol ){
 1636     *pnCol = p->nCol;
 1637   }
 1638 }
 1639 
 1640 /*
 1641 ** Return one of TCL_OK, TCL_BREAK or TCL_ERROR. If TCL_ERROR is
 1642 ** returned, then an error message is stored in the interpreter before
 1643 ** returning.
 1644 **
 1645 ** A return value of TCL_OK means there is a row of data available. The
 1646 ** data may be accessed using dbEvalRowInfo() and dbEvalColumnValue(). This
 1647 ** is analogous to a return of SQLITE_ROW from sqlite3_step(). If TCL_BREAK
 1648 ** is returned, then the SQL script has finished executing and there are
 1649 ** no further rows available. This is similar to SQLITE_DONE.
 1650 */
 1651 static int dbEvalStep(DbEvalContext *p){
 1652   const char *zPrevSql = 0;       /* Previous value of p->zSql */
 1653 
 1654   while( p->zSql[0] || p->pPreStmt ){
 1655     int rc;
 1656     if( p->pPreStmt==0 ){
 1657       zPrevSql = (p->zSql==zPrevSql ? 0 : p->zSql);
 1658       rc = dbPrepareAndBind(p->pDb, p->zSql, &p->zSql, &p->pPreStmt);
 1659       if( rc!=TCL_OK ) return rc;
 1660     }else{
 1661       int rcs;
 1662       SqliteDb *pDb = p->pDb;
 1663       SqlPreparedStmt *pPreStmt = p->pPreStmt;
 1664       sqlite3_stmt *pStmt = pPreStmt->pStmt;
 1665 
 1666       rcs = sqlite3_step(pStmt);
 1667       if( rcs==SQLITE_ROW ){
 1668         return TCL_OK;
 1669       }
 1670       if( p->pArray ){
 1671         dbEvalRowInfo(p, 0, 0);
 1672       }
 1673       rcs = sqlite3_reset(pStmt);
 1674 
 1675       pDb->nStep = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_FULLSCAN_STEP,1);
 1676       pDb->nSort = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_SORT,1);
 1677       pDb->nIndex = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_AUTOINDEX,1);
 1678       pDb->nVMStep = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_VM_STEP,1);
 1679       dbReleaseColumnNames(p);
 1680       p->pPreStmt = 0;
 1681 
 1682       if( rcs!=SQLITE_OK ){
 1683         /* If a run-time error occurs, report the error and stop reading
 1684         ** the SQL.  */
 1685         dbReleaseStmt(pDb, pPreStmt, 1);
 1686 #if SQLITE_TEST
 1687         if( p->pDb->bLegacyPrepare && rcs==SQLITE_SCHEMA && zPrevSql ){
 1688           /* If the runtime error was an SQLITE_SCHEMA, and the database
 1689           ** handle is configured to use the legacy sqlite3_prepare()
 1690           ** interface, retry prepare()/step() on the same SQL statement.
 1691           ** This only happens once. If there is a second SQLITE_SCHEMA
 1692           ** error, the error will be returned to the caller. */
 1693           p->zSql = zPrevSql;
 1694           continue;
 1695         }
 1696 #endif
 1697         Tcl_SetObjResult(pDb->interp,
 1698                          Tcl_NewStringObj(sqlite3_errmsg(pDb->db), -1));
 1699         return TCL_ERROR;
 1700       }else{
 1701         dbReleaseStmt(pDb, pPreStmt, 0);
 1702       }
 1703     }
 1704   }
 1705 
 1706   /* Finished */
 1707   return TCL_BREAK;
 1708 }
 1709 
 1710 /*
 1711 ** Free all resources currently held by the DbEvalContext structure passed
 1712 ** as the first argument. There should be exactly one call to this function
 1713 ** for each call to dbEvalInit().
 1714 */
 1715 static void dbEvalFinalize(DbEvalContext *p){
 1716   if( p->pPreStmt ){
 1717     sqlite3_reset(p->pPreStmt->pStmt);
 1718     dbReleaseStmt(p->pDb, p->pPreStmt, 0);
 1719     p->pPreStmt = 0;
 1720   }
 1721   if( p->pArray ){
 1722     Tcl_DecrRefCount(p->pArray);
 1723     p->pArray = 0;
 1724   }
 1725   Tcl_DecrRefCount(p->pSql);
 1726   dbReleaseColumnNames(p);
 1727 }
 1728 
 1729 /*
 1730 ** Return a pointer to a Tcl_Obj structure with ref-count 0 that contains
 1731 ** the value for the iCol'th column of the row currently pointed to by
 1732 ** the DbEvalContext structure passed as the first argument.
 1733 */
 1734 static Tcl_Obj *dbEvalColumnValue(DbEvalContext *p, int iCol){
 1735   sqlite3_stmt *pStmt = p->pPreStmt->pStmt;
 1736   switch( sqlite3_column_type(pStmt, iCol) ){
 1737     case SQLITE_BLOB: {
 1738       int bytes = sqlite3_column_bytes(pStmt, iCol);
 1739       const char *zBlob = sqlite3_column_blob(pStmt, iCol);
 1740       if( !zBlob ) bytes = 0;
 1741       return Tcl_NewByteArrayObj((u8*)zBlob, bytes);
 1742     }
 1743     case SQLITE_INTEGER: {
 1744       sqlite_int64 v = sqlite3_column_int64(pStmt, iCol);
 1745       if( v>=-2147483647 && v<=2147483647 ){
 1746         return Tcl_NewIntObj((int)v);
 1747       }else{
 1748         return Tcl_NewWideIntObj(v);
 1749       }
 1750     }
 1751     case SQLITE_FLOAT: {
 1752       return Tcl_NewDoubleObj(sqlite3_column_double(pStmt, iCol));
 1753     }
 1754     case SQLITE_NULL: {
 1755       return Tcl_NewStringObj(p->pDb->zNull, -1);
 1756     }
 1757   }
 1758 
 1759   return Tcl_NewStringObj((char*)sqlite3_column_text(pStmt, iCol), -1);
 1760 }
 1761 
 1762 /*
 1763 ** If using Tcl version 8.6 or greater, use the NR functions to avoid
 1764 ** recursive evalution of scripts by the [db eval] and [db trans]
 1765 ** commands. Even if the headers used while compiling the extension
 1766 ** are 8.6 or newer, the code still tests the Tcl version at runtime.
 1767 ** This allows stubs-enabled builds to be used with older Tcl libraries.
 1768 */
 1769 #if TCL_MAJOR_VERSION>8 || (TCL_MAJOR_VERSION==8 && TCL_MINOR_VERSION>=6)
 1770 # define SQLITE_TCL_NRE 1
 1771 static int DbUseNre(void){
 1772   int major, minor;
 1773   Tcl_GetVersion(&major, &minor, 0, 0);
 1774   return( (major==8 && minor>=6) || major>8 );
 1775 }
 1776 #else
 1777 /*
 1778 ** Compiling using headers earlier than 8.6. In this case NR cannot be
 1779 ** used, so DbUseNre() to always return zero. Add #defines for the other
 1780 ** Tcl_NRxxx() functions to prevent them from causing compilation errors,
 1781 ** even though the only invocations of them are within conditional blocks
 1782 ** of the form:
 1783 **
 1784 **   if( DbUseNre() ) { ... }
 1785 */
 1786 # define SQLITE_TCL_NRE 0
 1787 # define DbUseNre() 0
 1788 # define Tcl_NRAddCallback(a,b,c,d,e,f) (void)0
 1789 # define Tcl_NREvalObj(a,b,c) 0
 1790 # define Tcl_NRCreateCommand(a,b,c,d,e,f) (void)0
 1791 #endif
 1792 
 1793 /*
 1794 ** This function is part of the implementation of the command:
 1795 **
 1796 **   $db eval SQL ?ARRAYNAME? SCRIPT
 1797 */
 1798 static int SQLITE_TCLAPI DbEvalNextCmd(
 1799   ClientData data[],                   /* data[0] is the (DbEvalContext*) */
 1800   Tcl_Interp *interp,                  /* Tcl interpreter */
 1801   int result                           /* Result so far */
 1802 ){
 1803   int rc = result;                     /* Return code */
 1804 
 1805   /* The first element of the data[] array is a pointer to a DbEvalContext
 1806   ** structure allocated using Tcl_Alloc(). The second element of data[]
 1807   ** is a pointer to a Tcl_Obj containing the script to run for each row
 1808   ** returned by the queries encapsulated in data[0]. */
 1809   DbEvalContext *p = (DbEvalContext *)data[0];
 1810   Tcl_Obj *pScript = (Tcl_Obj *)data[1];
 1811   Tcl_Obj *pArray = p->pArray;
 1812 
 1813   while( (rc==TCL_OK || rc==TCL_CONTINUE) && TCL_OK==(rc = dbEvalStep(p)) ){
 1814     int i;
 1815     int nCol;
 1816     Tcl_Obj **apColName;
 1817     dbEvalRowInfo(p, &nCol, &apColName);
 1818     for(i=0; i<nCol; i++){
 1819       if( pArray==0 ){
 1820         Tcl_ObjSetVar2(interp, apColName[i], 0, dbEvalColumnValue(p,i), 0);
 1821       }else if( (p->evalFlags & SQLITE_EVAL_WITHOUTNULLS)!=0
 1822              && sqlite3_column_type(p->pPreStmt->pStmt, i)==SQLITE_NULL 
 1823       ){
 1824         Tcl_UnsetVar2(interp, Tcl_GetString(pArray), 
 1825                       Tcl_GetString(apColName[i]), 0);
 1826       }else{
 1827         Tcl_ObjSetVar2(interp, pArray, apColName[i], dbEvalColumnValue(p,i), 0);
 1828       }
 1829     }
 1830 
 1831     /* The required interpreter variables are now populated with the data
 1832     ** from the current row. If using NRE, schedule callbacks to evaluate
 1833     ** script pScript, then to invoke this function again to fetch the next
 1834     ** row (or clean up if there is no next row or the script throws an
 1835     ** exception). After scheduling the callbacks, return control to the
 1836     ** caller.
 1837     **
 1838     ** If not using NRE, evaluate pScript directly and continue with the
 1839     ** next iteration of this while(...) loop.  */
 1840     if( DbUseNre() ){
 1841       Tcl_NRAddCallback(interp, DbEvalNextCmd, (void*)p, (void*)pScript, 0, 0);
 1842       return Tcl_NREvalObj(interp, pScript, 0);
 1843     }else{
 1844       rc = Tcl_EvalObjEx(interp, pScript, 0);
 1845     }
 1846   }
 1847 
 1848   Tcl_DecrRefCount(pScript);
 1849   dbEvalFinalize(p);
 1850   Tcl_Free((char *)p);
 1851 
 1852   if( rc==TCL_OK || rc==TCL_BREAK ){
 1853     Tcl_ResetResult(interp);
 1854     rc = TCL_OK;
 1855   }
 1856   return rc;
 1857 }
 1858 
 1859 /*
 1860 ** This function is used by the implementations of the following database
 1861 ** handle sub-commands:
 1862 **
 1863 **   $db update_hook ?SCRIPT?
 1864 **   $db wal_hook ?SCRIPT?
 1865 **   $db commit_hook ?SCRIPT?
 1866 **   $db preupdate hook ?SCRIPT?
 1867 */
 1868 static void DbHookCmd(
 1869   Tcl_Interp *interp,             /* Tcl interpreter */
 1870   SqliteDb *pDb,                  /* Database handle */
 1871   Tcl_Obj *pArg,                  /* SCRIPT argument (or NULL) */
 1872   Tcl_Obj **ppHook                /* Pointer to member of SqliteDb */
 1873 ){
 1874   sqlite3 *db = pDb->db;
 1875 
 1876   if( *ppHook ){
 1877     Tcl_SetObjResult(interp, *ppHook);
 1878     if( pArg ){
 1879       Tcl_DecrRefCount(*ppHook);
 1880       *ppHook = 0;
 1881     }
 1882   }
 1883   if( pArg ){
 1884     assert( !(*ppHook) );
 1885     if( Tcl_GetCharLength(pArg)>0 ){
 1886       *ppHook = pArg;
 1887       Tcl_IncrRefCount(*ppHook);
 1888     }
 1889   }
 1890 
 1891 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
 1892   sqlite3_preupdate_hook(db, (pDb->pPreUpdateHook?DbPreUpdateHandler:0), pDb);
 1893 #endif
 1894   sqlite3_update_hook(db, (pDb->pUpdateHook?DbUpdateHandler:0), pDb);
 1895   sqlite3_rollback_hook(db, (pDb->pRollbackHook?DbRollbackHandler:0), pDb);
 1896   sqlite3_wal_hook(db, (pDb->pWalHook?DbWalHandler:0), pDb);
 1897 }
 1898 
 1899 /*
 1900 ** The "sqlite" command below creates a new Tcl command for each
 1901 ** connection it opens to an SQLite database.  This routine is invoked
 1902 ** whenever one of those connection-specific commands is executed
 1903 ** in Tcl.  For example, if you run Tcl code like this:
 1904 **
 1905 **       sqlite3 db1  "my_database"
 1906 **       db1 close
 1907 **
 1908 ** The first command opens a connection to the "my_database" database
 1909 ** and calls that connection "db1".  The second command causes this
 1910 ** subroutine to be invoked.
 1911 */
 1912 static int SQLITE_TCLAPI DbObjCmd(
 1913   void *cd,
 1914   Tcl_Interp *interp,
 1915   int objc,
 1916   Tcl_Obj *const*objv
 1917 ){
 1918   SqliteDb *pDb = (SqliteDb*)cd;
 1919   int choice;
 1920   int rc = TCL_OK;
 1921   static const char *DB_strs[] = {
 1922     "authorizer",             "backup",                "bind_fallback",
 1923     "busy",                   "cache",                 "changes",
 1924     "close",                  "collate",               "collation_needed",
 1925     "commit_hook",            "complete",              "config",
 1926     "copy",                   "deserialize",           "enable_load_extension",
 1927     "errorcode",              "eval",                  "exists",
 1928     "function",               "incrblob",              "interrupt",
 1929     "last_insert_rowid",      "nullvalue",             "onecolumn",
 1930     "preupdate",              "profile",               "progress",
 1931     "rekey",                  "restore",               "rollback_hook",
 1932     "serialize",              "status",                "timeout",
 1933     "total_changes",          "trace",                 "trace_v2",
 1934     "transaction",            "unlock_notify",         "update_hook",
 1935     "version",                "wal_hook",              0
 1936   };
 1937   enum DB_enum {
 1938     DB_AUTHORIZER,            DB_BACKUP,               DB_BIND_FALLBACK,
 1939     DB_BUSY,                  DB_CACHE,                DB_CHANGES,
 1940     DB_CLOSE,                 DB_COLLATE,              DB_COLLATION_NEEDED,
 1941     DB_COMMIT_HOOK,           DB_COMPLETE,             DB_CONFIG,
 1942     DB_COPY,                  DB_DESERIALIZE,          DB_ENABLE_LOAD_EXTENSION,
 1943     DB_ERRORCODE,             DB_EVAL,                 DB_EXISTS,
 1944     DB_FUNCTION,              DB_INCRBLOB,             DB_INTERRUPT,
 1945     DB_LAST_INSERT_ROWID,     DB_NULLVALUE,            DB_ONECOLUMN,
 1946     DB_PREUPDATE,             DB_PROFILE,              DB_PROGRESS,
 1947     DB_REKEY,                 DB_RESTORE,              DB_ROLLBACK_HOOK,
 1948     DB_SERIALIZE,             DB_STATUS,               DB_TIMEOUT,
 1949     DB_TOTAL_CHANGES,         DB_TRACE,                DB_TRACE_V2,
 1950     DB_TRANSACTION,           DB_UNLOCK_NOTIFY,        DB_UPDATE_HOOK,
 1951     DB_VERSION,               DB_WAL_HOOK             
 1952   };
 1953   /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
 1954 
 1955   if( objc<2 ){
 1956     Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
 1957     return TCL_ERROR;
 1958   }
 1959   if( Tcl_GetIndexFromObj(interp, objv[1], DB_strs, "option", 0, &choice) ){
 1960     return TCL_ERROR;
 1961   }
 1962 
 1963   switch( (enum DB_enum)choice ){
 1964 
 1965   /*    $db authorizer ?CALLBACK?
 1966   **
 1967   ** Invoke the given callback to authorize each SQL operation as it is
 1968   ** compiled.  5 arguments are appended to the callback before it is
 1969   ** invoked:
 1970   **
 1971   **   (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
 1972   **   (2) First descriptive name (depends on authorization type)
 1973   **   (3) Second descriptive name
 1974   **   (4) Name of the database (ex: "main", "temp")
 1975   **   (5) Name of trigger that is doing the access
 1976   **
 1977   ** The callback should return on of the following strings: SQLITE_OK,
 1978   ** SQLITE_IGNORE, or SQLITE_DENY.  Any other return value is an error.
 1979   **
 1980   ** If this method is invoked with no arguments, the current authorization
 1981   ** callback string is returned.
 1982   */
 1983   case DB_AUTHORIZER: {
 1984 #ifdef SQLITE_OMIT_AUTHORIZATION
 1985     Tcl_AppendResult(interp, "authorization not available in this build",
 1986                      (char*)0);
 1987     return TCL_ERROR;
 1988 #else
 1989     if( objc>3 ){
 1990       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
 1991       return TCL_ERROR;
 1992     }else if( objc==2 ){
 1993       if( pDb->zAuth ){
 1994         Tcl_AppendResult(interp, pDb->zAuth, (char*)0);
 1995       }
 1996     }else{
 1997       char *zAuth;
 1998       int len;
 1999       if( pDb->zAuth ){
 2000         Tcl_Free(pDb->zAuth);
 2001       }
 2002       zAuth = Tcl_GetStringFromObj(objv[2], &len);
 2003       if( zAuth && len>0 ){
 2004         pDb->zAuth = Tcl_Alloc( len + 1 );
 2005         memcpy(pDb->zAuth, zAuth, len+1);
 2006       }else{
 2007         pDb->zAuth = 0;
 2008       }
 2009       if( pDb->zAuth ){
 2010         typedef int (*sqlite3_auth_cb)(
 2011            void*,int,const char*,const char*,
 2012            const char*,const char*);
 2013         pDb->interp = interp;
 2014         sqlite3_set_authorizer(pDb->db,(sqlite3_auth_cb)auth_callback,pDb);
 2015       }else{
 2016         sqlite3_set_authorizer(pDb->db, 0, 0);
 2017       }
 2018     }
 2019 #endif
 2020     break;
 2021   }
 2022 
 2023   /*    $db backup ?DATABASE? FILENAME
 2024   **
 2025   ** Open or create a database file named FILENAME.  Transfer the
 2026   ** content of local database DATABASE (default: "main") into the
 2027   ** FILENAME database.
 2028   */
 2029   case DB_BACKUP: {
 2030     const char *zDestFile;
 2031     const char *zSrcDb;
 2032     sqlite3 *pDest;
 2033     sqlite3_backup *pBackup;
 2034 
 2035     if( objc==3 ){
 2036       zSrcDb = "main";
 2037       zDestFile = Tcl_GetString(objv[2]);
 2038     }else if( objc==4 ){
 2039       zSrcDb = Tcl_GetString(objv[2]);
 2040       zDestFile = Tcl_GetString(objv[3]);
 2041     }else{
 2042       Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? FILENAME");
 2043       return TCL_ERROR;
 2044     }
 2045     rc = sqlite3_open_v2(zDestFile, &pDest,
 2046                SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE| pDb->openFlags, 0);
 2047     if( rc!=SQLITE_OK ){
 2048       Tcl_AppendResult(interp, "cannot open target database: ",
 2049            sqlite3_errmsg(pDest), (char*)0);
 2050       sqlite3_close(pDest);
 2051       return TCL_ERROR;
 2052     }
 2053     pBackup = sqlite3_backup_init(pDest, "main", pDb->db, zSrcDb);
 2054     if( pBackup==0 ){
 2055       Tcl_AppendResult(interp, "backup failed: ",
 2056            sqlite3_errmsg(pDest), (char*)0);
 2057       sqlite3_close(pDest);
 2058       return TCL_ERROR;
 2059     }
 2060     while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
 2061     sqlite3_backup_finish(pBackup);
 2062     if( rc==SQLITE_DONE ){
 2063       rc = TCL_OK;
 2064     }else{
 2065       Tcl_AppendResult(interp, "backup failed: ",
 2066            sqlite3_errmsg(pDest), (char*)0);
 2067       rc = TCL_ERROR;
 2068     }
 2069     sqlite3_close(pDest);
 2070     break;
 2071   }
 2072 
 2073   /*    $db bind_fallback ?CALLBACK?
 2074   **
 2075   ** When resolving bind parameters in an SQL statement, if the parameter
 2076   ** cannot be associated with a TCL variable then invoke CALLBACK with a
 2077   ** single argument that is the name of the parameter and use the return
 2078   ** value of the CALLBACK as the binding.  If CALLBACK returns something
 2079   ** other than TCL_OK or TCL_ERROR then bind a NULL.
 2080   **
 2081   ** If CALLBACK is an empty string, then revert to the default behavior 
 2082   ** which is to set the binding to NULL.
 2083   **
 2084   ** If CALLBACK returns an error, that causes the statement execution to
 2085   ** abort.  Hence, to configure a connection so that it throws an error
 2086   ** on an attempt to bind an unknown variable, do something like this:
 2087   **
 2088   **     proc bind_error {name} {error "no such variable: $name"}
 2089   **     db bind_fallback bind_error
 2090   */
 2091   case DB_BIND_FALLBACK: {
 2092     if( objc>3 ){
 2093       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
 2094       return TCL_ERROR;
 2095     }else if( objc==2 ){
 2096       if( pDb->zBindFallback ){
 2097         Tcl_AppendResult(interp, pDb->zBindFallback, (char*)0);
 2098       }
 2099     }else{
 2100       char *zCallback;
 2101       int len;
 2102       if( pDb->zBindFallback ){
 2103         Tcl_Free(pDb->zBindFallback);
 2104       }
 2105       zCallback = Tcl_GetStringFromObj(objv[2], &len);
 2106       if( zCallback && len>0 ){
 2107         pDb->zBindFallback = Tcl_Alloc( len + 1 );
 2108         memcpy(pDb->zBindFallback, zCallback, len+1);
 2109       }else{
 2110         pDb->zBindFallback = 0;
 2111       }
 2112     }
 2113     break;
 2114   }
 2115 
 2116   /*    $db busy ?CALLBACK?
 2117   **
 2118   ** Invoke the given callback if an SQL statement attempts to open
 2119   ** a locked database file.
 2120   */
 2121   case DB_BUSY: {
 2122     if( objc>3 ){
 2123       Tcl_WrongNumArgs(interp, 2, objv, "CALLBACK");
 2124       return TCL_ERROR;
 2125     }else if( objc==2 ){
 2126       if( pDb->zBusy ){
 2127         Tcl_AppendResult(interp, pDb->zBusy, (char*)0);
 2128       }
 2129     }else{
 2130       char *zBusy;
 2131       int len;
 2132       if( pDb->zBusy ){
 2133         Tcl_Free(pDb->zBusy);
 2134       }
 2135       zBusy = Tcl_GetStringFromObj(objv[2], &len);
 2136       if( zBusy && len>0 ){
 2137         pDb->zBusy = Tcl_Alloc( len + 1 );
 2138         memcpy(pDb->zBusy, zBusy, len+1);
 2139       }else{
 2140         pDb->zBusy = 0;
 2141       }
 2142       if( pDb->zBusy ){
 2143         pDb->interp = interp;
 2144         sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb);
 2145       }else{
 2146         sqlite3_busy_handler(pDb->db, 0, 0);
 2147       }
 2148     }
 2149     break;
 2150   }
 2151 
 2152   /*     $db cache flush
 2153   **     $db cache size n
 2154   **
 2155   ** Flush the prepared statement cache, or set the maximum number of
 2156   ** cached statements.
 2157   */
 2158   case DB_CACHE: {
 2159     char *subCmd;
 2160     int n;
 2161 
 2162     if( objc<=2 ){
 2163       Tcl_WrongNumArgs(interp, 1, objv, "cache option ?arg?");
 2164       return TCL_ERROR;
 2165     }
 2166     subCmd = Tcl_GetStringFromObj( objv[2], 0 );
 2167     if( *subCmd=='f' && strcmp(subCmd,"flush")==0 ){
 2168       if( objc!=3 ){
 2169         Tcl_WrongNumArgs(interp, 2, objv, "flush");
 2170         return TCL_ERROR;
 2171       }else{
 2172         flushStmtCache( pDb );
 2173       }
 2174     }else if( *subCmd=='s' && strcmp(subCmd,"size")==0 ){
 2175       if( objc!=4 ){
 2176         Tcl_WrongNumArgs(interp, 2, objv, "size n");
 2177         return TCL_ERROR;
 2178       }else{
 2179         if( TCL_ERROR==Tcl_GetIntFromObj(interp, objv[3], &n) ){
 2180           Tcl_AppendResult( interp, "cannot convert \"",
 2181                Tcl_GetStringFromObj(objv[3],0), "\" to integer", (char*)0);
 2182           return TCL_ERROR;
 2183         }else{
 2184           if( n<0 ){
 2185             flushStmtCache( pDb );
 2186             n = 0;
 2187           }else if( n>MAX_PREPARED_STMTS ){
 2188             n = MAX_PREPARED_STMTS;
 2189           }
 2190           pDb->maxStmt = n;
 2191         }
 2192       }
 2193     }else{
 2194       Tcl_AppendResult( interp, "bad option \"",
 2195           Tcl_GetStringFromObj(objv[2],0), "\": must be flush or size",
 2196           (char*)0);
 2197       return TCL_ERROR;
 2198     }
 2199     break;
 2200   }
 2201 
 2202   /*     $db changes
 2203   **
 2204   ** Return the number of rows that were modified, inserted, or deleted by
 2205   ** the most recent INSERT, UPDATE or DELETE statement, not including
 2206   ** any changes made by trigger programs.
 2207   */
 2208   case DB_CHANGES: {
 2209     Tcl_Obj *pResult;
 2210     if( objc!=2 ){
 2211       Tcl_WrongNumArgs(interp, 2, objv, "");
 2212       return TCL_ERROR;
 2213     }
 2214     pResult = Tcl_GetObjResult(interp);
 2215     Tcl_SetIntObj(pResult, sqlite3_changes(pDb->db));
 2216     break;
 2217   }
 2218 
 2219   /*    $db close
 2220   **
 2221   ** Shutdown the database
 2222   */
 2223   case DB_CLOSE: {
 2224     Tcl_DeleteCommand(interp, Tcl_GetStringFromObj(objv[0], 0));
 2225     break;
 2226   }
 2227 
 2228   /*
 2229   **     $db collate NAME SCRIPT
 2230   **
 2231   ** Create a new SQL collation function called NAME.  Whenever
 2232   ** that function is called, invoke SCRIPT to evaluate the function.
 2233   */
 2234   case DB_COLLATE: {
 2235     SqlCollate *pCollate;
 2236     char *zName;
 2237     char *zScript;
 2238     int nScript;
 2239     if( objc!=4 ){
 2240       Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");
 2241       return TCL_ERROR;
 2242     }
 2243     zName = Tcl_GetStringFromObj(objv[2], 0);
 2244     zScript = Tcl_GetStringFromObj(objv[3], &nScript);
 2245     pCollate = (SqlCollate*)Tcl_Alloc( sizeof(*pCollate) + nScript + 1 );
 2246     if( pCollate==0 ) return TCL_ERROR;
 2247     pCollate->interp = interp;
 2248     pCollate->pNext = pDb->pCollate;
 2249     pCollate->zScript = (char*)&pCollate[1];
 2250     pDb->pCollate = pCollate;
 2251     memcpy(pCollate->zScript, zScript, nScript+1);
 2252     if( sqlite3_create_collation(pDb->db, zName, SQLITE_UTF8,
 2253         pCollate, tclSqlCollate) ){
 2254       Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
 2255       return TCL_ERROR;
 2256     }
 2257     break;
 2258   }
 2259 
 2260   /*
 2261   **     $db collation_needed SCRIPT
 2262   **
 2263   ** Create a new SQL collation function called NAME.  Whenever
 2264   ** that function is called, invoke SCRIPT to evaluate the function.
 2265   */
 2266   case DB_COLLATION_NEEDED: {
 2267     if( objc!=3 ){
 2268       Tcl_WrongNumArgs(interp, 2, objv, "SCRIPT");
 2269       return TCL_ERROR;
 2270     }
 2271     if( pDb->pCollateNeeded ){
 2272       Tcl_DecrRefCount(pDb->pCollateNeeded);
 2273     }
 2274     pDb->pCollateNeeded = Tcl_DuplicateObj(objv[2]);
 2275     Tcl_IncrRefCount(pDb->pCollateNeeded);
 2276     sqlite3_collation_needed(pDb->db, pDb, tclCollateNeeded);
 2277     break;
 2278   }
 2279 
 2280   /*    $db commit_hook ?CALLBACK?
 2281   **
 2282   ** Invoke the given callback just before committing every SQL transaction.
 2283   ** If the callback throws an exception or returns non-zero, then the
 2284   ** transaction is aborted.  If CALLBACK is an empty string, the callback
 2285   ** is disabled.
 2286   */
 2287   case DB_COMMIT_HOOK: {
 2288     if( objc>3 ){
 2289       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
 2290       return TCL_ERROR;
 2291     }else if( objc==2 ){
 2292       if( pDb->zCommit ){
 2293         Tcl_AppendResult(interp, pDb->zCommit, (char*)0);
 2294       }
 2295     }else{
 2296       const char *zCommit;
 2297       int len;
 2298       if( pDb->zCommit ){
 2299         Tcl_Free(pDb->zCommit);
 2300       }
 2301       zCommit = Tcl_GetStringFromObj(objv[2], &len);
 2302       if( zCommit && len>0 ){
 2303         pDb->zCommit = Tcl_Alloc( len + 1 );
 2304         memcpy(pDb->zCommit, zCommit, len+1);
 2305       }else{
 2306         pDb->zCommit = 0;
 2307       }
 2308       if( pDb->zCommit ){
 2309         pDb->interp = interp;
 2310         sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb);
 2311       }else{
 2312         sqlite3_commit_hook(pDb->db, 0, 0);
 2313       }
 2314     }
 2315     break;
 2316   }
 2317 
 2318   /*    $db complete SQL
 2319   **
 2320   ** Return TRUE if SQL is a complete SQL statement.  Return FALSE if
 2321   ** additional lines of input are needed.  This is similar to the
 2322   ** built-in "info complete" command of Tcl.
 2323   */
 2324   case DB_COMPLETE: {
 2325 #ifndef SQLITE_OMIT_COMPLETE
 2326     Tcl_Obj *pResult;
 2327     int isComplete;
 2328     if( objc!=3 ){
 2329       Tcl_WrongNumArgs(interp, 2, objv, "SQL");
 2330       return TCL_ERROR;
 2331     }
 2332     isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) );
 2333     pResult = Tcl_GetObjResult(interp);
 2334     Tcl_SetBooleanObj(pResult, isComplete);
 2335 #endif
 2336     break;
 2337   }
 2338 
 2339   /*    $db config ?OPTION? ?BOOLEAN?
 2340   **
 2341   ** Configure the database connection using the sqlite3_db_config()
 2342   ** interface.
 2343   */
 2344   case DB_CONFIG: {
 2345     static const struct DbConfigChoices {
 2346       const char *zName;
 2347       int op;
 2348     } aDbConfig[] = {
 2349         { "defensive",          SQLITE_DBCONFIG_DEFENSIVE             },
 2350         { "dqs_ddl",            SQLITE_DBCONFIG_DQS_DDL               },
 2351         { "dqs_dml",            SQLITE_DBCONFIG_DQS_DML               },
 2352         { "enable_fkey",        SQLITE_DBCONFIG_ENABLE_FKEY           },
 2353         { "enable_qpsg",        SQLITE_DBCONFIG_ENABLE_QPSG           },
 2354         { "enable_trigger",     SQLITE_DBCONFIG_ENABLE_TRIGGER        },
 2355         { "enable_view",        SQLITE_DBCONFIG_ENABLE_VIEW           },
 2356         { "fts3_tokenizer",     SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
 2357         { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    },
 2358         { "legacy_file_format", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT    },
 2359         { "load_extension",     SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
 2360         { "no_ckpt_on_close",   SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      },
 2361         { "reset_database",     SQLITE_DBCONFIG_RESET_DATABASE        },
 2362         { "trigger_eqp",        SQLITE_DBCONFIG_TRIGGER_EQP           },
 2363         { "trusted_schema",     SQLITE_DBCONFIG_TRUSTED_SCHEMA        },
 2364         { "writable_schema",    SQLITE_DBCONFIG_WRITABLE_SCHEMA       },
 2365     };
 2366     Tcl_Obj *pResult;
 2367     int ii;
 2368     if( objc>4 ){
 2369       Tcl_WrongNumArgs(interp, 2, objv, "?OPTION? ?BOOLEAN?");
 2370       return TCL_ERROR;
 2371     }
 2372     if( objc==2 ){
 2373       /* With no arguments, list all configuration options and with the
 2374       ** current value */
 2375       pResult = Tcl_NewListObj(0,0);
 2376       for(ii=0; ii<sizeof(aDbConfig)/sizeof(aDbConfig[0]); ii++){
 2377         int v = 0;
 2378         sqlite3_db_config(pDb->db, aDbConfig[ii].op, -1, &v);
 2379         Tcl_ListObjAppendElement(interp, pResult,
 2380            Tcl_NewStringObj(aDbConfig[ii].zName,-1));
 2381         Tcl_ListObjAppendElement(interp, pResult,
 2382            Tcl_NewIntObj(v));
 2383       }
 2384     }else{
 2385       const char *zOpt = Tcl_GetString(objv[2]);
 2386       int onoff = -1;
 2387       int v = 0;
 2388       if( zOpt[0]=='-' ) zOpt++;
 2389       for(ii=0; ii<sizeof(aDbConfig)/sizeof(aDbConfig[0]); ii++){
 2390         if( strcmp(aDbConfig[ii].zName, zOpt)==0 ) break;
 2391       }
 2392       if( ii>=sizeof(aDbConfig)/sizeof(aDbConfig[0]) ){
 2393         Tcl_AppendResult(interp, "unknown config option: \"", zOpt,
 2394                                 "\"", (void*)0);
 2395         return TCL_ERROR;
 2396       }
 2397       if( objc==4 ){
 2398         if( Tcl_GetBooleanFromObj(interp, objv[3], &onoff) ){
 2399           return TCL_ERROR;
 2400         }
 2401       }
 2402       sqlite3_db_config(pDb->db, aDbConfig[ii].op, onoff, &v);
 2403       pResult = Tcl_NewIntObj(v);
 2404     }
 2405     Tcl_SetObjResult(interp, pResult);
 2406     break;
 2407   }
 2408 
 2409   /*    $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
 2410   **
 2411   ** Copy data into table from filename, optionally using SEPARATOR
 2412   ** as column separators.  If a column contains a null string, or the
 2413   ** value of NULLINDICATOR, a NULL is inserted for the column.
 2414   ** conflict-algorithm is one of the sqlite conflict algorithms:
 2415   **    rollback, abort, fail, ignore, replace
 2416   ** On success, return the number of lines processed, not necessarily same
 2417   ** as 'db changes' due to conflict-algorithm selected.
 2418   **
 2419   ** This code is basically an implementation/enhancement of
 2420   ** the sqlite3 shell.c ".import" command.
 2421   **
 2422   ** This command usage is equivalent to the sqlite2.x COPY statement,
 2423   ** which imports file data into a table using the PostgreSQL COPY file format:
 2424   **   $db copy $conflit_algo $table_name $filename \t \\N
 2425   */
 2426   case DB_COPY: {
 2427     char *zTable;               /* Insert data into this table */
 2428     char *zFile;                /* The file from which to extract data */
 2429     char *zConflict;            /* The conflict algorithm to use */
 2430     sqlite3_stmt *pStmt;        /* A statement */
 2431     int nCol;                   /* Number of columns in the table */
 2432     int nByte;                  /* Number of bytes in an SQL string */
 2433     int i, j;                   /* Loop counters */
 2434     int nSep;                   /* Number of bytes in zSep[] */
 2435     int nNull;                  /* Number of bytes in zNull[] */
 2436     char *zSql;                 /* An SQL statement */
 2437     char *zLine;                /* A single line of input from the file */
 2438     char **azCol;               /* zLine[] broken up into columns */
 2439     const char *zCommit;        /* How to commit changes */
 2440     FILE *in;                   /* The input file */
 2441     int lineno = 0;             /* Line number of input file */
 2442     char zLineNum[80];          /* Line number print buffer */
 2443     Tcl_Obj *pResult;           /* interp result */
 2444 
 2445     const char *zSep;
 2446     const char *zNull;
 2447     if( objc<5 || objc>7 ){
 2448       Tcl_WrongNumArgs(interp, 2, objv,
 2449          "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");
 2450       return TCL_ERROR;
 2451     }
 2452     if( objc>=6 ){
 2453       zSep = Tcl_GetStringFromObj(objv[5], 0);
 2454     }else{
 2455       zSep = "\t";
 2456     }
 2457     if( objc>=7 ){
 2458       zNull = Tcl_GetStringFromObj(objv[6], 0);
 2459     }else{
 2460       zNull = "";
 2461     }
 2462     zConflict = Tcl_GetStringFromObj(objv[2], 0);
 2463     zTable = Tcl_GetStringFromObj(objv[3], 0);
 2464     zFile = Tcl_GetStringFromObj(objv[4], 0);
 2465     nSep = strlen30(zSep);
 2466     nNull = strlen30(zNull);
 2467     if( nSep==0 ){
 2468       Tcl_AppendResult(interp,"Error: non-null separator required for copy",
 2469                        (char*)0);
 2470       return TCL_ERROR;
 2471     }
 2472     if(strcmp(zConflict, "rollback") != 0 &&
 2473        strcmp(zConflict, "abort"   ) != 0 &&
 2474        strcmp(zConflict, "fail"    ) != 0 &&
 2475        strcmp(zConflict, "ignore"  ) != 0 &&
 2476        strcmp(zConflict, "replace" ) != 0 ) {
 2477       Tcl_AppendResult(interp, "Error: \"", zConflict,
 2478             "\", conflict-algorithm must be one of: rollback, "
 2479             "abort, fail, ignore, or replace", (char*)0);
 2480       return TCL_ERROR;
 2481     }
 2482     zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
 2483     if( zSql==0 ){
 2484       Tcl_AppendResult(interp, "Error: no such table: ", zTable, (char*)0);
 2485       return TCL_ERROR;
 2486     }
 2487     nByte = strlen30(zSql);
 2488     rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
 2489     sqlite3_free(zSql);
 2490     if( rc ){
 2491       Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), (char*)0);
 2492       nCol = 0;
 2493     }else{
 2494       nCol = sqlite3_column_count(pStmt);
 2495     }
 2496     sqlite3_finalize(pStmt);
 2497     if( nCol==0 ) {
 2498       return TCL_ERROR;
 2499     }
 2500     zSql = malloc( nByte + 50 + nCol*2 );
 2501     if( zSql==0 ) {
 2502       Tcl_AppendResult(interp, "Error: can't malloc()", (char*)0);
 2503       return TCL_ERROR;
 2504     }
 2505     sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",
 2506          zConflict, zTable);
 2507     j = strlen30(zSql);
 2508     for(i=1; i<nCol; i++){
 2509       zSql[j++] = ',';
 2510       zSql[j++] = '?';
 2511     }
 2512     zSql[j++] = ')';
 2513     zSql[j] = 0;
 2514     rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
 2515     free(zSql);
 2516     if( rc ){
 2517       Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), (char*)0);
 2518       sqlite3_finalize(pStmt);
 2519       return TCL_ERROR;
 2520     }
 2521     in = fopen(zFile, "rb");
 2522     if( in==0 ){
 2523       Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, (char*)0);
 2524       sqlite3_finalize(pStmt);
 2525       return TCL_ERROR;
 2526     }
 2527     azCol = malloc( sizeof(azCol[0])*(nCol+1) );
 2528     if( azCol==0 ) {
 2529       Tcl_AppendResult(interp, "Error: can't malloc()", (char*)0);
 2530       fclose(in);
 2531       return TCL_ERROR;
 2532     }
 2533     (void)sqlite3_exec(pDb->db, "BEGIN", 0, 0, 0);
 2534     zCommit = "COMMIT";
 2535     while( (zLine = local_getline(0, in))!=0 ){
 2536       char *z;
 2537       lineno++;
 2538       azCol[0] = zLine;
 2539       for(i=0, z=zLine; *z; z++){
 2540         if( *z==zSep[0] && strncmp(z, zSep, nSep)==0 ){
 2541           *z = 0;
 2542           i++;
 2543           if( i<nCol ){
 2544             azCol[i] = &z[nSep];
 2545             z += nSep-1;
 2546           }
 2547         }
 2548       }
 2549       if( i+1!=nCol ){
 2550         char *zErr;
 2551         int nErr = strlen30(zFile) + 200;
 2552         zErr = malloc(nErr);
 2553         if( zErr ){
 2554           sqlite3_snprintf(nErr, zErr,
 2555              "Error: %s line %d: expected %d columns of data but found %d",
 2556              zFile, lineno, nCol, i+1);
 2557           Tcl_AppendResult(interp, zErr, (char*)0);
 2558           free(zErr);
 2559         }
 2560         zCommit = "ROLLBACK";
 2561         break;
 2562       }
 2563       for(i=0; i<nCol; i++){
 2564         /* check for null data, if so, bind as null */
 2565         if( (nNull>0 && strcmp(azCol[i], zNull)==0)
 2566           || strlen30(azCol[i])==0
 2567         ){
 2568           sqlite3_bind_null(pStmt, i+1);
 2569         }else{
 2570           sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
 2571         }
 2572       }
 2573       sqlite3_step(pStmt);
 2574       rc = sqlite3_reset(pStmt);
 2575       free(zLine);
 2576       if( rc!=SQLITE_OK ){
 2577         Tcl_AppendResult(interp,"Error: ", sqlite3_errmsg(pDb->db), (char*)0);
 2578         zCommit = "ROLLBACK";
 2579         break;
 2580       }
 2581     }
 2582     free(azCol);
 2583     fclose(in);
 2584     sqlite3_finalize(pStmt);
 2585     (void)sqlite3_exec(pDb->db, zCommit, 0, 0, 0);
 2586 
 2587     if( zCommit[0] == 'C' ){
 2588       /* success, set result as number of lines processed */
 2589       pResult = Tcl_GetObjResult(interp);
 2590       Tcl_SetIntObj(pResult, lineno);
 2591       rc = TCL_OK;
 2592     }else{
 2593       /* failure, append lineno where failed */
 2594       sqlite3_snprintf(sizeof(zLineNum), zLineNum,"%d",lineno);
 2595       Tcl_AppendResult(interp,", failed while processing line: ",zLineNum,
 2596                        (char*)0);
 2597       rc = TCL_ERROR;
 2598     }
 2599     break;
 2600   }
 2601 
 2602   /*
 2603   **     $db deserialize ?-maxsize N? ?-readonly BOOL? ?DATABASE? VALUE
 2604   **
 2605   ** Reopen DATABASE (default "main") using the content in $VALUE
 2606   */
 2607   case DB_DESERIALIZE: {
 2608 #ifndef SQLITE_ENABLE_DESERIALIZE
 2609     Tcl_AppendResult(interp, "MEMDB not available in this build",
 2610                      (char*)0);
 2611     rc = TCL_ERROR;
 2612 #else
 2613     const char *zSchema = 0;
 2614     Tcl_Obj *pValue = 0;
 2615     unsigned char *pBA;
 2616     unsigned char *pData;
 2617     int len, xrc;
 2618     sqlite3_int64 mxSize = 0;
 2619     int i;
 2620     int isReadonly = 0;
 2621 
 2622 
 2623     if( objc<3 ){
 2624       Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? VALUE");
 2625       rc = TCL_ERROR;
 2626       break;
 2627     }
 2628     for(i=2; i<objc-1; i++){
 2629       const char *z = Tcl_GetString(objv[i]);
 2630       if( strcmp(z,"-maxsize")==0 && i<objc-2 ){
 2631         rc = Tcl_GetWideIntFromObj(interp, objv[++i], &mxSize);
 2632         if( rc ) goto deserialize_error;
 2633         continue;
 2634       }
 2635       if( strcmp(z,"-readonly")==0 && i<objc-2 ){
 2636         rc = Tcl_GetBooleanFromObj(interp, objv[++i], &isReadonly);
 2637         if( rc ) goto deserialize_error;
 2638         continue;
 2639       }
 2640       if( zSchema==0 && i==objc-2 && z[0]!='-' ){
 2641         zSchema = z;
 2642         continue;
 2643       }
 2644       Tcl_AppendResult(interp, "unknown option: ", z, (char*)0);
 2645       rc = TCL_ERROR;
 2646       goto deserialize_error;
 2647     }
 2648     pValue = objv[objc-1];
 2649     pBA = Tcl_GetByteArrayFromObj(pValue, &len);
 2650     pData = sqlite3_malloc64( len );
 2651     if( pData==0 && len>0 ){
 2652       Tcl_AppendResult(interp, "out of memory", (char*)0);
 2653       rc = TCL_ERROR;
 2654     }else{
 2655       int flags;
 2656       if( len>0 ) memcpy(pData, pBA, len);
 2657       if( isReadonly ){
 2658         flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_READONLY;
 2659       }else{
 2660         flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE;
 2661       }
 2662       xrc = sqlite3_deserialize(pDb->db, zSchema, pData, len, len, flags);
 2663       if( xrc ){
 2664         Tcl_AppendResult(interp, "unable to set MEMDB content", (char*)0);
 2665         rc = TCL_ERROR;
 2666       }
 2667       if( mxSize>0 ){
 2668         sqlite3_file_control(pDb->db, zSchema,SQLITE_FCNTL_SIZE_LIMIT,&mxSize);
 2669       }
 2670     }
 2671 deserialize_error:
 2672 #endif
 2673     break; 
 2674   }
 2675 
 2676   /*
 2677   **    $db enable_load_extension BOOLEAN
 2678   **
 2679   ** Turn the extension loading feature on or off.  It if off by
 2680   ** default.
 2681   */
 2682   case DB_ENABLE_LOAD_EXTENSION: {
 2683 #ifndef SQLITE_OMIT_LOAD_EXTENSION
 2684     int onoff;
 2685     if( objc!=3 ){
 2686       Tcl_WrongNumArgs(interp, 2, objv, "BOOLEAN");
 2687       return TCL_ERROR;
 2688     }
 2689     if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){
 2690       return TCL_ERROR;
 2691     }
 2692     sqlite3_enable_load_extension(pDb->db, onoff);
 2693     break;
 2694 #else
 2695     Tcl_AppendResult(interp, "extension loading is turned off at compile-time",
 2696                      (char*)0);
 2697     return TCL_ERROR;
 2698 #endif
 2699   }
 2700 
 2701   /*
 2702   **    $db errorcode
 2703   **
 2704   ** Return the numeric error code that was returned by the most recent
 2705   ** call to sqlite3_exec().
 2706   */
 2707   case DB_ERRORCODE: {
 2708     Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_errcode(pDb->db)));
 2709     break;
 2710   }
 2711 
 2712   /*
 2713   **    $db exists $sql
 2714   **    $db onecolumn $sql
 2715   **
 2716   ** The onecolumn method is the equivalent of:
 2717   **     lindex [$db eval $sql] 0
 2718   */
 2719   case DB_EXISTS:
 2720   case DB_ONECOLUMN: {
 2721     Tcl_Obj *pResult = 0;
 2722     DbEvalContext sEval;
 2723     if( objc!=3 ){
 2724       Tcl_WrongNumArgs(interp, 2, objv, "SQL");
 2725       return TCL_ERROR;
 2726     }
 2727 
 2728     dbEvalInit(&sEval, pDb, objv[2], 0, 0);
 2729     rc = dbEvalStep(&sEval);
 2730     if( choice==DB_ONECOLUMN ){
 2731       if( rc==TCL_OK ){
 2732         pResult = dbEvalColumnValue(&sEval, 0);
 2733       }else if( rc==TCL_BREAK ){
 2734         Tcl_ResetResult(interp);
 2735       }
 2736     }else if( rc==TCL_BREAK || rc==TCL_OK ){
 2737       pResult = Tcl_NewBooleanObj(rc==TCL_OK);
 2738     }
 2739     dbEvalFinalize(&sEval);
 2740     if( pResult ) Tcl_SetObjResult(interp, pResult);
 2741 
 2742     if( rc==TCL_BREAK ){
 2743       rc = TCL_OK;
 2744     }
 2745     break;
 2746   }
 2747 
 2748   /*
 2749   **    $db eval ?options? $sql ?array? ?{  ...code... }?
 2750   **
 2751   ** The SQL statement in $sql is evaluated.  For each row, the values are
 2752   ** placed in elements of the array named "array" and ...code... is executed.
 2753   ** If "array" and "code" are omitted, then no callback is every invoked.
 2754   ** If "array" is an empty string, then the values are placed in variables
 2755   ** that have the same name as the fields extracted by the query.
 2756   */
 2757   case DB_EVAL: {
 2758     int evalFlags = 0;
 2759     const char *zOpt;
 2760     while( objc>3 && (zOpt = Tcl_GetString(objv[2]))!=0 && zOpt[0]=='-' ){
 2761       if( strcmp(zOpt, "-withoutnulls")==0 ){
 2762         evalFlags |= SQLITE_EVAL_WITHOUTNULLS;
 2763       }
 2764       else{
 2765         Tcl_AppendResult(interp, "unknown option: \"", zOpt, "\"", (void*)0);
 2766         return TCL_ERROR;
 2767       }
 2768       objc--;
 2769       objv++;
 2770     }
 2771     if( objc<3 || objc>5 ){
 2772       Tcl_WrongNumArgs(interp, 2, objv, 
 2773           "?OPTIONS? SQL ?ARRAY-NAME? ?SCRIPT?");
 2774       return TCL_ERROR;
 2775     }
 2776 
 2777     if( objc==3 ){
 2778       DbEvalContext sEval;
 2779       Tcl_Obj *pRet = Tcl_NewObj();
 2780       Tcl_IncrRefCount(pRet);
 2781       dbEvalInit(&sEval, pDb, objv[2], 0, 0);
 2782       while( TCL_OK==(rc = dbEvalStep(&sEval)) ){
 2783         int i;
 2784         int nCol;
 2785         dbEvalRowInfo(&sEval, &nCol, 0);
 2786         for(i=0; i<nCol; i++){
 2787           Tcl_ListObjAppendElement(interp, pRet, dbEvalColumnValue(&sEval, i));
 2788         }
 2789       }
 2790       dbEvalFinalize(&sEval);
 2791       if( rc==TCL_BREAK ){
 2792         Tcl_SetObjResult(interp, pRet);
 2793         rc = TCL_OK;
 2794       }
 2795       Tcl_DecrRefCount(pRet);
 2796     }else{
 2797       ClientData cd2[2];
 2798       DbEvalContext *p;
 2799       Tcl_Obj *pArray = 0;
 2800       Tcl_Obj *pScript;
 2801 
 2802       if( objc>=5 && *(char *)Tcl_GetString(objv[3]) ){
 2803         pArray = objv[3];
 2804       }
 2805       pScript = objv[objc-1];
 2806       Tcl_IncrRefCount(pScript);
 2807 
 2808       p = (DbEvalContext *)Tcl_Alloc(sizeof(DbEvalContext));
 2809       dbEvalInit(p, pDb, objv[2], pArray, evalFlags);
 2810 
 2811       cd2[0] = (void *)p;
 2812       cd2[1] = (void *)pScript;
 2813       rc = DbEvalNextCmd(cd2, interp, TCL_OK);
 2814     }
 2815     break;
 2816   }
 2817 
 2818   /*
 2819   **     $db function NAME [OPTIONS] SCRIPT
 2820   **
 2821   ** Create a new SQL function called NAME.  Whenever that function is
 2822   ** called, invoke SCRIPT to evaluate the function.
 2823   **
 2824   ** Options:
 2825   **         --argcount N           Function has exactly N arguments
 2826   **         --deterministic        The function is pure
 2827   **         --directonly           Prohibit use inside triggers and views
 2828   **         --innocuous            Has no side effects or information leaks
 2829   **         --returntype TYPE      Specify the return type of the function
 2830   */
 2831   case DB_FUNCTION: {
 2832     int flags = SQLITE_UTF8;
 2833     SqlFunc *pFunc;
 2834     Tcl_Obj *pScript;
 2835     char *zName;
 2836     int nArg = -1;
 2837     int i;
 2838     int eType = SQLITE_NULL;
 2839     if( objc<4 ){
 2840       Tcl_WrongNumArgs(interp, 2, objv, "NAME ?SWITCHES? SCRIPT");
 2841       return TCL_ERROR;
 2842     }
 2843     for(i=3; i<(objc-1); i++){
 2844       const char *z = Tcl_GetString(objv[i]);
 2845       int n = strlen30(z);
 2846       if( n>1 && strncmp(z, "-argcount",n)==0 ){
 2847         if( i==(objc-2) ){
 2848           Tcl_AppendResult(interp, "option requires an argument: ", z,(char*)0);
 2849           return TCL_ERROR;
 2850         }
 2851         if( Tcl_GetIntFromObj(interp, objv[i+1], &nArg) ) return TCL_ERROR;
 2852         if( nArg<0 ){
 2853           Tcl_AppendResult(interp, "number of arguments must be non-negative",
 2854                            (char*)0);
 2855           return TCL_ERROR;
 2856         }
 2857         i++;
 2858       }else
 2859       if( n>1 && strncmp(z, "-deterministic",n)==0 ){
 2860         flags |= SQLITE_DETERMINISTIC;
 2861       }else
 2862       if( n>1 && strncmp(z, "-directonly",n)==0 ){
 2863         flags |= SQLITE_DIRECTONLY;
 2864       }else
 2865       if( n>1 && strncmp(z, "-innocuous",n)==0 ){
 2866         flags |= SQLITE_INNOCUOUS;
 2867       }else
 2868       if( n>1 && strncmp(z, "-returntype", n)==0 ){
 2869         const char *azType[] = {"integer", "real", "text", "blob", "any", 0};
 2870         assert( SQLITE_INTEGER==1 && SQLITE_FLOAT==2 && SQLITE_TEXT==3 );
 2871         assert( SQLITE_BLOB==4 && SQLITE_NULL==5 );
 2872         if( i==(objc-2) ){
 2873           Tcl_AppendResult(interp, "option requires an argument: ", z,(char*)0);
 2874           return TCL_ERROR;
 2875         }
 2876         i++;
 2877         if( Tcl_GetIndexFromObj(interp, objv[i], azType, "type", 0, &eType) ){
 2878           return TCL_ERROR;
 2879         }
 2880         eType++;
 2881       }else{
 2882         Tcl_AppendResult(interp, "bad option \"", z,
 2883             "\": must be -argcount, -deterministic, -directonly,"
 2884             " -innocuous, or -returntype", (char*)0
 2885         );
 2886         return TCL_ERROR;
 2887       }
 2888     }
 2889 
 2890     pScript = objv[objc-1];
 2891     zName = Tcl_GetStringFromObj(objv[2], 0);
 2892     pFunc = findSqlFunc(pDb, zName);
 2893     if( pFunc==0 ) return TCL_ERROR;
 2894     if( pFunc->pScript ){
 2895       Tcl_DecrRefCount(pFunc->pScript);
 2896     }
 2897     pFunc->pScript = pScript;
 2898     Tcl_IncrRefCount(pScript);
 2899     pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript);
 2900     pFunc->eType = eType;
 2901     rc = sqlite3_create_function(pDb->db, zName, nArg, flags,
 2902         pFunc, tclSqlFunc, 0, 0);
 2903     if( rc!=SQLITE_OK ){
 2904       rc = TCL_ERROR;
 2905       Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
 2906     }
 2907     break;
 2908   }
 2909 
 2910   /*
 2911   **     $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
 2912   */
 2913   case DB_INCRBLOB: {
 2914 #ifdef SQLITE_OMIT_INCRBLOB
 2915     Tcl_AppendResult(interp, "incrblob not available in this build", (char*)0);
 2916     return TCL_ERROR;
 2917 #else
 2918     int isReadonly = 0;
 2919     const char *zDb = "main";
 2920     const char *zTable;
 2921     const char *zColumn;
 2922     Tcl_WideInt iRow;
 2923 
 2924     /* Check for the -readonly option */
 2925     if( objc>3 && strcmp(Tcl_GetString(objv[2]), "-readonly")==0 ){
 2926       isReadonly = 1;
 2927     }
 2928 
 2929     if( objc!=(5+isReadonly) && objc!=(6+isReadonly) ){
 2930       Tcl_WrongNumArgs(interp, 2, objv, "?-readonly? ?DB? TABLE COLUMN ROWID");
 2931       return TCL_ERROR;
 2932     }
 2933 
 2934     if( objc==(6+isReadonly) ){
 2935       zDb = Tcl_GetString(objv[2]);
 2936     }
 2937     zTable = Tcl_GetString(objv[objc-3]);
 2938     zColumn = Tcl_GetString(objv[objc-2]);
 2939     rc = Tcl_GetWideIntFromObj(interp, objv[objc-1], &iRow);
 2940 
 2941     if( rc==TCL_OK ){
 2942       rc = createIncrblobChannel(
 2943           interp, pDb, zDb, zTable, zColumn, (sqlite3_int64)iRow, isReadonly
 2944       );
 2945     }
 2946 #endif
 2947     break;
 2948   }
 2949 
 2950   /*
 2951   **     $db interrupt
 2952   **
 2953   ** Interrupt the execution of the inner-most SQL interpreter.  This
 2954   ** causes the SQL statement to return an error of SQLITE_INTERRUPT.
 2955   */
 2956   case DB_INTERRUPT: {
 2957     sqlite3_interrupt(pDb->db);
 2958     break;
 2959   }
 2960 
 2961   /*
 2962   **     $db nullvalue ?STRING?
 2963   **
 2964   ** Change text used when a NULL comes back from the database. If ?STRING?
 2965   ** is not present, then the current string used for NULL is returned.
 2966   ** If STRING is present, then STRING is returned.
 2967   **
 2968   */
 2969   case DB_NULLVALUE: {
 2970     if( objc!=2 && objc!=3 ){
 2971       Tcl_WrongNumArgs(interp, 2, objv, "NULLVALUE");
 2972       return TCL_ERROR;
 2973     }
 2974     if( objc==3 ){
 2975       int len;
 2976       char *zNull = Tcl_GetStringFromObj(objv[2], &len);
 2977       if( pDb->zNull ){
 2978         Tcl_Free(pDb->zNull);
 2979       }
 2980       if( zNull && len>0 ){
 2981         pDb->zNull = Tcl_Alloc( len + 1 );
 2982         memcpy(pDb->zNull, zNull, len);
 2983         pDb->zNull[len] = '\0';
 2984       }else{
 2985         pDb->zNull = 0;
 2986       }
 2987     }
 2988     Tcl_SetObjResult(interp, Tcl_NewStringObj(pDb->zNull, -1));
 2989     break;
 2990   }
 2991 
 2992   /*
 2993   **     $db last_insert_rowid
 2994   **
 2995   ** Return an integer which is the ROWID for the most recent insert.
 2996   */
 2997   case DB_LAST_INSERT_ROWID: {
 2998     Tcl_Obj *pResult;
 2999     Tcl_WideInt rowid;
 3000     if( objc!=2 ){
 3001       Tcl_WrongNumArgs(interp, 2, objv, "");
 3002       return TCL_ERROR;
 3003     }
 3004     rowid = sqlite3_last_insert_rowid(pDb->db);
 3005     pResult = Tcl_GetObjResult(interp);
 3006     Tcl_SetWideIntObj(pResult, rowid);
 3007     break;
 3008   }
 3009 
 3010   /*
 3011   ** The DB_ONECOLUMN method is implemented together with DB_EXISTS.
 3012   */
 3013 
 3014   /*    $db progress ?N CALLBACK?
 3015   **
 3016   ** Invoke the given callback every N virtual machine opcodes while executing
 3017   ** queries.
 3018   */
 3019   case DB_PROGRESS: {
 3020     if( objc==2 ){
 3021       if( pDb->zProgress ){
 3022         Tcl_AppendResult(interp, pDb->zProgress, (char*)0);
 3023       }
 3024     }else if( objc==4 ){
 3025       char *zProgress;
 3026       int len;
 3027       int N;
 3028       if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &N) ){
 3029         return TCL_ERROR;
 3030       };
 3031       if( pDb->zProgress ){
 3032         Tcl_Free(pDb->zProgress);
 3033       }
 3034       zProgress = Tcl_GetStringFromObj(objv[3], &len);
 3035       if( zProgress && len>0 ){
 3036         pDb->zProgress = Tcl_Alloc( len + 1 );
 3037         memcpy(pDb->zProgress, zProgress, len+1);
 3038       }else{
 3039         pDb->zProgress = 0;
 3040       }
 3041 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
 3042       if( pDb->zProgress ){
 3043         pDb->interp = interp;
 3044         sqlite3_progress_handler(pDb->db, N, DbProgressHandler, pDb);
 3045       }else{
 3046         sqlite3_progress_handler(pDb->db, 0, 0, 0);
 3047       }
 3048 #endif
 3049     }else{
 3050       Tcl_WrongNumArgs(interp, 2, objv, "N CALLBACK");
 3051       return TCL_ERROR;
 3052     }
 3053     break;
 3054   }
 3055 
 3056   /*    $db profile ?CALLBACK?
 3057   **
 3058   ** Make arrangements to invoke the CALLBACK routine after each SQL statement
 3059   ** that has run.  The text of the SQL and the amount of elapse time are
 3060   ** appended to CALLBACK before the script is run.
 3061   */
 3062   case DB_PROFILE: {
 3063     if( objc>3 ){
 3064       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
 3065       return TCL_ERROR;
 3066     }else if( objc==2 ){
 3067       if( pDb->zProfile ){
 3068         Tcl_AppendResult(interp, pDb->zProfile, (char*)0);
 3069       }
 3070     }else{
 3071       char *zProfile;
 3072       int len;
 3073       if( pDb->zProfile ){
 3074         Tcl_Free(pDb->zProfile);
 3075       }
 3076       zProfile = Tcl_GetStringFromObj(objv[2], &len);
 3077       if( zProfile && len>0 ){
 3078         pDb->zProfile = Tcl_Alloc( len + 1 );
 3079         memcpy(pDb->zProfile, zProfile, len+1);
 3080       }else{
 3081         pDb->zProfile = 0;
 3082       }
 3083 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
 3084     !defined(SQLITE_OMIT_DEPRECATED)
 3085       if( pDb->zProfile ){
 3086         pDb->interp = interp;
 3087         sqlite3_profile(pDb->db, DbProfileHandler, pDb);
 3088       }else{
 3089         sqlite3_profile(pDb->db, 0, 0);
 3090       }
 3091 #endif
 3092     }
 3093     break;
 3094   }
 3095 
 3096   /*
 3097   **     $db rekey KEY
 3098   **
 3099   ** Change the encryption key on the currently open database.
 3100   */
 3101   case DB_REKEY: {
 3102     if( objc!=3 ){
 3103       Tcl_WrongNumArgs(interp, 2, objv, "KEY");
 3104       return TCL_ERROR;
 3105     }
 3106     break;
 3107   }
 3108 
 3109   /*    $db restore ?DATABASE? FILENAME
 3110   **
 3111   ** Open a database file named FILENAME.  Transfer the content
 3112   ** of FILENAME into the local database DATABASE (default: "main").
 3113   */
 3114   case DB_RESTORE: {
 3115     const char *zSrcFile;
 3116     const char *zDestDb;
 3117     sqlite3 *pSrc;
 3118     sqlite3_backup *pBackup;
 3119     int nTimeout = 0;
 3120 
 3121     if( objc==3 ){
 3122       zDestDb = "main";
 3123       zSrcFile = Tcl_GetString(objv[2]);
 3124     }else if( objc==4 ){
 3125       zDestDb = Tcl_GetString(objv[2]);
 3126       zSrcFile = Tcl_GetString(objv[3]);
 3127     }else{
 3128       Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? FILENAME");
 3129       return TCL_ERROR;
 3130     }
 3131     rc = sqlite3_open_v2(zSrcFile, &pSrc,
 3132                          SQLITE_OPEN_READONLY | pDb->openFlags, 0);
 3133     if( rc!=SQLITE_OK ){
 3134       Tcl_AppendResult(interp, "cannot open source database: ",
 3135            sqlite3_errmsg(pSrc), (char*)0);
 3136       sqlite3_close(pSrc);
 3137       return TCL_ERROR;
 3138     }
 3139     pBackup = sqlite3_backup_init(pDb->db, zDestDb, pSrc, "main");
 3140     if( pBackup==0 ){
 3141       Tcl_AppendResult(interp, "restore failed: ",
 3142            sqlite3_errmsg(pDb->db), (char*)0);
 3143       sqlite3_close(pSrc);
 3144       return TCL_ERROR;
 3145     }
 3146     while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
 3147               || rc==SQLITE_BUSY ){
 3148       if( rc==SQLITE_BUSY ){
 3149         if( nTimeout++ >= 3 ) break;
 3150         sqlite3_sleep(100);
 3151       }
 3152     }
 3153     sqlite3_backup_finish(pBackup);
 3154     if( rc==SQLITE_DONE ){
 3155       rc = TCL_OK;
 3156     }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
 3157       Tcl_AppendResult(interp, "restore failed: source database busy",
 3158                        (char*)0);
 3159       rc = TCL_ERROR;
 3160     }else{
 3161       Tcl_AppendResult(interp, "restore failed: ",
 3162            sqlite3_errmsg(pDb->db), (char*)0);
 3163       rc = TCL_ERROR;
 3164     }
 3165     sqlite3_close(pSrc);
 3166     break;
 3167   }
 3168 
 3169   /*
 3170   **     $db serialize ?DATABASE?
 3171   **
 3172   ** Return a serialization of a database.  
 3173   */
 3174   case DB_SERIALIZE: {
 3175 #ifndef SQLITE_ENABLE_DESERIALIZE
 3176     Tcl_AppendResult(interp, "MEMDB not available in this build",
 3177                      (char*)0);
 3178     rc = TCL_ERROR;
 3179 #else
 3180     const char *zSchema = objc>=3 ? Tcl_GetString(objv[2]) : "main";
 3181     sqlite3_int64 sz = 0;
 3182     unsigned char *pData;
 3183     if( objc!=2 && objc!=3 ){
 3184       Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE?");
 3185       rc = TCL_ERROR;
 3186     }else{
 3187       int needFree;
 3188       pData = sqlite3_serialize(pDb->db, zSchema, &sz, SQLITE_SERIALIZE_NOCOPY);
 3189       if( pData ){
 3190         needFree = 0;
 3191       }else{
 3192         pData = sqlite3_serialize(pDb->db, zSchema, &sz, 0);
 3193         needFree = 1;
 3194       }
 3195       Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pData,sz));
 3196       if( needFree ) sqlite3_free(pData);
 3197     }
 3198 #endif
 3199     break;
 3200   }
 3201 
 3202   /*
 3203   **     $db status (step|sort|autoindex|vmstep)
 3204   **
 3205   ** Display SQLITE_STMTSTATUS_FULLSCAN_STEP or
 3206   ** SQLITE_STMTSTATUS_SORT for the most recent eval.
 3207   */
 3208   case DB_STATUS: {
 3209     int v;
 3210     const char *zOp;
 3211     if( objc!=3 ){
 3212       Tcl_WrongNumArgs(interp, 2, objv, "(step|sort|autoindex)");
 3213       return TCL_ERROR;
 3214     }
 3215     zOp = Tcl_GetString(objv[2]);
 3216     if( strcmp(zOp, "step")==0 ){
 3217       v = pDb->nStep;
 3218     }else if( strcmp(zOp, "sort")==0 ){
 3219       v = pDb->nSort;
 3220     }else if( strcmp(zOp, "autoindex")==0 ){
 3221       v = pDb->nIndex;
 3222     }else if( strcmp(zOp, "vmstep")==0 ){
 3223       v = pDb->nVMStep;
 3224     }else{
 3225       Tcl_AppendResult(interp,
 3226             "bad argument: should be autoindex, step, sort or vmstep",
 3227             (char*)0);
 3228       return TCL_ERROR;
 3229     }
 3230     Tcl_SetObjResult(interp, Tcl_NewIntObj(v));
 3231     break;
 3232   }
 3233 
 3234   /*
 3235   **     $db timeout MILLESECONDS
 3236   **
 3237   ** Delay for the number of milliseconds specified when a file is locked.
 3238   */
 3239   case DB_TIMEOUT: {
 3240     int ms;
 3241     if( objc!=3 ){
 3242       Tcl_WrongNumArgs(interp, 2, objv, "MILLISECONDS");
 3243       return TCL_ERROR;
 3244     }
 3245     if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR;
 3246     sqlite3_busy_timeout(pDb->db, ms);
 3247     break;
 3248   }
 3249 
 3250   /*
 3251   **     $db total_changes
 3252   **
 3253   ** Return the number of rows that were modified, inserted, or deleted
 3254   ** since the database handle was created.
 3255   */
 3256   case DB_TOTAL_CHANGES: {
 3257     Tcl_Obj *pResult;
 3258     if( objc!=2 ){
 3259       Tcl_WrongNumArgs(interp, 2, objv, "");
 3260       return TCL_ERROR;
 3261     }
 3262     pResult = Tcl_GetObjResult(interp);
 3263     Tcl_SetIntObj(pResult, sqlite3_total_changes(pDb->db));
 3264     break;
 3265   }
 3266 
 3267   /*    $db trace ?CALLBACK?
 3268   **
 3269   ** Make arrangements to invoke the CALLBACK routine for each SQL statement
 3270   ** that is executed.  The text of the SQL is appended to CALLBACK before
 3271   ** it is executed.
 3272   */
 3273   case DB_TRACE: {
 3274     if( objc>3 ){
 3275       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
 3276       return TCL_ERROR;
 3277     }else if( objc==2 ){
 3278       if( pDb->zTrace ){
 3279         Tcl_AppendResult(interp, pDb->zTrace, (char*)0);
 3280       }
 3281     }else{
 3282       char *zTrace;
 3283       int len;
 3284       if( pDb->zTrace ){
 3285         Tcl_Free(pDb->zTrace);
 3286       }
 3287       zTrace = Tcl_GetStringFromObj(objv[2], &len);
 3288       if( zTrace && len>0 ){
 3289         pDb->zTrace = Tcl_Alloc( len + 1 );
 3290         memcpy(pDb->zTrace, zTrace, len+1);
 3291       }else{
 3292         pDb->zTrace = 0;
 3293       }
 3294 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
 3295     !defined(SQLITE_OMIT_DEPRECATED)
 3296       if( pDb->zTrace ){
 3297         pDb->interp = interp;
 3298         sqlite3_trace(pDb->db, DbTraceHandler, pDb);
 3299       }else{
 3300         sqlite3_trace(pDb->db, 0, 0);
 3301       }
 3302 #endif
 3303     }
 3304     break;
 3305   }
 3306 
 3307   /*    $db trace_v2 ?CALLBACK? ?MASK?
 3308   **
 3309   ** Make arrangements to invoke the CALLBACK routine for each trace event
 3310   ** matching the mask that is generated.  The parameters are appended to
 3311   ** CALLBACK before it is executed.
 3312   */
 3313   case DB_TRACE_V2: {
 3314     if( objc>4 ){
 3315       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK? ?MASK?");
 3316       return TCL_ERROR;
 3317     }else if( objc==2 ){
 3318       if( pDb->zTraceV2 ){
 3319         Tcl_AppendResult(interp, pDb->zTraceV2, (char*)0);
 3320       }
 3321     }else{
 3322       char *zTraceV2;
 3323       int len;
 3324       Tcl_WideInt wMask = 0;
 3325       if( objc==4 ){
 3326         static const char *TTYPE_strs[] = {
 3327           "statement", "profile", "row", "close", 0
 3328         };
 3329         enum TTYPE_enum {
 3330           TTYPE_STMT, TTYPE_PROFILE, TTYPE_ROW, TTYPE_CLOSE
 3331         };
 3332         int i;
 3333         if( TCL_OK!=Tcl_ListObjLength(interp, objv[3], &len) ){
 3334           return TCL_ERROR;
 3335         }
 3336         for(i=0; i<len; i++){
 3337           Tcl_Obj *pObj;
 3338           int ttype;
 3339           if( TCL_OK!=Tcl_ListObjIndex(interp, objv[3], i, &pObj) ){
 3340             return TCL_ERROR;
 3341           }
 3342           if( Tcl_GetIndexFromObj(interp, pObj, TTYPE_strs, "trace type",
 3343                                   0, &ttype)!=TCL_OK ){
 3344             Tcl_WideInt wType;
 3345             Tcl_Obj *pError = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
 3346             Tcl_IncrRefCount(pError);
 3347             if( TCL_OK==Tcl_GetWideIntFromObj(interp, pObj, &wType) ){
 3348               Tcl_DecrRefCount(pError);
 3349               wMask |= wType;
 3350             }else{
 3351               Tcl_SetObjResult(interp, pError);
 3352               Tcl_DecrRefCount(pError);
 3353               return TCL_ERROR;
 3354             }
 3355           }else{
 3356             switch( (enum TTYPE_enum)ttype ){
 3357               case TTYPE_STMT:    wMask |= SQLITE_TRACE_STMT;    break;
 3358               case TTYPE_PROFILE: wMask |= SQLITE_TRACE_PROFILE; break;
 3359               case TTYPE_ROW:     wMask |= SQLITE_TRACE_ROW;     break;
 3360               case TTYPE_CLOSE:   wMask |= SQLITE_TRACE_CLOSE;   break;
 3361             }
 3362           }
 3363         }
 3364       }else{
 3365         wMask = SQLITE_TRACE_STMT; /* use the "legacy" default */
 3366       }
 3367       if( pDb->zTraceV2 ){
 3368         Tcl_Free(pDb->zTraceV2);
 3369       }
 3370       zTraceV2 = Tcl_GetStringFromObj(objv[2], &len);
 3371       if( zTraceV2 && len>0 ){
 3372         pDb->zTraceV2 = Tcl_Alloc( len + 1 );
 3373         memcpy(pDb->zTraceV2, zTraceV2, len+1);
 3374       }else{
 3375         pDb->zTraceV2 = 0;
 3376       }
 3377 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
 3378       if( pDb->zTraceV2 ){
 3379         pDb->interp = interp;
 3380         sqlite3_trace_v2(pDb->db, (unsigned)wMask, DbTraceV2Handler, pDb);
 3381       }else{
 3382         sqlite3_trace_v2(pDb->db, 0, 0, 0);
 3383       }
 3384 #endif
 3385     }
 3386     break;
 3387   }
 3388 
 3389   /*    $db transaction [-deferred|-immediate|-exclusive] SCRIPT
 3390   **
 3391   ** Start a new transaction (if we are not already in the midst of a
 3392   ** transaction) and execute the TCL script SCRIPT.  After SCRIPT
 3393   ** completes, either commit the transaction or roll it back if SCRIPT
 3394   ** throws an exception.  Or if no new transation was started, do nothing.
 3395   ** pass the exception on up the stack.
 3396   **
 3397   ** This command was inspired by Dave Thomas's talk on Ruby at the
 3398   ** 2005 O'Reilly Open Source Convention (OSCON).
 3399   */
 3400   case DB_TRANSACTION: {
 3401     Tcl_Obj *pScript;
 3402     const char *zBegin = "SAVEPOINT _tcl_transaction";
 3403     if( objc!=3 && objc!=4 ){
 3404       Tcl_WrongNumArgs(interp, 2, objv, "[TYPE] SCRIPT");
 3405       return TCL_ERROR;
 3406     }
 3407 
 3408     if( pDb->nTransaction==0 && objc==4 ){
 3409       static const char *TTYPE_strs[] = {
 3410         "deferred",   "exclusive",  "immediate", 0
 3411       };
 3412       enum TTYPE_enum {
 3413         TTYPE_DEFERRED, TTYPE_EXCLUSIVE, TTYPE_IMMEDIATE
 3414       };
 3415       int ttype;
 3416       if( Tcl_GetIndexFromObj(interp, objv[2], TTYPE_strs, "transaction type",
 3417                               0, &ttype) ){
 3418         return TCL_ERROR;
 3419       }
 3420       switch( (enum TTYPE_enum)ttype ){
 3421         case TTYPE_DEFERRED:    /* no-op */;                 break;
 3422         case TTYPE_EXCLUSIVE:   zBegin = "BEGIN EXCLUSIVE";  break;
 3423         case TTYPE_IMMEDIATE:   zBegin = "BEGIN IMMEDIATE";  break;
 3424       }
 3425     }
 3426     pScript = objv[objc-1];
 3427 
 3428     /* Run the SQLite BEGIN command to open a transaction or savepoint. */
 3429     pDb->disableAuth++;
 3430     rc = sqlite3_exec(pDb->db, zBegin, 0, 0, 0);
 3431     pDb->disableAuth--;
 3432     if( rc!=SQLITE_OK ){
 3433       Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);
 3434       return TCL_ERROR;
 3435     }
 3436     pDb->nTransaction++;
 3437 
 3438     /* If using NRE, schedule a callback to invoke the script pScript, then
 3439     ** a second callback to commit (or rollback) the transaction or savepoint
 3440     ** opened above. If not using NRE, evaluate the script directly, then
 3441     ** call function DbTransPostCmd() to commit (or rollback) the transaction
 3442     ** or savepoint.  */
 3443     if( DbUseNre() ){
 3444       Tcl_NRAddCallback(interp, DbTransPostCmd, cd, 0, 0, 0);
 3445       (void)Tcl_NREvalObj(interp, pScript, 0);
 3446     }else{
 3447       rc = DbTransPostCmd(&cd, interp, Tcl_EvalObjEx(interp, pScript, 0));
 3448     }
 3449     break;
 3450   }
 3451 
 3452   /*
 3453   **    $db unlock_notify ?script?
 3454   */
 3455   case DB_UNLOCK_NOTIFY: {
 3456 #ifndef SQLITE_ENABLE_UNLOCK_NOTIFY
 3457     Tcl_AppendResult(interp, "unlock_notify not available in this build",
 3458                      (char*)0);
 3459     rc = TCL_ERROR;
 3460 #else
 3461     if( objc!=2 && objc!=3 ){
 3462       Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
 3463       rc = TCL_ERROR;
 3464     }else{
 3465       void (*xNotify)(void **, int) = 0;
 3466       void *pNotifyArg = 0;
 3467 
 3468       if( pDb->pUnlockNotify ){
 3469         Tcl_DecrRefCount(pDb->pUnlockNotify);
 3470         pDb->pUnlockNotify = 0;
 3471       }
 3472 
 3473       if( objc==3 ){
 3474         xNotify = DbUnlockNotify;
 3475         pNotifyArg = (void *)pDb;
 3476         pDb->pUnlockNotify = objv[2];
 3477         Tcl_IncrRefCount(pDb->pUnlockNotify);
 3478       }
 3479 
 3480       if( sqlite3_unlock_notify(pDb->db, xNotify, pNotifyArg) ){
 3481         Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);
 3482         rc = TCL_ERROR;
 3483       }
 3484     }
 3485 #endif
 3486     break;
 3487   }
 3488 
 3489   /*
 3490   **    $db preupdate_hook count
 3491   **    $db preupdate_hook hook ?SCRIPT?
 3492   **    $db preupdate_hook new INDEX
 3493   **    $db preupdate_hook old INDEX
 3494   */
 3495   case DB_PREUPDATE: {
 3496 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
 3497     Tcl_AppendResult(interp, "preupdate_hook was omitted at compile-time", 
 3498                      (char*)0);
 3499     rc = TCL_ERROR;
 3500 #else
 3501     static const char *azSub[] = {"count", "depth", "hook", "new", "old", 0};
 3502     enum DbPreupdateSubCmd {
 3503       PRE_COUNT, PRE_DEPTH, PRE_HOOK, PRE_NEW, PRE_OLD
 3504     };
 3505     int iSub;
 3506 
 3507     if( objc<3 ){
 3508       Tcl_WrongNumArgs(interp, 2, objv, "SUB-COMMAND ?ARGS?");
 3509     }
 3510     if( Tcl_GetIndexFromObj(interp, objv[2], azSub, "sub-command", 0, &iSub) ){
 3511       return TCL_ERROR;
 3512     }
 3513 
 3514     switch( (enum DbPreupdateSubCmd)iSub ){
 3515       case PRE_COUNT: {
 3516         int nCol = sqlite3_preupdate_count(pDb->db);
 3517         Tcl_SetObjResult(interp, Tcl_NewIntObj(nCol));
 3518         break;
 3519       }
 3520 
 3521       case PRE_HOOK: {
 3522         if( objc>4 ){
 3523           Tcl_WrongNumArgs(interp, 2, objv, "hook ?SCRIPT?");
 3524           return TCL_ERROR;
 3525         }
 3526         DbHookCmd(interp, pDb, (objc==4 ? objv[3] : 0), &pDb->pPreUpdateHook);
 3527         break;
 3528       }
 3529 
 3530       case PRE_DEPTH: {
 3531         Tcl_Obj *pRet;
 3532         if( objc!=3 ){
 3533           Tcl_WrongNumArgs(interp, 3, objv, "");
 3534           return TCL_ERROR;
 3535         }
 3536         pRet = Tcl_NewIntObj(sqlite3_preupdate_depth(pDb->db));
 3537         Tcl_SetObjResult(interp, pRet);
 3538         break;
 3539       }
 3540 
 3541       case PRE_NEW:
 3542       case PRE_OLD: {
 3543         int iIdx;
 3544         sqlite3_value *pValue;
 3545         if( objc!=4 ){
 3546           Tcl_WrongNumArgs(interp, 3, objv, "INDEX");
 3547           return TCL_ERROR;
 3548         }
 3549         if( Tcl_GetIntFromObj(interp, objv[3], &iIdx) ){
 3550           return TCL_ERROR;
 3551         }
 3552 
 3553         if( iSub==PRE_OLD ){
 3554           rc = sqlite3_preupdate_old(pDb->db, iIdx, &pValue);
 3555         }else{
 3556           assert( iSub==PRE_NEW );
 3557           rc = sqlite3_preupdate_new(pDb->db, iIdx, &pValue);
 3558         }
 3559 
 3560         if( rc==SQLITE_OK ){
 3561           Tcl_Obj *pObj;
 3562           pObj = Tcl_NewStringObj((char*)sqlite3_value_text(pValue), -1);
 3563           Tcl_SetObjResult(interp, pObj);
 3564         }else{
 3565           Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);
 3566           return TCL_ERROR;
 3567         }
 3568       }
 3569     }
 3570 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
 3571     break;
 3572   }
 3573 
 3574   /*
 3575   **    $db wal_hook ?script?
 3576   **    $db update_hook ?script?
 3577   **    $db rollback_hook ?script?
 3578   */
 3579   case DB_WAL_HOOK:
 3580   case DB_UPDATE_HOOK:
 3581   case DB_ROLLBACK_HOOK: {
 3582     /* set ppHook to point at pUpdateHook or pRollbackHook, depending on
 3583     ** whether [$db update_hook] or [$db rollback_hook] was invoked.
 3584     */
 3585     Tcl_Obj **ppHook = 0;
 3586     if( choice==DB_WAL_HOOK ) ppHook = &pDb->pWalHook;
 3587     if( choice==DB_UPDATE_HOOK ) ppHook = &pDb->pUpdateHook;
 3588     if( choice==DB_ROLLBACK_HOOK ) ppHook = &pDb->pRollbackHook;
 3589     if( objc>3 ){
 3590        Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
 3591        return TCL_ERROR;
 3592     }
 3593 
 3594     DbHookCmd(interp, pDb, (objc==3 ? objv[2] : 0), ppHook);
 3595     break;
 3596   }
 3597 
 3598   /*    $db version
 3599   **
 3600   ** Return the version string for this database.
 3601   */
 3602   case DB_VERSION: {
 3603     int i;
 3604     for(i=2; i<objc; i++){
 3605       const char *zArg = Tcl_GetString(objv[i]);
 3606       /* Optional arguments to $db version are used for testing purpose */
 3607 #ifdef SQLITE_TEST
 3608       /* $db version -use-legacy-prepare BOOLEAN
 3609       **
 3610       ** Turn the use of legacy sqlite3_prepare() on or off.
 3611       */
 3612       if( strcmp(zArg, "-use-legacy-prepare")==0 && i+1<objc ){
 3613         i++;
 3614         if( Tcl_GetBooleanFromObj(interp, objv[i], &pDb->bLegacyPrepare) ){
 3615           return TCL_ERROR;
 3616         }
 3617       }else
 3618 
 3619       /* $db version -last-stmt-ptr
 3620       **
 3621       ** Return a string which is a hex encoding of the pointer to the
 3622       ** most recent sqlite3_stmt in the statement cache.
 3623       */
 3624       if( strcmp(zArg, "-last-stmt-ptr")==0 ){
 3625         char zBuf[100];
 3626         sqlite3_snprintf(sizeof(zBuf), zBuf, "%p",
 3627                          pDb->stmtList ? pDb->stmtList->pStmt: 0);
 3628         Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
 3629       }else
 3630 #endif /* SQLITE_TEST */
 3631       {
 3632         Tcl_AppendResult(interp, "unknown argument: ", zArg, (char*)0);
 3633         return TCL_ERROR;
 3634       }
 3635     }
 3636     if( i==2 ){   
 3637       Tcl_SetResult(interp, (char *)sqlite3_libversion(), TCL_STATIC);
 3638     }
 3639     break;
 3640   }
 3641 
 3642 
 3643   } /* End of the SWITCH statement */
 3644   return rc;
 3645 }
 3646 
 3647 #if SQLITE_TCL_NRE
 3648 /*
 3649 ** Adaptor that provides an objCmd interface to the NRE-enabled
 3650 ** interface implementation.
 3651 */
 3652 static int SQLITE_TCLAPI DbObjCmdAdaptor(
 3653   void *cd,
 3654   Tcl_Interp *interp,
 3655   int objc,
 3656   Tcl_Obj *const*objv
 3657 ){
 3658   return Tcl_NRCallObjProc(interp, DbObjCmd, cd, objc, objv);
 3659 }
 3660 #endif /* SQLITE_TCL_NRE */
 3661 
 3662 /*
 3663 ** Issue the usage message when the "sqlite3" command arguments are
 3664 ** incorrect.
 3665 */
 3666 static int sqliteCmdUsage(
 3667   Tcl_Interp *interp,
 3668   Tcl_Obj *const*objv
 3669 ){
 3670   Tcl_WrongNumArgs(interp, 1, objv,
 3671     "HANDLE ?FILENAME? ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"
 3672     " ?-nofollow BOOLEAN?"
 3673     " ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN? ?-uri BOOLEAN?"
 3674   );
 3675   return TCL_ERROR;
 3676 }
 3677 
 3678 /*
 3679 **   sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?
 3680 **                           ?-create BOOLEAN? ?-nomutex BOOLEAN?
 3681 **                           ?-nofollow BOOLEAN?
 3682 **
 3683 ** This is the main Tcl command.  When the "sqlite" Tcl command is
 3684 ** invoked, this routine runs to process that command.
 3685 **
 3686 ** The first argument, DBNAME, is an arbitrary name for a new
 3687 ** database connection.  This command creates a new command named
 3688 ** DBNAME that is used to control that connection.  The database
 3689 ** connection is deleted when the DBNAME command is deleted.
 3690 **
 3691 ** The second argument is the name of the database file.
 3692 **
 3693 */
 3694 static int SQLITE_TCLAPI DbMain(
 3695   void *cd,
 3696   Tcl_Interp *interp,
 3697   int objc,
 3698   Tcl_Obj *const*objv
 3699 ){
 3700   SqliteDb *p;
 3701   const char *zArg;
 3702   char *zErrMsg;
 3703   int i;
 3704   const char *zFile = 0;
 3705   const char *zVfs = 0;
 3706   int flags;
 3707   int bTranslateFileName = 1;
 3708   Tcl_DString translatedFilename;
 3709   int rc;
 3710 
 3711   /* In normal use, each TCL interpreter runs in a single thread.  So
 3712   ** by default, we can turn off mutexing on SQLite database connections.
 3713   ** However, for testing purposes it is useful to have mutexes turned
 3714   ** on.  So, by default, mutexes default off.  But if compiled with
 3715   ** SQLITE_TCL_DEFAULT_FULLMUTEX then mutexes default on.
 3716   */
 3717 #ifdef SQLITE_TCL_DEFAULT_FULLMUTEX
 3718   flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
 3719 #else
 3720   flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX;
 3721 #endif
 3722 
 3723   if( objc==1 ) return sqliteCmdUsage(interp, objv);
 3724   if( objc==2 ){
 3725     zArg = Tcl_GetStringFromObj(objv[1], 0);
 3726     if( strcmp(zArg,"-version")==0 ){
 3727       Tcl_AppendResult(interp,sqlite3_libversion(), (char*)0);
 3728       return TCL_OK;
 3729     }
 3730     if( strcmp(zArg,"-sourceid")==0 ){
 3731       Tcl_AppendResult(interp,sqlite3_sourceid(), (char*)0);
 3732       return TCL_OK;
 3733     }
 3734     if( strcmp(zArg,"-has-codec")==0 ){
 3735       Tcl_AppendResult(interp,"0",(char*)0);
 3736       return TCL_OK;
 3737     }
 3738     if( zArg[0]=='-' ) return sqliteCmdUsage(interp, objv);
 3739   }
 3740   for(i=2; i<objc; i++){
 3741     zArg = Tcl_GetString(objv[i]);
 3742     if( zArg[0]!='-' ){
 3743       if( zFile!=0 ) return sqliteCmdUsage(interp, objv);
 3744       zFile = zArg;
 3745       continue;
 3746     }
 3747     if( i==objc-1 ) return sqliteCmdUsage(interp, objv);
 3748     i++;
 3749     if( strcmp(zArg,"-key")==0 ){
 3750       /* no-op */
 3751     }else if( strcmp(zArg, "-vfs")==0 ){
 3752       zVfs = Tcl_GetString(objv[i]);
 3753     }else if( strcmp(zArg, "-readonly")==0 ){
 3754       int b;
 3755       if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
 3756       if( b ){
 3757         flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
 3758         flags |= SQLITE_OPEN_READONLY;
 3759       }else{
 3760         flags &= ~SQLITE_OPEN_READONLY;
 3761         flags |= SQLITE_OPEN_READWRITE;
 3762       }
 3763     }else if( strcmp(zArg, "-create")==0 ){
 3764       int b;
 3765       if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
 3766       if( b && (flags & SQLITE_OPEN_READONLY)==0 ){
 3767         flags |= SQLITE_OPEN_CREATE;
 3768       }else{
 3769         flags &= ~SQLITE_OPEN_CREATE;
 3770       }
 3771     }else if( strcmp(zArg, "-nofollow")==0 ){
 3772       int b;
 3773       if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
 3774       if( b ){
 3775         flags |= SQLITE_OPEN_NOFOLLOW;
 3776       }else{
 3777         flags &= ~SQLITE_OPEN_NOFOLLOW;
 3778       }
 3779     }else if( strcmp(zArg, "-nomutex")==0 ){
 3780       int b;
 3781       if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
 3782       if( b ){
 3783         flags |= SQLITE_OPEN_NOMUTEX;
 3784         flags &= ~SQLITE_OPEN_FULLMUTEX;
 3785       }else{
 3786         flags &= ~SQLITE_OPEN_NOMUTEX;
 3787       }
 3788     }else if( strcmp(zArg, "-fullmutex")==0 ){
 3789       int b;
 3790       if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
 3791       if( b ){
 3792         flags |= SQLITE_OPEN_FULLMUTEX;
 3793         flags &= ~SQLITE_OPEN_NOMUTEX;
 3794       }else{
 3795         flags &= ~SQLITE_OPEN_FULLMUTEX;
 3796       }
 3797     }else if( strcmp(zArg, "-uri")==0 ){
 3798       int b;
 3799       if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
 3800       if( b ){
 3801         flags |= SQLITE_OPEN_URI;
 3802       }else{
 3803         flags &= ~SQLITE_OPEN_URI;
 3804       }
 3805     }else if( strcmp(zArg, "-translatefilename")==0 ){
 3806       if( Tcl_GetBooleanFromObj(interp, objv[i], &bTranslateFileName) ){
 3807         return TCL_ERROR;
 3808       }
 3809     }else{
 3810       Tcl_AppendResult(interp, "unknown option: ", zArg, (char*)0);
 3811       return TCL_ERROR;
 3812     }
 3813   }
 3814   zErrMsg = 0;
 3815   p = (SqliteDb*)Tcl_Alloc( sizeof(*p) );
 3816   memset(p, 0, sizeof(*p));
 3817   if( zFile==0 ) zFile = "";
 3818   if( bTranslateFileName ){
 3819     zFile = Tcl_TranslateFileName(interp, zFile, &translatedFilename);
 3820   }
 3821   rc = sqlite3_open_v2(zFile, &p->db, flags, zVfs);
 3822   if( bTranslateFileName ){
 3823     Tcl_DStringFree(&translatedFilename);
 3824   }
 3825   if( p->db ){
 3826     if( SQLITE_OK!=sqlite3_errcode(p->db) ){
 3827       zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));
 3828       sqlite3_close(p->db);
 3829       p->db = 0;
 3830     }
 3831   }else{
 3832     zErrMsg = sqlite3_mprintf("%s", sqlite3_errstr(rc));
 3833   }
 3834   if( p->db==0 ){
 3835     Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE);
 3836     Tcl_Free((char*)p);
 3837     sqlite3_free(zErrMsg);
 3838     return TCL_ERROR;
 3839   }
 3840   p->maxStmt = NUM_PREPARED_STMTS;
 3841   p->openFlags = flags & SQLITE_OPEN_URI;
 3842   p->interp = interp;
 3843   zArg = Tcl_GetStringFromObj(objv[1], 0);
 3844   if( DbUseNre() ){
 3845     Tcl_NRCreateCommand(interp, zArg, DbObjCmdAdaptor, DbObjCmd,
 3846                         (char*)p, DbDeleteCmd);
 3847   }else{
 3848     Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd);
 3849   }
 3850   return TCL_OK;
 3851 }
 3852 
 3853 /*
 3854 ** Provide a dummy Tcl_InitStubs if we are using this as a static
 3855 ** library.
 3856 */
 3857 #ifndef USE_TCL_STUBS
 3858 # undef  Tcl_InitStubs
 3859 # define Tcl_InitStubs(a,b,c) TCL_VERSION
 3860 #endif
 3861 
 3862 /*
 3863 ** Make sure we have a PACKAGE_VERSION macro defined.  This will be
 3864 ** defined automatically by the TEA makefile.  But other makefiles
 3865 ** do not define it.
 3866 */
 3867 #ifndef PACKAGE_VERSION
 3868 # define PACKAGE_VERSION SQLITE_VERSION
 3869 #endif
 3870 
 3871 /*
 3872 ** Initialize this module.
 3873 **
 3874 ** This Tcl module contains only a single new Tcl command named "sqlite".
 3875 ** (Hence there is no namespace.  There is no point in using a namespace
 3876 ** if the extension only supplies one new name!)  The "sqlite" command is
 3877 ** used to open a new SQLite database.  See the DbMain() routine above
 3878 ** for additional information.
 3879 **
 3880 ** The EXTERN macros are required by TCL in order to work on windows.
 3881 */
 3882 EXTERN int Sqlite3_Init(Tcl_Interp *interp){
 3883   int rc = Tcl_InitStubs(interp, "8.4", 0) ? TCL_OK : TCL_ERROR;
 3884   if( rc==TCL_OK ){
 3885     Tcl_CreateObjCommand(interp, "sqlite3", (Tcl_ObjCmdProc*)DbMain, 0, 0);
 3886 #ifndef SQLITE_3_SUFFIX_ONLY
 3887     /* The "sqlite" alias is undocumented.  It is here only to support
 3888     ** legacy scripts.  All new scripts should use only the "sqlite3"
 3889     ** command. */
 3890     Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0);
 3891 #endif
 3892     rc = Tcl_PkgProvide(interp, "sqlite3", PACKAGE_VERSION);
 3893   }
 3894   return rc;
 3895 }
 3896 EXTERN int Tclsqlite3_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
 3897 EXTERN int Sqlite3_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
 3898 EXTERN int Tclsqlite3_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
 3899 
 3900 /* Because it accesses the file-system and uses persistent state, SQLite
 3901 ** is not considered appropriate for safe interpreters.  Hence, we cause
 3902 ** the _SafeInit() interfaces return TCL_ERROR.
 3903 */
 3904 EXTERN int Sqlite3_SafeInit(Tcl_Interp *interp){ return TCL_ERROR; }
 3905 EXTERN int Sqlite3_SafeUnload(Tcl_Interp *interp, int flags){return TCL_ERROR;}
 3906 
 3907 
 3908 
 3909 #ifndef SQLITE_3_SUFFIX_ONLY
 3910 int Sqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
 3911 int Tclsqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
 3912 int Sqlite_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
 3913 int Tclsqlite_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
 3914 #endif
 3915 
 3916 /*
 3917 ** If the TCLSH macro is defined, add code to make a stand-alone program.
 3918 */
 3919 #if defined(TCLSH)
 3920 
 3921 /* This is the main routine for an ordinary TCL shell.  If there are
 3922 ** are arguments, run the first argument as a script.  Otherwise,
 3923 ** read TCL commands from standard input
 3924 */
 3925 static const char *tclsh_main_loop(void){
 3926   static const char zMainloop[] =
 3927     "if {[llength $argv]>=1} {\n"
 3928       "set argv0 [lindex $argv 0]\n"
 3929       "set argv [lrange $argv 1 end]\n"
 3930       "source $argv0\n"
 3931     "} else {\n"
 3932       "set line {}\n"
 3933       "while {![eof stdin]} {\n"
 3934         "if {$line!=\"\"} {\n"
 3935           "puts -nonewline \"> \"\n"
 3936         "} else {\n"
 3937           "puts -nonewline \"% \"\n"
 3938         "}\n"
 3939         "flush stdout\n"
 3940         "append line [gets stdin]\n"
 3941         "if {[info complete $line]} {\n"
 3942           "if {[catch {uplevel #0 $line} result]} {\n"
 3943             "puts stderr \"Error: $result\"\n"
 3944           "} elseif {$result!=\"\"} {\n"
 3945             "puts $result\n"
 3946           "}\n"
 3947           "set line {}\n"
 3948         "} else {\n"
 3949           "append line \\n\n"
 3950         "}\n"
 3951       "}\n"
 3952     "}\n"
 3953   ;
 3954   return zMainloop;
 3955 }
 3956 
 3957 #define TCLSH_MAIN main   /* Needed to fake out mktclapp */
 3958 int SQLITE_CDECL TCLSH_MAIN(int argc, char **argv){
 3959   Tcl_Interp *interp;
 3960   int i;
 3961   const char *zScript = 0;
 3962   char zArgc[32];
 3963 #if defined(TCLSH_INIT_PROC)
 3964   extern const char *TCLSH_INIT_PROC(Tcl_Interp*);
 3965 #endif
 3966 
 3967 #if !defined(_WIN32_WCE)
 3968   if( getenv("SQLITE_DEBUG_BREAK") ){
 3969     if( isatty(0) && isatty(2) ){
 3970       fprintf(stderr,
 3971           "attach debugger to process %d and press any key to continue.\n",
 3972           GETPID());
 3973       fgetc(stdin);
 3974     }else{
 3975 #if defined(_WIN32) || defined(WIN32)
 3976       DebugBreak();
 3977 #elif defined(SIGTRAP)
 3978       raise(SIGTRAP);
 3979 #endif
 3980     }
 3981   }
 3982 #endif
 3983 
 3984   /* Call sqlite3_shutdown() once before doing anything else. This is to
 3985   ** test that sqlite3_shutdown() can be safely called by a process before
 3986   ** sqlite3_initialize() is. */
 3987   sqlite3_shutdown();
 3988 
 3989   Tcl_FindExecutable(argv[0]);
 3990   Tcl_SetSystemEncoding(NULL, "utf-8");
 3991   interp = Tcl_CreateInterp();
 3992   Sqlite3_Init(interp);
 3993 
 3994   sqlite3_snprintf(sizeof(zArgc), zArgc, "%d", argc-1);
 3995   Tcl_SetVar(interp,"argc", zArgc, TCL_GLOBAL_ONLY);
 3996   Tcl_SetVar(interp,"argv0",argv[0],TCL_GLOBAL_ONLY);
 3997   Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY);
 3998   for(i=1; i<argc; i++){
 3999     Tcl_SetVar(interp, "argv", argv[i],
 4000         TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT | TCL_APPEND_VALUE);
 4001   }
 4002 #if defined(TCLSH_INIT_PROC)
 4003   zScript = TCLSH_INIT_PROC(interp);
 4004 #endif
 4005   if( zScript==0 ){
 4006     zScript = tclsh_main_loop();
 4007   }
 4008   if( Tcl_GlobalEval(interp, zScript)!=TCL_OK ){
 4009     const char *zInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
 4010     if( zInfo==0 ) zInfo = Tcl_GetStringResult(interp);
 4011     fprintf(stderr,"%s: %s\n", *argv, zInfo);
 4012     return 1;
 4013   }
 4014   return 0;
 4015 }
 4016 #endif /* TCLSH */