1 /*

     2 ** 2001 September 15

     3 **

     4 ** The author disclaims copyright to this source code.  In place of

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

     8 **    May you find forgiveness for yourself and forgive others.

     9 **    May you share freely, never taking more than you give.

    10 **

    11 *************************************************************************

    12 ** A TCL Interface to SQLite

    13 **

    14 ** $Id: tclsqlite.c,v 1.173 2006/09/02 14:17:00 drh Exp $

    15 */

    16 #ifndef NO_TCL     /* Omit this whole file if TCL is unavailable */

    17 

    18 #include "sqliteInt.h"

    19 #include "hash.h"

    20 #include "tcl.h"

    21 #include <stdlib.h>

    22 #include <string.h>

    23 #include <assert.h>

    24 #include <ctype.h>

    25 

    26 /*

    27  * Windows needs to know which symbols to export.  Unix does not.

    28  * BUILD_sqlite should be undefined for Unix.

    29  */

    30 #ifdef BUILD_sqlite

    31 #undef TCL_STORAGE_CLASS

    32 #define TCL_STORAGE_CLASS DLLEXPORT

    33 #endif /* BUILD_sqlite */

    34 

    35 #define NUM_PREPARED_STMTS 10

    36 #define MAX_PREPARED_STMTS 100

    37 

    38 /*

    39 ** If TCL uses UTF-8 and SQLite is configured to use iso8859, then we

    40 ** have to do a translation when going between the two.  Set the 

    41 ** UTF_TRANSLATION_NEEDED macro to indicate that we need to do

    42 ** this translation.  

    43 */

    44 #if defined(TCL_UTF_MAX) && !defined(SQLITE_UTF8)

    45 # define UTF_TRANSLATION_NEEDED 1

    46 #endif

    47 

    48 /*

    49 ** New SQL functions can be created as TCL scripts.  Each such function

    50 ** is described by an instance of the following structure.

    51 */

    52 typedef struct SqlFunc SqlFunc;

    53 struct SqlFunc {

    54   Tcl_Interp *interp;   /* The TCL interpret to execute the function */

    55   Tcl_Obj *pScript;     /* The Tcl_Obj representation of the script */

    56   int useEvalObjv;      /* True if it is safe to use Tcl_EvalObjv */

    57   char *zName;          /* Name of this function */

    58   SqlFunc *pNext;       /* Next function on the list of them all */

    59 };

    60 

    61 /*

    62 ** New collation sequences function can be created as TCL scripts.  Each such

    63 ** function is described by an instance of the following structure.

    64 */

    65 typedef struct SqlCollate SqlCollate;

    66 struct SqlCollate {

    67   Tcl_Interp *interp;   /* The TCL interpret to execute the function */

    68   char *zScript;        /* The script to be run */

    69   SqlCollate *pNext;    /* Next function on the list of them all */

    70 };

    71 

    72 /*

    73 ** Prepared statements are cached for faster execution.  Each prepared

    74 ** statement is described by an instance of the following structure.

    75 */

    76 typedef struct SqlPreparedStmt SqlPreparedStmt;

    77 struct SqlPreparedStmt {

    78   SqlPreparedStmt *pNext;  /* Next in linked list */

    79   SqlPreparedStmt *pPrev;  /* Previous on the list */

    80   sqlite3_stmt *pStmt;     /* The prepared statement */

    81   int nSql;                /* chars in zSql[] */

    82   char zSql[1];            /* Text of the SQL statement */

    83 };

    84 

    85 /*

    86 ** There is one instance of this structure for each SQLite database

    87 ** that has been opened by the SQLite TCL interface.

    88 */

    89 typedef struct SqliteDb SqliteDb;

    90 struct SqliteDb {

    91   sqlite3 *db;               /* The "real" database structure. MUST BE FIRST */

    92   Tcl_Interp *interp;        /* The interpreter used for this database */

    93   char *zBusy;               /* The busy callback routine */

    94   char *zCommit;             /* The commit hook callback routine */

    95   char *zTrace;              /* The trace callback routine */

    96   char *zProfile;            /* The profile callback routine */

    97   char *zProgress;           /* The progress callback routine */

    98   char *zAuth;               /* The authorization callback routine */

    99   char *zNull;               /* Text to substitute for an SQL NULL value */

   100   SqlFunc *pFunc;            /* List of SQL functions */

   101   Tcl_Obj *pUpdateHook;      /* Update hook script (if any) */

   102   Tcl_Obj *pRollbackHook;    /* Rollback hook script (if any) */

   103   SqlCollate *pCollate;      /* List of SQL collation functions */

   104   int rc;                    /* Return code of most recent sqlite3_exec() */

   105   Tcl_Obj *pCollateNeeded;   /* Collation needed script */

   106   SqlPreparedStmt *stmtList; /* List of prepared statements*/

   107   SqlPreparedStmt *stmtLast; /* Last statement in the list */

   108   int maxStmt;               /* The next maximum number of stmtList */

   109   int nStmt;                 /* Number of statements in stmtList */

   110 };

   111 

   112 /*

   113 ** Look at the script prefix in pCmd.  We will be executing this script

   114 ** after first appending one or more arguments.  This routine analyzes

   115 ** the script to see if it is safe to use Tcl_EvalObjv() on the script

   116 ** rather than the more general Tcl_EvalEx().  Tcl_EvalObjv() is much

   117 ** faster.

   118 **

   119 ** Scripts that are safe to use with Tcl_EvalObjv() consists of a

   120 ** command name followed by zero or more arguments with no [...] or $

   121 ** or {...} or ; to be seen anywhere.  Most callback scripts consist

   122 ** of just a single procedure name and they meet this requirement.

   123 */

   124 static int safeToUseEvalObjv(Tcl_Interp *interp, Tcl_Obj *pCmd){

   125   /* We could try to do something with Tcl_Parse().  But we will instead

   126   ** just do a search for forbidden characters.  If any of the forbidden

   127   ** characters appear in pCmd, we will report the string as unsafe.

   128   */

   129   const char *z;

   130   int n;

   131   z = Tcl_GetStringFromObj(pCmd, &n);

   132   while( n-- > 0 ){

   133     int c = *(z++);

   134     if( c=='$' || c=='[' || c==';' ) return 0;

   135   }

   136   return 1;

   137 }

   138 

   139 /*

   140 ** Find an SqlFunc structure with the given name.  Or create a new

   141 ** one if an existing one cannot be found.  Return a pointer to the

   142 ** structure.

   143 */

   144 static SqlFunc *findSqlFunc(SqliteDb *pDb, const char *zName){

   145   SqlFunc *p, *pNew;

   146   int i;

   147   pNew = (SqlFunc*)Tcl_Alloc( sizeof(*pNew) + strlen(zName) + 1 );

   148   pNew->zName = (char*)&pNew[1];

   149   for(i=0; zName[i]; i++){ pNew->zName[i] = tolower(zName[i]); }

   150   pNew->zName[i] = 0;

   151   for(p=pDb->pFunc; p; p=p->pNext){ 

   152     if( strcmp(p->zName, pNew->zName)==0 ){

   153       Tcl_Free((char*)pNew);

   154       return p;

   155     }

   156   }

   157   pNew->interp = pDb->interp;

   158   pNew->pScript = 0;

   159   pNew->pNext = pDb->pFunc;

   160   pDb->pFunc = pNew;

   161   return pNew;

   162 }

   163 

   164 /*

   165 ** Finalize and free a list of prepared statements

   166 */

   167 static void flushStmtCache( SqliteDb *pDb ){

   168   SqlPreparedStmt *pPreStmt;

   169 

   170   while(  pDb->stmtList ){

   171     sqlite3_finalize( pDb->stmtList->pStmt );

   172     pPreStmt = pDb->stmtList;

   173     pDb->stmtList = pDb->stmtList->pNext;

   174     Tcl_Free( (char*)pPreStmt );

   175   }

   176   pDb->nStmt = 0;

   177   pDb->stmtLast = 0;

   178 }

   179 

   180 /*

   181 ** TCL calls this procedure when an sqlite3 database command is

   182 ** deleted.

   183 */

   184 static void DbDeleteCmd(void *db){

   185   SqliteDb *pDb = (SqliteDb*)db;

   186   flushStmtCache(pDb);

   187   sqlite3_close(pDb->db);

   188   while( pDb->pFunc ){

   189     SqlFunc *pFunc = pDb->pFunc;

   190     pDb->pFunc = pFunc->pNext;

   191     Tcl_DecrRefCount(pFunc->pScript);

   192     Tcl_Free((char*)pFunc);

   193   }

   194   while( pDb->pCollate ){

   195     SqlCollate *pCollate = pDb->pCollate;

   196     pDb->pCollate = pCollate->pNext;

   197     Tcl_Free((char*)pCollate);

   198   }

   199   if( pDb->zBusy ){

   200     Tcl_Free(pDb->zBusy);

   201   }

   202   if( pDb->zTrace ){

   203     Tcl_Free(pDb->zTrace);

   204   }

   205   if( pDb->zProfile ){

   206     Tcl_Free(pDb->zProfile);

   207   }

   208   if( pDb->zAuth ){

   209     Tcl_Free(pDb->zAuth);

   210   }

   211   if( pDb->zNull ){

   212     Tcl_Free(pDb->zNull);

   213   }

   214   if( pDb->pUpdateHook ){

   215     Tcl_DecrRefCount(pDb->pUpdateHook);

   216   }

   217   if( pDb->pRollbackHook ){

   218     Tcl_DecrRefCount(pDb->pRollbackHook);

   219   }

   220   if( pDb->pCollateNeeded ){

   221     Tcl_DecrRefCount(pDb->pCollateNeeded);

   222   }

   223   Tcl_Free((char*)pDb);

   224 }

   225 

   226 /*

   227 ** This routine is called when a database file is locked while trying

   228 ** to execute SQL.

   229 */

   230 static int DbBusyHandler(void *cd, int nTries){

   231   SqliteDb *pDb = (SqliteDb*)cd;

   232   int rc;

   233   char zVal[30];

   234 

   235   sprintf(zVal, "%d", nTries);

   236   rc = Tcl_VarEval(pDb->interp, pDb->zBusy, " ", zVal, (char*)0);

   237   if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){

   238     return 0;

   239   }

   240   return 1;

   241 }

   242 

   243 /*

   244 ** This routine is invoked as the 'progress callback' for the database.

   245 */

   246 static int DbProgressHandler(void *cd){

   247   SqliteDb *pDb = (SqliteDb*)cd;

   248   int rc;

   249 

   250   assert( pDb->zProgress );

   251   rc = Tcl_Eval(pDb->interp, pDb->zProgress);

   252   if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){

   253     return 1;

   254   }

   255   return 0;

   256 }

   257 

   258 #ifndef SQLITE_OMIT_TRACE

   259 /*

   260 ** This routine is called by the SQLite trace handler whenever a new

   261 ** block of SQL is executed.  The TCL script in pDb->zTrace is executed.

   262 */

   263 static void DbTraceHandler(void *cd, const char *zSql){

   264   SqliteDb *pDb = (SqliteDb*)cd;

   265   Tcl_DString str;

   266 

   267   Tcl_DStringInit(&str);

   268   Tcl_DStringAppend(&str, pDb->zTrace, -1);

   269   Tcl_DStringAppendElement(&str, zSql);

   270   Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));

   271   Tcl_DStringFree(&str);

   272   Tcl_ResetResult(pDb->interp);

   273 }

   274 #endif

   275 

   276 #ifndef SQLITE_OMIT_TRACE

   277 /*

   278 ** This routine is called by the SQLite profile handler after a statement

   279 ** SQL has executed.  The TCL script in pDb->zProfile is evaluated.

   280 */

   281 static void DbProfileHandler(void *cd, const char *zSql, sqlite_uint64 tm){

   282   SqliteDb *pDb = (SqliteDb*)cd;

   283   Tcl_DString str;

   284   char zTm[100];

   285 

   286   sqlite3_snprintf(sizeof(zTm)-1, zTm, "%lld", tm);

   287   Tcl_DStringInit(&str);

   288   Tcl_DStringAppend(&str, pDb->zProfile, -1);

   289   Tcl_DStringAppendElement(&str, zSql);

   290   Tcl_DStringAppendElement(&str, zTm);

   291   Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));

   292   Tcl_DStringFree(&str);

   293   Tcl_ResetResult(pDb->interp);

   294 }

   295 #endif

   296 

   297 /*

   298 ** This routine is called when a transaction is committed.  The

   299 ** TCL script in pDb->zCommit is executed.  If it returns non-zero or

   300 ** if it throws an exception, the transaction is rolled back instead

   301 ** of being committed.

   302 */

   303 static int DbCommitHandler(void *cd){

   304   SqliteDb *pDb = (SqliteDb*)cd;

   305   int rc;

   306 

   307   rc = Tcl_Eval(pDb->interp, pDb->zCommit);

   308   if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){

   309     return 1;

   310   }

   311   return 0;

   312 }

   313 

   314 static void DbRollbackHandler(void *clientData){

   315   SqliteDb *pDb = (SqliteDb*)clientData;

   316   assert(pDb->pRollbackHook);

   317   if( TCL_OK!=Tcl_EvalObjEx(pDb->interp, pDb->pRollbackHook, 0) ){

   318     Tcl_BackgroundError(pDb->interp);

   319   }

   320 }

   321 

   322 static void DbUpdateHandler(

   323   void *p, 

   324   int op,

   325   const char *zDb, 

   326   const char *zTbl, 

   327   sqlite_int64 rowid

   328 ){

   329   SqliteDb *pDb = (SqliteDb *)p;

   330   Tcl_Obj *pCmd;

   331 

   332   assert( pDb->pUpdateHook );

   333   assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );

   334 

   335   pCmd = Tcl_DuplicateObj(pDb->pUpdateHook);

   336   Tcl_IncrRefCount(pCmd);

   337   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(

   338     ( (op==SQLITE_INSERT)?"INSERT":(op==SQLITE_UPDATE)?"UPDATE":"DELETE"), -1));

   339   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));

   340   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));

   341   Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(rowid));

   342   Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);

   343 }

   344 

   345 static void tclCollateNeeded(

   346   void *pCtx,

   347   sqlite3 *db,

   348   int enc,

   349   const char *zName

   350 ){

   351   SqliteDb *pDb = (SqliteDb *)pCtx;

   352   Tcl_Obj *pScript = Tcl_DuplicateObj(pDb->pCollateNeeded);

   353   Tcl_IncrRefCount(pScript);

   354   Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(zName, -1));

   355   Tcl_EvalObjEx(pDb->interp, pScript, 0);

   356   Tcl_DecrRefCount(pScript);

   357 }

   358 

   359 /*

   360 ** This routine is called to evaluate an SQL collation function implemented

   361 ** using TCL script.

   362 */

   363 static int tclSqlCollate(

   364   void *pCtx,

   365   int nA,

   366   const void *zA,

   367   int nB,

   368   const void *zB

   369 ){

   370   SqlCollate *p = (SqlCollate *)pCtx;

   371   Tcl_Obj *pCmd;

   372 

   373   pCmd = Tcl_NewStringObj(p->zScript, -1);

   374   Tcl_IncrRefCount(pCmd);

   375   Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zA, nA));

   376   Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zB, nB));

   377   Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);

   378   Tcl_DecrRefCount(pCmd);

   379   return (atoi(Tcl_GetStringResult(p->interp)));

   380 }

   381 

   382 /*

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

   384 ** using TCL script.

   385 */

   386 static void tclSqlFunc(sqlite3_context *context, int argc, sqlite3_value**argv){

   387   SqlFunc *p = sqlite3_user_data(context);

   388   Tcl_Obj *pCmd;

   389   int i;

   390   int rc;

   391 

   392   if( argc==0 ){

   393     /* If there are no arguments to the function, call Tcl_EvalObjEx on the

   394     ** script object directly.  This allows the TCL compiler to generate

   395     ** bytecode for the command on the first invocation and thus make

   396     ** subsequent invocations much faster. */

   397     pCmd = p->pScript;

   398     Tcl_IncrRefCount(pCmd);

   399     rc = Tcl_EvalObjEx(p->interp, pCmd, 0);

   400     Tcl_DecrRefCount(pCmd);

   401   }else{

   402     /* If there are arguments to the function, make a shallow copy of the

   403     ** script object, lappend the arguments, then evaluate the copy.

   404     **

   405     ** By "shallow" copy, we mean a only the outer list Tcl_Obj is duplicated.

   406     ** The new Tcl_Obj contains pointers to the original list elements. 

   407     ** That way, when Tcl_EvalObjv() is run and shimmers the first element

   408     ** of the list to tclCmdNameType, that alternate representation will

   409     ** be preserved and reused on the next invocation.

   410     */

   411     Tcl_Obj **aArg;

   412     int nArg;

   413     if( Tcl_ListObjGetElements(p->interp, p->pScript, &nArg, &aArg) ){

   414       sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1); 

   415       return;

   416     }     

   417     pCmd = Tcl_NewListObj(nArg, aArg);

   418     Tcl_IncrRefCount(pCmd);

   419     for(i=0; i<argc; i++){

   420       sqlite3_value *pIn = argv[i];

   421       Tcl_Obj *pVal;

   422             

   423       /* Set pVal to contain the i'th column of this row. */

   424       switch( sqlite3_value_type(pIn) ){

   425         case SQLITE_BLOB: {

   426           int bytes = sqlite3_value_bytes(pIn);

   427           pVal = Tcl_NewByteArrayObj(sqlite3_value_blob(pIn), bytes);

   428           break;

   429         }

   430         case SQLITE_INTEGER: {

   431           sqlite_int64 v = sqlite3_value_int64(pIn);

   432           if( v>=-2147483647 && v<=2147483647 ){

   433             pVal = Tcl_NewIntObj(v);

   434           }else{

   435             pVal = Tcl_NewWideIntObj(v);

   436           }

   437           break;

   438         }

   439         case SQLITE_FLOAT: {

   440           double r = sqlite3_value_double(pIn);

   441           pVal = Tcl_NewDoubleObj(r);

   442           break;

   443         }

   444         case SQLITE_NULL: {

   445           pVal = Tcl_NewStringObj("", 0);

   446           break;

   447         }

   448         default: {

   449           int bytes = sqlite3_value_bytes(pIn);

   450           pVal = Tcl_NewStringObj((char *)sqlite3_value_text(pIn), bytes);

   451           break;

   452         }

   453       }

   454       rc = Tcl_ListObjAppendElement(p->interp, pCmd, pVal);

   455       if( rc ){

   456         Tcl_DecrRefCount(pCmd);

   457         sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1); 

   458         return;

   459       }

   460     }

   461     if( !p->useEvalObjv ){

   462       /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd

   463       ** is a list without a string representation.  To prevent this from

   464       ** happening, make sure pCmd has a valid string representation */

   465       Tcl_GetString(pCmd);

   466     }

   467     rc = Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);

   468     Tcl_DecrRefCount(pCmd);

   469   }

   470 

   471   if( rc && rc!=TCL_RETURN ){

   472     sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1); 

   473   }else{

   474     Tcl_Obj *pVar = Tcl_GetObjResult(p->interp);

   475     int n;

   476     u8 *data;

   477     char *zType = pVar->typePtr ? pVar->typePtr->name : "";

   478     char c = zType[0];

   479     if( c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0 ){

   480       /* Only return a BLOB type if the Tcl variable is a bytearray and

   481       ** has no string representation. */

   482       data = Tcl_GetByteArrayFromObj(pVar, &n);

   483       sqlite3_result_blob(context, data, n, SQLITE_TRANSIENT);

   484     }else if( (c=='b' && strcmp(zType,"boolean")==0) ||

   485           (c=='i' && strcmp(zType,"int")==0) ){

   486       Tcl_GetIntFromObj(0, pVar, &n);

   487       sqlite3_result_int(context, n);

   488     }else if( c=='d' && strcmp(zType,"double")==0 ){

   489       double r;

   490       Tcl_GetDoubleFromObj(0, pVar, &r);

   491       sqlite3_result_double(context, r);

   492     }else if( c=='w' && strcmp(zType,"wideInt")==0 ){

   493       Tcl_WideInt v;

   494       Tcl_GetWideIntFromObj(0, pVar, &v);

   495       sqlite3_result_int64(context, v);

   496     }else{

   497       data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);

   498       sqlite3_result_text(context, (char *)data, n, SQLITE_TRANSIENT);

   499     }

   500   }

   501 }

   502 

   503 #ifndef SQLITE_OMIT_AUTHORIZATION

   504 /*

   505 ** This is the authentication function.  It appends the authentication

   506 ** type code and the two arguments to zCmd[] then invokes the result

   507 ** on the interpreter.  The reply is examined to determine if the

   508 ** authentication fails or succeeds.

   509 */

   510 static int auth_callback(

   511   void *pArg,

   512   int code,

   513   const char *zArg1,

   514   const char *zArg2,

   515   const char *zArg3,

   516   const char *zArg4

   517 ){

   518   char *zCode;

   519   Tcl_DString str;

   520   int rc;

   521   const char *zReply;

   522   SqliteDb *pDb = (SqliteDb*)pArg;

   523 

   524   switch( code ){

   525     case SQLITE_COPY              : zCode="SQLITE_COPY"; break;

   526     case SQLITE_CREATE_INDEX      : zCode="SQLITE_CREATE_INDEX"; break;

   527     case SQLITE_CREATE_TABLE      : zCode="SQLITE_CREATE_TABLE"; break;

   528     case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break;

   529     case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break;

   530     case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break;

   531     case SQLITE_CREATE_TEMP_VIEW  : zCode="SQLITE_CREATE_TEMP_VIEW"; break;

   532     case SQLITE_CREATE_TRIGGER    : zCode="SQLITE_CREATE_TRIGGER"; break;

   533     case SQLITE_CREATE_VIEW       : zCode="SQLITE_CREATE_VIEW"; break;

   534     case SQLITE_DELETE            : zCode="SQLITE_DELETE"; break;

   535     case SQLITE_DROP_INDEX        : zCode="SQLITE_DROP_INDEX"; break;

   536     case SQLITE_DROP_TABLE        : zCode="SQLITE_DROP_TABLE"; break;

   537     case SQLITE_DROP_TEMP_INDEX   : zCode="SQLITE_DROP_TEMP_INDEX"; break;

   538     case SQLITE_DROP_TEMP_TABLE   : zCode="SQLITE_DROP_TEMP_TABLE"; break;

   539     case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break;

   540     case SQLITE_DROP_TEMP_VIEW    : zCode="SQLITE_DROP_TEMP_VIEW"; break;

   541     case SQLITE_DROP_TRIGGER      : zCode="SQLITE_DROP_TRIGGER"; break;

   542     case SQLITE_DROP_VIEW         : zCode="SQLITE_DROP_VIEW"; break;

   543     case SQLITE_INSERT            : zCode="SQLITE_INSERT"; break;

   544     case SQLITE_PRAGMA            : zCode="SQLITE_PRAGMA"; break;

   545     case SQLITE_READ              : zCode="SQLITE_READ"; break;

   546     case SQLITE_SELECT            : zCode="SQLITE_SELECT"; break;

   547     case SQLITE_TRANSACTION       : zCode="SQLITE_TRANSACTION"; break;

   548     case SQLITE_UPDATE            : zCode="SQLITE_UPDATE"; break;

   549     case SQLITE_ATTACH            : zCode="SQLITE_ATTACH"; break;

   550     case SQLITE_DETACH            : zCode="SQLITE_DETACH"; break;

   551     case SQLITE_ALTER_TABLE       : zCode="SQLITE_ALTER_TABLE"; break;

   552     case SQLITE_REINDEX           : zCode="SQLITE_REINDEX"; break;

   553     case SQLITE_ANALYZE           : zCode="SQLITE_ANALYZE"; break;

   554     case SQLITE_CREATE_VTABLE     : zCode="SQLITE_CREATE_VTABLE"; break;

   555     case SQLITE_DROP_VTABLE       : zCode="SQLITE_DROP_VTABLE"; break;

   556     case SQLITE_FUNCTION          : zCode="SQLITE_FUNCTION"; break;

   557     default                       : zCode="????"; break;

   558   }

   559   Tcl_DStringInit(&str);

   560   Tcl_DStringAppend(&str, pDb->zAuth, -1);

   561   Tcl_DStringAppendElement(&str, zCode);

   562   Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");

   563   Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");

   564   Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");

   565   Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");

   566   rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str));

   567   Tcl_DStringFree(&str);

   568   zReply = Tcl_GetStringResult(pDb->interp);

   569   if( strcmp(zReply,"SQLITE_OK")==0 ){

   570     rc = SQLITE_OK;

   571   }else if( strcmp(zReply,"SQLITE_DENY")==0 ){

   572     rc = SQLITE_DENY;

   573   }else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){

   574     rc = SQLITE_IGNORE;

   575   }else{

   576     rc = 999;

   577   }

   578   return rc;

   579 }

   580 #endif /* SQLITE_OMIT_AUTHORIZATION */

   581 

   582 /*

   583 ** zText is a pointer to text obtained via an sqlite3_result_text()

   584 ** or similar interface. This routine returns a Tcl string object, 

   585 ** reference count set to 0, containing the text. If a translation

   586 ** between iso8859 and UTF-8 is required, it is preformed.

   587 */

   588 static Tcl_Obj *dbTextToObj(char const *zText){

   589   Tcl_Obj *pVal;

   590 #ifdef UTF_TRANSLATION_NEEDED

   591   Tcl_DString dCol;

   592   Tcl_DStringInit(&dCol);

   593   Tcl_ExternalToUtfDString(NULL, zText, -1, &dCol);

   594   pVal = Tcl_NewStringObj(Tcl_DStringValue(&dCol), -1);

   595   Tcl_DStringFree(&dCol);

   596 #else

   597   pVal = Tcl_NewStringObj(zText, -1);

   598 #endif

   599   return pVal;

   600 }

   601 

   602 /*

   603 ** This routine reads a line of text from FILE in, stores

   604 ** the text in memory obtained from malloc() and returns a pointer

   605 ** to the text.  NULL is returned at end of file, or if malloc()

   606 ** fails.

   607 **

   608 ** The interface is like "readline" but no command-line editing

   609 ** is done.

   610 **

   611 ** copied from shell.c from '.import' command

   612 */

   613 static char *local_getline(char *zPrompt, FILE *in){

   614   char *zLine;

   615   int nLine;

   616   int n;

   617   int eol;

   618 

   619   nLine = 100;

   620   zLine = malloc( nLine );

   621   if( zLine==0 ) return 0;

   622   n = 0;

   623   eol = 0;

   624   while( !eol ){

   625     if( n+100>nLine ){

   626       nLine = nLine*2 + 100;

   627       zLine = realloc(zLine, nLine);

   628       if( zLine==0 ) return 0;

   629     }

   630     if( fgets(&zLine[n], nLine - n, in)==0 ){

   631       if( n==0 ){

   632         free(zLine);

   633         return 0;

   634       }

   635       zLine[n] = 0;

   636       eol = 1;

   637       break;

   638     }

   639     while( zLine[n] ){ n++; }

   640     if( n>0 && zLine[n-1]=='\n' ){

   641       n--;

   642       zLine[n] = 0;

   643       eol = 1;

   644     }

   645   }

   646   zLine = realloc( zLine, n+1 );

   647   return zLine;

   648 }

   649 

   650 /*

   651 ** The "sqlite" command below creates a new Tcl command for each

   652 ** connection it opens to an SQLite database.  This routine is invoked

   653 ** whenever one of those connection-specific commands is executed

   654 ** in Tcl.  For example, if you run Tcl code like this:

   655 **

   656 **       sqlite3 db1  "my_database"

   657 **       db1 close

   658 **

   659 ** The first command opens a connection to the "my_database" database

   660 ** and calls that connection "db1".  The second command causes this

   661 ** subroutine to be invoked.

   662 */

   663 static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){

   664   SqliteDb *pDb = (SqliteDb*)cd;

   665   int choice;

   666   int rc = TCL_OK;

   667   static const char *DB_strs[] = {

   668     "authorizer",         "busy",              "cache",

   669     "changes",            "close",             "collate",

   670     "collation_needed",   "commit_hook",       "complete",

   671     "copy",               "enable_load_extension","errorcode",

   672     "eval",               "exists",            "function",

   673     "interrupt",          "last_insert_rowid", "nullvalue",

   674     "onecolumn",          "profile",           "progress",

   675     "rekey",              "rollback_hook",     "timeout",

   676     "total_changes",      "trace",             "transaction",

   677     "update_hook",        "version",           0

   678   };

   679   enum DB_enum {

   680     DB_AUTHORIZER,        DB_BUSY,             DB_CACHE,

   681     DB_CHANGES,           DB_CLOSE,            DB_COLLATE,

   682     DB_COLLATION_NEEDED,  DB_COMMIT_HOOK,      DB_COMPLETE,

   683     DB_COPY,              DB_ENABLE_LOAD_EXTENSION,DB_ERRORCODE,

   684     DB_EVAL,              DB_EXISTS,           DB_FUNCTION,

   685     DB_INTERRUPT,         DB_LAST_INSERT_ROWID,DB_NULLVALUE,

   686     DB_ONECOLUMN,         DB_PROFILE,          DB_PROGRESS,

   687     DB_REKEY,             DB_ROLLBACK_HOOK,    DB_TIMEOUT,

   688     DB_TOTAL_CHANGES,     DB_TRACE,            DB_TRANSACTION,

   689     DB_UPDATE_HOOK,       DB_VERSION,          

   690   };

   691   /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */

   692 

   693   if( objc<2 ){

   694     Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");

   695     return TCL_ERROR;

   696   }

   697   if( Tcl_GetIndexFromObj(interp, objv[1], DB_strs, "option", 0, &choice) ){

   698     return TCL_ERROR;

   699   }

   700 

   701   switch( (enum DB_enum)choice ){

   702 

   703   /*    $db authorizer ?CALLBACK?

   704   **

   705   ** Invoke the given callback to authorize each SQL operation as it is

   706   ** compiled.  5 arguments are appended to the callback before it is

   707   ** invoked:

   708   **

   709   **   (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)

   710   **   (2) First descriptive name (depends on authorization type)

   711   **   (3) Second descriptive name

   712   **   (4) Name of the database (ex: "main", "temp")

   713   **   (5) Name of trigger that is doing the access

   714   **

   715   ** The callback should return on of the following strings: SQLITE_OK,

   716   ** SQLITE_IGNORE, or SQLITE_DENY.  Any other return value is an error.

   717   **

   718   ** If this method is invoked with no arguments, the current authorization

   719   ** callback string is returned.

   720   */

   721   case DB_AUTHORIZER: {

   722 #ifdef SQLITE_OMIT_AUTHORIZATION

   723     Tcl_AppendResult(interp, "authorization not available in this build", 0);

   724     return TCL_ERROR;

   725 #else

   726     if( objc>3 ){

   727       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");

   728       return TCL_ERROR;

   729     }else if( objc==2 ){

   730       if( pDb->zAuth ){

   731         Tcl_AppendResult(interp, pDb->zAuth, 0);

   732       }

   733     }else{

   734       char *zAuth;

   735       int len;

   736       if( pDb->zAuth ){

   737         Tcl_Free(pDb->zAuth);

   738       }

   739       zAuth = Tcl_GetStringFromObj(objv[2], &len);

   740       if( zAuth && len>0 ){

   741         pDb->zAuth = Tcl_Alloc( len + 1 );

   742         strcpy(pDb->zAuth, zAuth);

   743       }else{

   744         pDb->zAuth = 0;

   745       }

   746       if( pDb->zAuth ){

   747         pDb->interp = interp;

   748         sqlite3_set_authorizer(pDb->db, auth_callback, pDb);

   749       }else{

   750         sqlite3_set_authorizer(pDb->db, 0, 0);

   751       }

   752     }

   753 #endif

   754     break;

   755   }

   756 

   757   /*    $db busy ?CALLBACK?

   758   **

   759   ** Invoke the given callback if an SQL statement attempts to open

   760   ** a locked database file.

   761   */

   762   case DB_BUSY: {

   763     if( objc>3 ){

   764       Tcl_WrongNumArgs(interp, 2, objv, "CALLBACK");

   765       return TCL_ERROR;

   766     }else if( objc==2 ){

   767       if( pDb->zBusy ){

   768         Tcl_AppendResult(interp, pDb->zBusy, 0);

   769       }

   770     }else{

   771       char *zBusy;

   772       int len;

   773       if( pDb->zBusy ){

   774         Tcl_Free(pDb->zBusy);

   775       }

   776       zBusy = Tcl_GetStringFromObj(objv[2], &len);

   777       if( zBusy && len>0 ){

   778         pDb->zBusy = Tcl_Alloc( len + 1 );

   779         strcpy(pDb->zBusy, zBusy);

   780       }else{

   781         pDb->zBusy = 0;

   782       }

   783       if( pDb->zBusy ){

   784         pDb->interp = interp;

   785         sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb);

   786       }else{

   787         sqlite3_busy_handler(pDb->db, 0, 0);

   788       }

   789     }

   790     break;

   791   }

   792 

   793   /*     $db cache flush

   794   **     $db cache size n

   795   **

   796   ** Flush the prepared statement cache, or set the maximum number of

   797   ** cached statements.

   798   */

   799   case DB_CACHE: {

   800     char *subCmd;

   801     int n;

   802 

   803     if( objc<=2 ){

   804       Tcl_WrongNumArgs(interp, 1, objv, "cache option ?arg?");

   805       return TCL_ERROR;

   806     }

   807     subCmd = Tcl_GetStringFromObj( objv[2], 0 );

   808     if( *subCmd=='f' && strcmp(subCmd,"flush")==0 ){

   809       if( objc!=3 ){

   810         Tcl_WrongNumArgs(interp, 2, objv, "flush");

   811         return TCL_ERROR;

   812       }else{

   813         flushStmtCache( pDb );

   814       }

   815     }else if( *subCmd=='s' && strcmp(subCmd,"size")==0 ){

   816       if( objc!=4 ){

   817         Tcl_WrongNumArgs(interp, 2, objv, "size n");

   818         return TCL_ERROR;

   819       }else{

   820         if( TCL_ERROR==Tcl_GetIntFromObj(interp, objv[3], &n) ){

   821           Tcl_AppendResult( interp, "cannot convert \"", 

   822                Tcl_GetStringFromObj(objv[3],0), "\" to integer", 0);

   823           return TCL_ERROR;

   824         }else{

   825           if( n<0 ){

   826             flushStmtCache( pDb );

   827             n = 0;

   828           }else if( n>MAX_PREPARED_STMTS ){

   829             n = MAX_PREPARED_STMTS;

   830           }

   831           pDb->maxStmt = n;

   832         }

   833       }

   834     }else{

   835       Tcl_AppendResult( interp, "bad option \"", 

   836           Tcl_GetStringFromObj(objv[0],0), "\": must be flush or size", 0);

   837       return TCL_ERROR;

   838     }

   839     break;

   840   }

   841 

   842   /*     $db changes

   843   **

   844   ** Return the number of rows that were modified, inserted, or deleted by

   845   ** the most recent INSERT, UPDATE or DELETE statement, not including 

   846   ** any changes made by trigger programs.

   847   */

   848   case DB_CHANGES: {

   849     Tcl_Obj *pResult;

   850     if( objc!=2 ){

   851       Tcl_WrongNumArgs(interp, 2, objv, "");

   852       return TCL_ERROR;

   853     }

   854     pResult = Tcl_GetObjResult(interp);

   855     Tcl_SetIntObj(pResult, sqlite3_changes(pDb->db));

   856     break;

   857   }

   858 

   859   /*    $db close

   860   **

   861   ** Shutdown the database

   862   */

   863   case DB_CLOSE: {

   864     Tcl_DeleteCommand(interp, Tcl_GetStringFromObj(objv[0], 0));

   865     break;

   866   }

   867 

   868   /*

   869   **     $db collate NAME SCRIPT

   870   **

   871   ** Create a new SQL collation function called NAME.  Whenever

   872   ** that function is called, invoke SCRIPT to evaluate the function.

   873   */

   874   case DB_COLLATE: {

   875     SqlCollate *pCollate;

   876     char *zName;

   877     char *zScript;

   878     int nScript;

   879     if( objc!=4 ){

   880       Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");

   881       return TCL_ERROR;

   882     }

   883     zName = Tcl_GetStringFromObj(objv[2], 0);

   884     zScript = Tcl_GetStringFromObj(objv[3], &nScript);

   885     pCollate = (SqlCollate*)Tcl_Alloc( sizeof(*pCollate) + nScript + 1 );

   886     if( pCollate==0 ) return TCL_ERROR;

   887     pCollate->interp = interp;

   888     pCollate->pNext = pDb->pCollate;

   889     pCollate->zScript = (char*)&pCollate[1];

   890     pDb->pCollate = pCollate;

   891     strcpy(pCollate->zScript, zScript);

   892     if( sqlite3_create_collation(pDb->db, zName, SQLITE_UTF8, 

   893         pCollate, tclSqlCollate) ){

   894       Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);

   895       return TCL_ERROR;

   896     }

   897     break;

   898   }

   899 

   900   /*

   901   **     $db collation_needed SCRIPT

   902   **

   903   ** Create a new SQL collation function called NAME.  Whenever

   904   ** that function is called, invoke SCRIPT to evaluate the function.

   905   */

   906   case DB_COLLATION_NEEDED: {

   907     if( objc!=3 ){

   908       Tcl_WrongNumArgs(interp, 2, objv, "SCRIPT");

   909       return TCL_ERROR;

   910     }

   911     if( pDb->pCollateNeeded ){

   912       Tcl_DecrRefCount(pDb->pCollateNeeded);

   913     }

   914     pDb->pCollateNeeded = Tcl_DuplicateObj(objv[2]);

   915     Tcl_IncrRefCount(pDb->pCollateNeeded);

   916     sqlite3_collation_needed(pDb->db, pDb, tclCollateNeeded);

   917     break;

   918   }

   919 

   920   /*    $db commit_hook ?CALLBACK?

   921   **

   922   ** Invoke the given callback just before committing every SQL transaction.

   923   ** If the callback throws an exception or returns non-zero, then the

   924   ** transaction is aborted.  If CALLBACK is an empty string, the callback

   925   ** is disabled.

   926   */

   927   case DB_COMMIT_HOOK: {

   928     if( objc>3 ){

   929       Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");

   930       return TCL_ERROR;

   931     }else if( objc==2 ){

   932       if( pDb->zCommit ){

   933         Tcl_AppendResult(interp, pDb->zCommit, 0);

   934       }

   935     }else{

   936       char *zCommit;

   937       int len;

   938       if( pDb->zCommit ){

   939         Tcl_Free(pDb->zCommit);

   940       }

   941       zCommit = Tcl_GetStringFromObj(objv[2], &len);

   942       if( zCommit && len>0 ){

   943         pDb->zCommit = Tcl_Alloc( len + 1 );

   944         strcpy(pDb->zCommit, zCommit);

   945       }else{

   946         pDb->zCommit = 0;

   947       }

   948       if( pDb->zCommit ){

   949         pDb->interp = interp;

   950         sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb);

   951       }else{

   952         sqlite3_commit_hook(pDb->db, 0, 0);

   953       }

   954     }

   955     break;

   956   }

   957 

   958   /*    $db complete SQL

   959   **

   960   ** Return TRUE if SQL is a complete SQL statement.  Return FALSE if

   961   ** additional lines of input are needed.  This is similar to the

   962   ** built-in "info complete" command of Tcl.

   963   */

   964   case DB_COMPLETE: {

   965 #ifndef SQLITE_OMIT_COMPLETE

   966     Tcl_Obj *pResult;

   967     int isComplete;

   968     if( objc!=3 ){

   969       Tcl_WrongNumArgs(interp, 2, objv, "SQL");

   970       return TCL_ERROR;

   971     }

   972     isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) );

   973     pResult = Tcl_GetObjResult(interp);

   974     Tcl_SetBooleanObj(pResult, isComplete);

   975 #endif

   976     break;

   977   }

   978 

   979   /*    $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?

   980   **

   981   ** Copy data into table from filename, optionally using SEPARATOR

   982   ** as column separators.  If a column contains a null string, or the

   983   ** value of NULLINDICATOR, a NULL is inserted for the column.

   984   ** conflict-algorithm is one of the sqlite conflict algorithms:

   985   **    rollback, abort, fail, ignore, replace

   986   ** On success, return the number of lines processed, not necessarily same

   987   ** as 'db changes' due to conflict-algorithm selected.

   988   **

   989   ** This code is basically an implementation/enhancement of

   990   ** the sqlite3 shell.c ".import" command.

   991   **

   992   ** This command usage is equivalent to the sqlite2.x COPY statement,

   993   ** which imports file data into a table using the PostgreSQL COPY file format:

   994   **   $db copy $conflit_algo $table_name $filename \t \\N

   995   */

   996   case DB_COPY: {

   997     char *zTable;               /* Insert data into this table */

   998     char *zFile;                /* The file from which to extract data */

   999     char *zConflict;            /* The conflict algorithm to use */

  1000     sqlite3_stmt *pStmt;        /* A statement */

  1001     int rc;                     /* Result code */

  1002     int nCol;                   /* Number of columns in the table */

  1003     int nByte;                  /* Number of bytes in an SQL string */

  1004     int i, j;                   /* Loop counters */

  1005     int nSep;                   /* Number of bytes in zSep[] */

  1006     int nNull;                  /* Number of bytes in zNull[] */

  1007     char *zSql;                 /* An SQL statement */

  1008     char *zLine;                /* A single line of input from the file */

  1009     char **azCol;               /* zLine[] broken up into columns */

  1010     char *zCommit;              /* How to commit changes */

  1011     FILE *in;                   /* The input file */

  1012     int lineno = 0;             /* Line number of input file */

  1013     char zLineNum[80];          /* Line number print buffer */

  1014     Tcl_Obj *pResult;           /* interp result */

  1015 

  1016     char *zSep;

  1017     char *zNull;

  1018     if( objc<5 || objc>7 ){

  1019       Tcl_WrongNumArgs(interp, 2, objv, 

  1020          "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");

  1021       return TCL_ERROR;

  1022     }

  1023     if( objc>=6 ){

  1024       zSep = Tcl_GetStringFromObj(objv[5], 0);

  1025     }else{

  1026       zSep = "\t";

  1027     }

  1028     if( objc>=7 ){

  1029       zNull = Tcl_GetStringFromObj(objv[6], 0);

  1030     }else{

  1031       zNull = "";

  1032     }

  1033     zConflict = Tcl_GetStringFromObj(objv[2], 0);

  1034     zTable = Tcl_GetStringFromObj(objv[3], 0);

  1035     zFile = Tcl_GetStringFromObj(objv[4], 0);

  1036     nSep = strlen(zSep);

  1037     nNull = strlen(zNull);

  1038     if( nSep==0 ){

  1039       Tcl_AppendResult(interp,"Error: non-null separator required for copy",0);

  1040       return TCL_ERROR;

  1041     }

  1042     if(sqlite3StrICmp(zConflict, "rollback") != 0 &&

  1043        sqlite3StrICmp(zConflict, "abort"   ) != 0 &&

  1044        sqlite3StrICmp(zConflict, "fail"    ) != 0 &&

  1045        sqlite3StrICmp(zConflict, "ignore"  ) != 0 &&

  1046        sqlite3StrICmp(zConflict, "replace" ) != 0 ) {

  1047       Tcl_AppendResult(interp, "Error: \"", zConflict, 

  1048             "\", conflict-algorithm must be one of: rollback, "

  1049             "abort, fail, ignore, or replace", 0);

  1050       return TCL_ERROR;

  1051     }

  1052     zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);

  1053     if( zSql==0 ){

  1054       Tcl_AppendResult(interp, "Error: no such table: ", zTable, 0);

  1055       return TCL_ERROR;

  1056     }

  1057     nByte = strlen(zSql);

  1058     rc = sqlite3_prepare(pDb->db, zSql, 0, &pStmt, 0);

  1059     sqlite3_free(zSql);

  1060     if( rc ){

  1061       Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), 0);

  1062       nCol = 0;

  1063     }else{

  1064       nCol = sqlite3_column_count(pStmt);

  1065     }

  1066     sqlite3_finalize(pStmt);

  1067     if( nCol==0 ) {

  1068       return TCL_ERROR;

  1069     }

  1070     zSql = malloc( nByte + 50 + nCol*2 );

  1071     if( zSql==0 ) {

  1072       Tcl_AppendResult(interp, "Error: can't malloc()", 0);

  1073       return TCL_ERROR;

  1074     }

  1075     sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",

  1076          zConflict, zTable);

  1077     j = strlen(zSql);

  1078     for(i=1; i<nCol; i++){

  1079       zSql[j++] = ',';

  1080       zSql[j++] = '?';

  1081     }

  1082     zSql[j++] = ')';

  1083     zSql[j] = 0;

  1084     rc = sqlite3_prepare(pDb->db, zSql, 0, &pStmt, 0);

  1085     free(zSql);

  1086     if( rc ){

  1087       Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), 0);

  1088       sqlite3_finalize(pStmt);

  1089       return TCL_ERROR;

  1090     }

  1091     in = fopen(zFile, "rb");

  1092     if( in==0 ){

  1093       Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, NULL);

  1094       sqlite3_finalize(pStmt);

  1095       return TCL_ERROR;

  1096     }

  1097     azCol = malloc( sizeof(azCol[0])*(nCol+1) );

  1098     if( azCol==0 ) {

  1099       Tcl_AppendResult(interp, "Error: can't malloc()", 0);

  1100       fclose(in);

  1101       return TCL_ERROR;

  1102     }

  1103     (void)sqlite3_exec(pDb->db, "BEGIN", 0, 0, 0);

  1104     zCommit = "COMMIT";

  1105     while( (zLine = local_getline(0, in))!=0 ){

  1106       char *z;

  1107       i = 0;

  1108       lineno++;

  1109       azCol[0] = zLine;

  1110       for(i=0, z=zLine; *z; z++){

  1111         if( *z==zSep[0] && strncmp(z, zSep, nSep)==0 ){

  1112           *z = 0;

  1113           i++;

  1114           if( i<nCol ){

  1115             azCol[i] = &z[nSep];

  1116             z += nSep-1;

  1117           }

  1118         }

  1119       }

  1120       if( i+1!=nCol ){

  1121         char *zErr;

  1122         zErr = malloc(200 + strlen(zFile));

  1123         if( zErr ){

  1124           sprintf(zErr,

  1125              "Error: %s line %d: expected %d columns of data but found %d",

  1126              zFile, lineno, nCol, i+1);

  1127           Tcl_AppendResult(interp, zErr, 0);

  1128           free(zErr);

  1129         }

  1130         zCommit = "ROLLBACK";

  1131         break;

  1132       }

  1133       for(i=0; i<nCol; i++){

  1134         /* check for null data, if so, bind as null */

  1135         if ((nNull>0 && strcmp(azCol[i], zNull)==0) || strlen(azCol[i])==0) {