1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/SRC/tclsqlite.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2691 @@
1.4 +/*
1.5 +** 2001 September 15
1.6 +**
1.7 +** Portions Copyright (c) 2008 Nokia Corporation and/or its subsidiaries. All rights reserved.
1.8 +**
1.9 +** The author disclaims copyright to this source code. In place of
1.10 +** a legal notice, here is a blessing:
1.11 +**
1.12 +** May you do good and not evil.
1.13 +** May you find forgiveness for yourself and forgive others.
1.14 +** May you share freely, never taking more than you give.
1.15 +**
1.16 +*************************************************************************
1.17 +** A TCL Interface to SQLite. Append this file to sqlite3.c and
1.18 +** compile the whole thing to build a TCL-enabled version of SQLite.
1.19 +**
1.20 +** $Id: tclsqlite.c,v 1.226 2008/09/23 10:12:15 drh Exp $
1.21 +*/
1.22 +#include "tcl.h"
1.23 +#include <errno.h>
1.24 +
1.25 +/*
1.26 +** Some additional include files are needed if this file is not
1.27 +** appended to the amalgamation.
1.28 +*/
1.29 +#ifndef SQLITE_AMALGAMATION
1.30 +# include "sqliteInt.h"
1.31 +# include <stdlib.h>
1.32 +# include <string.h>
1.33 +# include <assert.h>
1.34 +# include <ctype.h>
1.35 +#endif
1.36 +
1.37 +#ifdef __SYMBIAN32__
1.38 +int CopyTestFiles(void);
1.39 +int DeleteTestFiles(void);
1.40 +int PrintText(void*, Tcl_Interp*, int objc, Tcl_Obj* const* objv);
1.41 +void PrintS(const char* aText);
1.42 +#endif
1.43 +
1.44 +/*
1.45 + * Windows needs to know which symbols to export. Unix does not.
1.46 + * BUILD_sqlite should be undefined for Unix.
1.47 + */
1.48 +#ifdef BUILD_sqlite
1.49 +#undef TCL_STORAGE_CLASS
1.50 +#define TCL_STORAGE_CLASS DLLEXPORT
1.51 +#endif /* BUILD_sqlite */
1.52 +
1.53 +#define NUM_PREPARED_STMTS 10
1.54 +#define MAX_PREPARED_STMTS 100
1.55 +
1.56 +/*
1.57 +** If TCL uses UTF-8 and SQLite is configured to use iso8859, then we
1.58 +** have to do a translation when going between the two. Set the
1.59 +** UTF_TRANSLATION_NEEDED macro to indicate that we need to do
1.60 +** this translation.
1.61 +*/
1.62 +#if defined(TCL_UTF_MAX) && !defined(SQLITE_UTF8)
1.63 +# define UTF_TRANSLATION_NEEDED 1
1.64 +#endif
1.65 +
1.66 +/*
1.67 +** New SQL functions can be created as TCL scripts. Each such function
1.68 +** is described by an instance of the following structure.
1.69 +*/
1.70 +typedef struct SqlFunc SqlFunc;
1.71 +struct SqlFunc {
1.72 + Tcl_Interp *interp; /* The TCL interpret to execute the function */
1.73 + Tcl_Obj *pScript; /* The Tcl_Obj representation of the script */
1.74 + int useEvalObjv; /* True if it is safe to use Tcl_EvalObjv */
1.75 + char *zName; /* Name of this function */
1.76 + SqlFunc *pNext; /* Next function on the list of them all */
1.77 +};
1.78 +
1.79 +/*
1.80 +** New collation sequences function can be created as TCL scripts. Each such
1.81 +** function is described by an instance of the following structure.
1.82 +*/
1.83 +typedef struct SqlCollate SqlCollate;
1.84 +struct SqlCollate {
1.85 + Tcl_Interp *interp; /* The TCL interpret to execute the function */
1.86 + char *zScript; /* The script to be run */
1.87 + SqlCollate *pNext; /* Next function on the list of them all */
1.88 +};
1.89 +
1.90 +/*
1.91 +** Prepared statements are cached for faster execution. Each prepared
1.92 +** statement is described by an instance of the following structure.
1.93 +*/
1.94 +typedef struct SqlPreparedStmt SqlPreparedStmt;
1.95 +struct SqlPreparedStmt {
1.96 + SqlPreparedStmt *pNext; /* Next in linked list */
1.97 + SqlPreparedStmt *pPrev; /* Previous on the list */
1.98 + sqlite3_stmt *pStmt; /* The prepared statement */
1.99 + int nSql; /* chars in zSql[] */
1.100 + const char *zSql; /* Text of the SQL statement */
1.101 +};
1.102 +
1.103 +typedef struct IncrblobChannel IncrblobChannel;
1.104 +
1.105 +/*
1.106 +** There is one instance of this structure for each SQLite database
1.107 +** that has been opened by the SQLite TCL interface.
1.108 +*/
1.109 +typedef struct SqliteDb SqliteDb;
1.110 +struct SqliteDb {
1.111 + sqlite3 *db; /* The "real" database structure. MUST BE FIRST */
1.112 + Tcl_Interp *interp; /* The interpreter used for this database */
1.113 + char *zBusy; /* The busy callback routine */
1.114 + char *zCommit; /* The commit hook callback routine */
1.115 + char *zTrace; /* The trace callback routine */
1.116 + char *zProfile; /* The profile callback routine */
1.117 + char *zProgress; /* The progress callback routine */
1.118 + char *zAuth; /* The authorization callback routine */
1.119 + int disableAuth; /* Disable the authorizer if it exists */
1.120 + char *zNull; /* Text to substitute for an SQL NULL value */
1.121 + SqlFunc *pFunc; /* List of SQL functions */
1.122 + Tcl_Obj *pUpdateHook; /* Update hook script (if any) */
1.123 + Tcl_Obj *pRollbackHook; /* Rollback hook script (if any) */
1.124 + SqlCollate *pCollate; /* List of SQL collation functions */
1.125 + int rc; /* Return code of most recent sqlite3_exec() */
1.126 + Tcl_Obj *pCollateNeeded; /* Collation needed script */
1.127 + SqlPreparedStmt *stmtList; /* List of prepared statements*/
1.128 + SqlPreparedStmt *stmtLast; /* Last statement in the list */
1.129 + int maxStmt; /* The next maximum number of stmtList */
1.130 + int nStmt; /* Number of statements in stmtList */
1.131 + IncrblobChannel *pIncrblob;/* Linked list of open incrblob channels */
1.132 +};
1.133 +
1.134 +struct IncrblobChannel {
1.135 + sqlite3_blob *pBlob; /* sqlite3 blob handle */
1.136 + SqliteDb *pDb; /* Associated database connection */
1.137 + int iSeek; /* Current seek offset */
1.138 + Tcl_Channel channel; /* Channel identifier */
1.139 + IncrblobChannel *pNext; /* Linked list of all open incrblob channels */
1.140 + IncrblobChannel *pPrev; /* Linked list of all open incrblob channels */
1.141 +};
1.142 +
1.143 +#ifndef SQLITE_OMIT_INCRBLOB
1.144 +/*
1.145 +** Close all incrblob channels opened using database connection pDb.
1.146 +** This is called when shutting down the database connection.
1.147 +*/
1.148 +static void closeIncrblobChannels(SqliteDb *pDb){
1.149 + IncrblobChannel *p;
1.150 + IncrblobChannel *pNext;
1.151 +
1.152 + for(p=pDb->pIncrblob; p; p=pNext){
1.153 + pNext = p->pNext;
1.154 +
1.155 + /* Note: Calling unregister here call Tcl_Close on the incrblob channel,
1.156 + ** which deletes the IncrblobChannel structure at *p. So do not
1.157 + ** call Tcl_Free() here.
1.158 + */
1.159 + Tcl_UnregisterChannel(pDb->interp, p->channel);
1.160 + }
1.161 +}
1.162 +
1.163 +/*
1.164 +** Close an incremental blob channel.
1.165 +*/
1.166 +static int incrblobClose(ClientData instanceData, Tcl_Interp *interp){
1.167 + IncrblobChannel *p = (IncrblobChannel *)instanceData;
1.168 + int rc = sqlite3_blob_close(p->pBlob);
1.169 + sqlite3 *db = p->pDb->db;
1.170 +
1.171 + /* Remove the channel from the SqliteDb.pIncrblob list. */
1.172 + if( p->pNext ){
1.173 + p->pNext->pPrev = p->pPrev;
1.174 + }
1.175 + if( p->pPrev ){
1.176 + p->pPrev->pNext = p->pNext;
1.177 + }
1.178 + if( p->pDb->pIncrblob==p ){
1.179 + p->pDb->pIncrblob = p->pNext;
1.180 + }
1.181 +
1.182 + /* Free the IncrblobChannel structure */
1.183 + Tcl_Free((char *)p);
1.184 +
1.185 + if( rc!=SQLITE_OK ){
1.186 + Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
1.187 + return TCL_ERROR;
1.188 + }
1.189 + return TCL_OK;
1.190 +}
1.191 +
1.192 +/*
1.193 +** Read data from an incremental blob channel.
1.194 +*/
1.195 +static int incrblobInput(
1.196 + ClientData instanceData,
1.197 + char *buf,
1.198 + int bufSize,
1.199 + int *errorCodePtr
1.200 +){
1.201 + IncrblobChannel *p = (IncrblobChannel *)instanceData;
1.202 + int nRead = bufSize; /* Number of bytes to read */
1.203 + int nBlob; /* Total size of the blob */
1.204 + int rc; /* sqlite error code */
1.205 +
1.206 + nBlob = sqlite3_blob_bytes(p->pBlob);
1.207 + if( (p->iSeek+nRead)>nBlob ){
1.208 + nRead = nBlob-p->iSeek;
1.209 + }
1.210 + if( nRead<=0 ){
1.211 + return 0;
1.212 + }
1.213 +
1.214 + rc = sqlite3_blob_read(p->pBlob, (void *)buf, nRead, p->iSeek);
1.215 + if( rc!=SQLITE_OK ){
1.216 + *errorCodePtr = rc;
1.217 + return -1;
1.218 + }
1.219 +
1.220 + p->iSeek += nRead;
1.221 + return nRead;
1.222 +}
1.223 +
1.224 +/*
1.225 +** Write data to an incremental blob channel.
1.226 +*/
1.227 +static int incrblobOutput(
1.228 + ClientData instanceData,
1.229 + CONST char *buf,
1.230 + int toWrite,
1.231 + int *errorCodePtr
1.232 +){
1.233 + IncrblobChannel *p = (IncrblobChannel *)instanceData;
1.234 + int nWrite = toWrite; /* Number of bytes to write */
1.235 + int nBlob; /* Total size of the blob */
1.236 + int rc; /* sqlite error code */
1.237 +
1.238 + nBlob = sqlite3_blob_bytes(p->pBlob);
1.239 + if( (p->iSeek+nWrite)>nBlob ){
1.240 + *errorCodePtr = EINVAL;
1.241 + return -1;
1.242 + }
1.243 + if( nWrite<=0 ){
1.244 + return 0;
1.245 + }
1.246 +
1.247 + rc = sqlite3_blob_write(p->pBlob, (void *)buf, nWrite, p->iSeek);
1.248 + if( rc!=SQLITE_OK ){
1.249 + *errorCodePtr = EIO;
1.250 + return -1;
1.251 + }
1.252 +
1.253 + p->iSeek += nWrite;
1.254 + return nWrite;
1.255 +}
1.256 +
1.257 +/*
1.258 +** Seek an incremental blob channel.
1.259 +*/
1.260 +static int incrblobSeek(
1.261 + ClientData instanceData,
1.262 + long offset,
1.263 + int seekMode,
1.264 + int *errorCodePtr
1.265 +){
1.266 + IncrblobChannel *p = (IncrblobChannel *)instanceData;
1.267 +
1.268 + switch( seekMode ){
1.269 + case SEEK_SET:
1.270 + p->iSeek = offset;
1.271 + break;
1.272 + case SEEK_CUR:
1.273 + p->iSeek += offset;
1.274 + break;
1.275 + case SEEK_END:
1.276 + p->iSeek = sqlite3_blob_bytes(p->pBlob) + offset;
1.277 + break;
1.278 +
1.279 + default: assert(0); /* Bad seekMode */
1.280 + }
1.281 +
1.282 + return p->iSeek;
1.283 +}
1.284 +
1.285 +
1.286 +static void incrblobWatch(ClientData instanceData, int mode){
1.287 + /* NO-OP */
1.288 +}
1.289 +static int incrblobHandle(ClientData instanceData, int dir, ClientData *hPtr){
1.290 + return TCL_ERROR;
1.291 +}
1.292 +
1.293 +static Tcl_ChannelType IncrblobChannelType = {
1.294 + "incrblob", /* typeName */
1.295 + TCL_CHANNEL_VERSION_2, /* version */
1.296 + incrblobClose, /* closeProc */
1.297 + incrblobInput, /* inputProc */
1.298 + incrblobOutput, /* outputProc */
1.299 + incrblobSeek, /* seekProc */
1.300 + 0, /* setOptionProc */
1.301 + 0, /* getOptionProc */
1.302 + incrblobWatch, /* watchProc (this is a no-op) */
1.303 + incrblobHandle, /* getHandleProc (always returns error) */
1.304 + 0, /* close2Proc */
1.305 + 0, /* blockModeProc */
1.306 + 0, /* flushProc */
1.307 + 0, /* handlerProc */
1.308 + 0, /* wideSeekProc */
1.309 +};
1.310 +
1.311 +/*
1.312 +** Create a new incrblob channel.
1.313 +*/
1.314 +static int createIncrblobChannel(
1.315 + Tcl_Interp *interp,
1.316 + SqliteDb *pDb,
1.317 + const char *zDb,
1.318 + const char *zTable,
1.319 + const char *zColumn,
1.320 + sqlite_int64 iRow,
1.321 + int isReadonly
1.322 +){
1.323 + IncrblobChannel *p;
1.324 + sqlite3 *db = pDb->db;
1.325 + sqlite3_blob *pBlob;
1.326 + int rc;
1.327 + int flags = TCL_READABLE|(isReadonly ? 0 : TCL_WRITABLE);
1.328 +
1.329 + /* This variable is used to name the channels: "incrblob_[incr count]" */
1.330 + static int count = 0;
1.331 + char zChannel[64];
1.332 +
1.333 + rc = sqlite3_blob_open(db, zDb, zTable, zColumn, iRow, !isReadonly, &pBlob);
1.334 + if( rc!=SQLITE_OK ){
1.335 + Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
1.336 + return TCL_ERROR;
1.337 + }
1.338 +
1.339 + p = (IncrblobChannel *)Tcl_Alloc(sizeof(IncrblobChannel));
1.340 + p->iSeek = 0;
1.341 + p->pBlob = pBlob;
1.342 +
1.343 + sqlite3_snprintf(sizeof(zChannel), zChannel, "incrblob_%d", ++count);
1.344 + p->channel = Tcl_CreateChannel(&IncrblobChannelType, zChannel, p, flags);
1.345 + Tcl_RegisterChannel(interp, p->channel);
1.346 +
1.347 + /* Link the new channel into the SqliteDb.pIncrblob list. */
1.348 + p->pNext = pDb->pIncrblob;
1.349 + p->pPrev = 0;
1.350 + if( p->pNext ){
1.351 + p->pNext->pPrev = p;
1.352 + }
1.353 + pDb->pIncrblob = p;
1.354 + p->pDb = pDb;
1.355 +
1.356 + Tcl_SetResult(interp, (char *)Tcl_GetChannelName(p->channel), TCL_VOLATILE);
1.357 + return TCL_OK;
1.358 +}
1.359 +#else /* else clause for "#ifndef SQLITE_OMIT_INCRBLOB" */
1.360 + #define closeIncrblobChannels(pDb)
1.361 +#endif
1.362 +
1.363 +/*
1.364 +** Look at the script prefix in pCmd. We will be executing this script
1.365 +** after first appending one or more arguments. This routine analyzes
1.366 +** the script to see if it is safe to use Tcl_EvalObjv() on the script
1.367 +** rather than the more general Tcl_EvalEx(). Tcl_EvalObjv() is much
1.368 +** faster.
1.369 +**
1.370 +** Scripts that are safe to use with Tcl_EvalObjv() consists of a
1.371 +** command name followed by zero or more arguments with no [...] or $
1.372 +** or {...} or ; to be seen anywhere. Most callback scripts consist
1.373 +** of just a single procedure name and they meet this requirement.
1.374 +*/
1.375 +static int safeToUseEvalObjv(Tcl_Interp *interp, Tcl_Obj *pCmd){
1.376 + /* We could try to do something with Tcl_Parse(). But we will instead
1.377 + ** just do a search for forbidden characters. If any of the forbidden
1.378 + ** characters appear in pCmd, we will report the string as unsafe.
1.379 + */
1.380 + const char *z;
1.381 + int n;
1.382 + z = Tcl_GetStringFromObj(pCmd, &n);
1.383 + while( n-- > 0 ){
1.384 + int c = *(z++);
1.385 + if( c=='$' || c=='[' || c==';' ) return 0;
1.386 + }
1.387 + return 1;
1.388 +}
1.389 +
1.390 +/*
1.391 +** Find an SqlFunc structure with the given name. Or create a new
1.392 +** one if an existing one cannot be found. Return a pointer to the
1.393 +** structure.
1.394 +*/
1.395 +static SqlFunc *findSqlFunc(SqliteDb *pDb, const char *zName){
1.396 + SqlFunc *p, *pNew;
1.397 + int i;
1.398 + pNew = (SqlFunc*)Tcl_Alloc( sizeof(*pNew) + strlen(zName) + 1 );
1.399 + pNew->zName = (char*)&pNew[1];
1.400 + for(i=0; zName[i]; i++){ pNew->zName[i] = tolower(zName[i]); }
1.401 + pNew->zName[i] = 0;
1.402 + for(p=pDb->pFunc; p; p=p->pNext){
1.403 + if( strcmp(p->zName, pNew->zName)==0 ){
1.404 + Tcl_Free((char*)pNew);
1.405 + return p;
1.406 + }
1.407 + }
1.408 + pNew->interp = pDb->interp;
1.409 + pNew->pScript = 0;
1.410 + pNew->pNext = pDb->pFunc;
1.411 + pDb->pFunc = pNew;
1.412 + return pNew;
1.413 +}
1.414 +
1.415 +/*
1.416 +** Finalize and free a list of prepared statements
1.417 +*/
1.418 +static void flushStmtCache( SqliteDb *pDb ){
1.419 + SqlPreparedStmt *pPreStmt;
1.420 +
1.421 + while( pDb->stmtList ){
1.422 + sqlite3_finalize( pDb->stmtList->pStmt );
1.423 + pPreStmt = pDb->stmtList;
1.424 + pDb->stmtList = pDb->stmtList->pNext;
1.425 + Tcl_Free( (char*)pPreStmt );
1.426 + }
1.427 + pDb->nStmt = 0;
1.428 + pDb->stmtLast = 0;
1.429 +}
1.430 +
1.431 +/*
1.432 +** TCL calls this procedure when an sqlite3 database command is
1.433 +** deleted.
1.434 +*/
1.435 +static void DbDeleteCmd(void *db){
1.436 + SqliteDb *pDb = (SqliteDb*)db;
1.437 + flushStmtCache(pDb);
1.438 + closeIncrblobChannels(pDb);
1.439 + sqlite3_close(pDb->db);
1.440 + while( pDb->pFunc ){
1.441 + SqlFunc *pFunc = pDb->pFunc;
1.442 + pDb->pFunc = pFunc->pNext;
1.443 + Tcl_DecrRefCount(pFunc->pScript);
1.444 + Tcl_Free((char*)pFunc);
1.445 + }
1.446 + while( pDb->pCollate ){
1.447 + SqlCollate *pCollate = pDb->pCollate;
1.448 + pDb->pCollate = pCollate->pNext;
1.449 + Tcl_Free((char*)pCollate);
1.450 + }
1.451 + if( pDb->zBusy ){
1.452 + Tcl_Free(pDb->zBusy);
1.453 + }
1.454 + if( pDb->zTrace ){
1.455 + Tcl_Free(pDb->zTrace);
1.456 + }
1.457 + if( pDb->zProfile ){
1.458 + Tcl_Free(pDb->zProfile);
1.459 + }
1.460 + if( pDb->zAuth ){
1.461 + Tcl_Free(pDb->zAuth);
1.462 + }
1.463 + if( pDb->zNull ){
1.464 + Tcl_Free(pDb->zNull);
1.465 + }
1.466 + if( pDb->pUpdateHook ){
1.467 + Tcl_DecrRefCount(pDb->pUpdateHook);
1.468 + }
1.469 + if( pDb->pRollbackHook ){
1.470 + Tcl_DecrRefCount(pDb->pRollbackHook);
1.471 + }
1.472 + if( pDb->pCollateNeeded ){
1.473 + Tcl_DecrRefCount(pDb->pCollateNeeded);
1.474 + }
1.475 + Tcl_Free((char*)pDb);
1.476 +}
1.477 +
1.478 +/*
1.479 +** This routine is called when a database file is locked while trying
1.480 +** to execute SQL.
1.481 +*/
1.482 +static int DbBusyHandler(void *cd, int nTries){
1.483 + SqliteDb *pDb = (SqliteDb*)cd;
1.484 + int rc;
1.485 + char zVal[30];
1.486 +
1.487 + sqlite3_snprintf(sizeof(zVal), zVal, "%d", nTries);
1.488 + rc = Tcl_VarEval(pDb->interp, pDb->zBusy, " ", zVal, (char*)0);
1.489 + if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
1.490 + return 0;
1.491 + }
1.492 + return 1;
1.493 +}
1.494 +
1.495 +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1.496 +/*
1.497 +** This routine is invoked as the 'progress callback' for the database.
1.498 +*/
1.499 +static int DbProgressHandler(void *cd){
1.500 + SqliteDb *pDb = (SqliteDb*)cd;
1.501 + int rc;
1.502 +
1.503 + assert( pDb->zProgress );
1.504 + rc = Tcl_Eval(pDb->interp, pDb->zProgress);
1.505 + if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
1.506 + return 1;
1.507 + }
1.508 + return 0;
1.509 +}
1.510 +#endif
1.511 +
1.512 +#ifndef SQLITE_OMIT_TRACE
1.513 +/*
1.514 +** This routine is called by the SQLite trace handler whenever a new
1.515 +** block of SQL is executed. The TCL script in pDb->zTrace is executed.
1.516 +*/
1.517 +static void DbTraceHandler(void *cd, const char *zSql){
1.518 + SqliteDb *pDb = (SqliteDb*)cd;
1.519 + Tcl_DString str;
1.520 +
1.521 + Tcl_DStringInit(&str);
1.522 + Tcl_DStringAppend(&str, pDb->zTrace, -1);
1.523 + Tcl_DStringAppendElement(&str, zSql);
1.524 + Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));
1.525 + Tcl_DStringFree(&str);
1.526 + Tcl_ResetResult(pDb->interp);
1.527 +}
1.528 +#endif
1.529 +
1.530 +#ifndef SQLITE_OMIT_TRACE
1.531 +/*
1.532 +** This routine is called by the SQLite profile handler after a statement
1.533 +** SQL has executed. The TCL script in pDb->zProfile is evaluated.
1.534 +*/
1.535 +static void DbProfileHandler(void *cd, const char *zSql, sqlite_uint64 tm){
1.536 + SqliteDb *pDb = (SqliteDb*)cd;
1.537 + Tcl_DString str;
1.538 + char zTm[100];
1.539 +
1.540 + sqlite3_snprintf(sizeof(zTm)-1, zTm, "%lld", tm);
1.541 + Tcl_DStringInit(&str);
1.542 + Tcl_DStringAppend(&str, pDb->zProfile, -1);
1.543 + Tcl_DStringAppendElement(&str, zSql);
1.544 + Tcl_DStringAppendElement(&str, zTm);
1.545 + Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));
1.546 + Tcl_DStringFree(&str);
1.547 + Tcl_ResetResult(pDb->interp);
1.548 +}
1.549 +#endif
1.550 +
1.551 +/*
1.552 +** This routine is called when a transaction is committed. The
1.553 +** TCL script in pDb->zCommit is executed. If it returns non-zero or
1.554 +** if it throws an exception, the transaction is rolled back instead
1.555 +** of being committed.
1.556 +*/
1.557 +static int DbCommitHandler(void *cd){
1.558 + SqliteDb *pDb = (SqliteDb*)cd;
1.559 + int rc;
1.560 +
1.561 + rc = Tcl_Eval(pDb->interp, pDb->zCommit);
1.562 + if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
1.563 + return 1;
1.564 + }
1.565 + return 0;
1.566 +}
1.567 +
1.568 +static void DbRollbackHandler(void *clientData){
1.569 + SqliteDb *pDb = (SqliteDb*)clientData;
1.570 + assert(pDb->pRollbackHook);
1.571 + if( TCL_OK!=Tcl_EvalObjEx(pDb->interp, pDb->pRollbackHook, 0) ){
1.572 + Tcl_BackgroundError(pDb->interp);
1.573 + }
1.574 +}
1.575 +
1.576 +static void DbUpdateHandler(
1.577 + void *p,
1.578 + int op,
1.579 + const char *zDb,
1.580 + const char *zTbl,
1.581 + sqlite_int64 rowid
1.582 +){
1.583 + SqliteDb *pDb = (SqliteDb *)p;
1.584 + Tcl_Obj *pCmd;
1.585 +
1.586 + assert( pDb->pUpdateHook );
1.587 + assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
1.588 +
1.589 + pCmd = Tcl_DuplicateObj(pDb->pUpdateHook);
1.590 + Tcl_IncrRefCount(pCmd);
1.591 + Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(
1.592 + ( (op==SQLITE_INSERT)?"INSERT":(op==SQLITE_UPDATE)?"UPDATE":"DELETE"), -1));
1.593 + Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));
1.594 + Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));
1.595 + Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(rowid));
1.596 + Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
1.597 +}
1.598 +
1.599 +static void tclCollateNeeded(
1.600 + void *pCtx,
1.601 + sqlite3 *db,
1.602 + int enc,
1.603 + const char *zName
1.604 +){
1.605 + SqliteDb *pDb = (SqliteDb *)pCtx;
1.606 + Tcl_Obj *pScript = Tcl_DuplicateObj(pDb->pCollateNeeded);
1.607 + Tcl_IncrRefCount(pScript);
1.608 + Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(zName, -1));
1.609 + Tcl_EvalObjEx(pDb->interp, pScript, 0);
1.610 + Tcl_DecrRefCount(pScript);
1.611 +}
1.612 +
1.613 +/*
1.614 +** This routine is called to evaluate an SQL collation function implemented
1.615 +** using TCL script.
1.616 +*/
1.617 +static int tclSqlCollate(
1.618 + void *pCtx,
1.619 + int nA,
1.620 + const void *zA,
1.621 + int nB,
1.622 + const void *zB
1.623 +){
1.624 + SqlCollate *p = (SqlCollate *)pCtx;
1.625 + Tcl_Obj *pCmd;
1.626 +
1.627 + pCmd = Tcl_NewStringObj(p->zScript, -1);
1.628 + Tcl_IncrRefCount(pCmd);
1.629 + Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zA, nA));
1.630 + Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zB, nB));
1.631 + Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
1.632 + Tcl_DecrRefCount(pCmd);
1.633 + return (atoi(Tcl_GetStringResult(p->interp)));
1.634 +}
1.635 +
1.636 +/*
1.637 +** This routine is called to evaluate an SQL function implemented
1.638 +** using TCL script.
1.639 +*/
1.640 +static void tclSqlFunc(sqlite3_context *context, int argc, sqlite3_value**argv){
1.641 + SqlFunc *p = sqlite3_user_data(context);
1.642 + Tcl_Obj *pCmd;
1.643 + int i;
1.644 + int rc;
1.645 +
1.646 + if( argc==0 ){
1.647 + /* If there are no arguments to the function, call Tcl_EvalObjEx on the
1.648 + ** script object directly. This allows the TCL compiler to generate
1.649 + ** bytecode for the command on the first invocation and thus make
1.650 + ** subsequent invocations much faster. */
1.651 + pCmd = p->pScript;
1.652 + Tcl_IncrRefCount(pCmd);
1.653 + rc = Tcl_EvalObjEx(p->interp, pCmd, 0);
1.654 + Tcl_DecrRefCount(pCmd);
1.655 + }else{
1.656 + /* If there are arguments to the function, make a shallow copy of the
1.657 + ** script object, lappend the arguments, then evaluate the copy.
1.658 + **
1.659 + ** By "shallow" copy, we mean a only the outer list Tcl_Obj is duplicated.
1.660 + ** The new Tcl_Obj contains pointers to the original list elements.
1.661 + ** That way, when Tcl_EvalObjv() is run and shimmers the first element
1.662 + ** of the list to tclCmdNameType, that alternate representation will
1.663 + ** be preserved and reused on the next invocation.
1.664 + */
1.665 + Tcl_Obj **aArg;
1.666 + int nArg;
1.667 + if( Tcl_ListObjGetElements(p->interp, p->pScript, &nArg, &aArg) ){
1.668 + sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
1.669 + return;
1.670 + }
1.671 + pCmd = Tcl_NewListObj(nArg, aArg);
1.672 + Tcl_IncrRefCount(pCmd);
1.673 + for(i=0; i<argc; i++){
1.674 + sqlite3_value *pIn = argv[i];
1.675 + Tcl_Obj *pVal;
1.676 +
1.677 + /* Set pVal to contain the i'th column of this row. */
1.678 + switch( sqlite3_value_type(pIn) ){
1.679 + case SQLITE_BLOB: {
1.680 + int bytes = sqlite3_value_bytes(pIn);
1.681 + pVal = Tcl_NewByteArrayObj(sqlite3_value_blob(pIn), bytes);
1.682 + break;
1.683 + }
1.684 + case SQLITE_INTEGER: {
1.685 + sqlite_int64 v = sqlite3_value_int64(pIn);
1.686 + if( v>=-2147483647 && v<=2147483647 ){
1.687 + pVal = Tcl_NewIntObj(v);
1.688 + }else{
1.689 + pVal = Tcl_NewWideIntObj(v);
1.690 + }
1.691 + break;
1.692 + }
1.693 + case SQLITE_FLOAT: {
1.694 + double r = sqlite3_value_double(pIn);
1.695 + pVal = Tcl_NewDoubleObj(r);
1.696 + break;
1.697 + }
1.698 + case SQLITE_NULL: {
1.699 + pVal = Tcl_NewStringObj("", 0);
1.700 + break;
1.701 + }
1.702 + default: {
1.703 + int bytes = sqlite3_value_bytes(pIn);
1.704 + pVal = Tcl_NewStringObj((char *)sqlite3_value_text(pIn), bytes);
1.705 + break;
1.706 + }
1.707 + }
1.708 + rc = Tcl_ListObjAppendElement(p->interp, pCmd, pVal);
1.709 + if( rc ){
1.710 + Tcl_DecrRefCount(pCmd);
1.711 + sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
1.712 + return;
1.713 + }
1.714 + }
1.715 + if( !p->useEvalObjv ){
1.716 + /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd
1.717 + ** is a list without a string representation. To prevent this from
1.718 + ** happening, make sure pCmd has a valid string representation */
1.719 + Tcl_GetString(pCmd);
1.720 + }
1.721 + rc = Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
1.722 + Tcl_DecrRefCount(pCmd);
1.723 + }
1.724 +
1.725 + if( rc && rc!=TCL_RETURN ){
1.726 + sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);
1.727 + }else{
1.728 + Tcl_Obj *pVar = Tcl_GetObjResult(p->interp);
1.729 + int n;
1.730 + u8 *data;
1.731 + char *zType = pVar->typePtr ? pVar->typePtr->name : "";
1.732 + char c = zType[0];
1.733 + if( c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0 ){
1.734 + /* Only return a BLOB type if the Tcl variable is a bytearray and
1.735 + ** has no string representation. */
1.736 + data = Tcl_GetByteArrayFromObj(pVar, &n);
1.737 + sqlite3_result_blob(context, data, n, SQLITE_TRANSIENT);
1.738 + }else if( c=='b' && strcmp(zType,"boolean")==0 ){
1.739 + Tcl_GetIntFromObj(0, pVar, &n);
1.740 + sqlite3_result_int(context, n);
1.741 + }else if( c=='d' && strcmp(zType,"double")==0 ){
1.742 + double r;
1.743 + Tcl_GetDoubleFromObj(0, pVar, &r);
1.744 + sqlite3_result_double(context, r);
1.745 + }else if( (c=='w' && strcmp(zType,"wideInt")==0) ||
1.746 + (c=='i' && strcmp(zType,"int")==0) ){
1.747 + Tcl_WideInt v;
1.748 + Tcl_GetWideIntFromObj(0, pVar, &v);
1.749 + sqlite3_result_int64(context, v);
1.750 + }else{
1.751 + data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);
1.752 + sqlite3_result_text(context, (char *)data, n, SQLITE_TRANSIENT);
1.753 + }
1.754 + }
1.755 +}
1.756 +
1.757 +#ifndef SQLITE_OMIT_AUTHORIZATION
1.758 +/*
1.759 +** This is the authentication function. It appends the authentication
1.760 +** type code and the two arguments to zCmd[] then invokes the result
1.761 +** on the interpreter. The reply is examined to determine if the
1.762 +** authentication fails or succeeds.
1.763 +*/
1.764 +static int auth_callback(
1.765 + void *pArg,
1.766 + int code,
1.767 + const char *zArg1,
1.768 + const char *zArg2,
1.769 + const char *zArg3,
1.770 + const char *zArg4
1.771 +){
1.772 + char *zCode;
1.773 + Tcl_DString str;
1.774 + int rc;
1.775 + const char *zReply;
1.776 + SqliteDb *pDb = (SqliteDb*)pArg;
1.777 + if( pDb->disableAuth ) return SQLITE_OK;
1.778 +
1.779 + switch( code ){
1.780 + case SQLITE_COPY : zCode="SQLITE_COPY"; break;
1.781 + case SQLITE_CREATE_INDEX : zCode="SQLITE_CREATE_INDEX"; break;
1.782 + case SQLITE_CREATE_TABLE : zCode="SQLITE_CREATE_TABLE"; break;
1.783 + case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break;
1.784 + case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break;
1.785 + case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break;
1.786 + case SQLITE_CREATE_TEMP_VIEW : zCode="SQLITE_CREATE_TEMP_VIEW"; break;
1.787 + case SQLITE_CREATE_TRIGGER : zCode="SQLITE_CREATE_TRIGGER"; break;
1.788 + case SQLITE_CREATE_VIEW : zCode="SQLITE_CREATE_VIEW"; break;
1.789 + case SQLITE_DELETE : zCode="SQLITE_DELETE"; break;
1.790 + case SQLITE_DROP_INDEX : zCode="SQLITE_DROP_INDEX"; break;
1.791 + case SQLITE_DROP_TABLE : zCode="SQLITE_DROP_TABLE"; break;
1.792 + case SQLITE_DROP_TEMP_INDEX : zCode="SQLITE_DROP_TEMP_INDEX"; break;
1.793 + case SQLITE_DROP_TEMP_TABLE : zCode="SQLITE_DROP_TEMP_TABLE"; break;
1.794 + case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break;
1.795 + case SQLITE_DROP_TEMP_VIEW : zCode="SQLITE_DROP_TEMP_VIEW"; break;
1.796 + case SQLITE_DROP_TRIGGER : zCode="SQLITE_DROP_TRIGGER"; break;
1.797 + case SQLITE_DROP_VIEW : zCode="SQLITE_DROP_VIEW"; break;
1.798 + case SQLITE_INSERT : zCode="SQLITE_INSERT"; break;
1.799 + case SQLITE_PRAGMA : zCode="SQLITE_PRAGMA"; break;
1.800 + case SQLITE_READ : zCode="SQLITE_READ"; break;
1.801 + case SQLITE_SELECT : zCode="SQLITE_SELECT"; break;
1.802 + case SQLITE_TRANSACTION : zCode="SQLITE_TRANSACTION"; break;
1.803 + case SQLITE_UPDATE : zCode="SQLITE_UPDATE"; break;
1.804 + case SQLITE_ATTACH : zCode="SQLITE_ATTACH"; break;
1.805 + case SQLITE_DETACH : zCode="SQLITE_DETACH"; break;
1.806 + case SQLITE_ALTER_TABLE : zCode="SQLITE_ALTER_TABLE"; break;
1.807 + case SQLITE_REINDEX : zCode="SQLITE_REINDEX"; break;
1.808 + case SQLITE_ANALYZE : zCode="SQLITE_ANALYZE"; break;
1.809 + case SQLITE_CREATE_VTABLE : zCode="SQLITE_CREATE_VTABLE"; break;
1.810 + case SQLITE_DROP_VTABLE : zCode="SQLITE_DROP_VTABLE"; break;
1.811 + case SQLITE_FUNCTION : zCode="SQLITE_FUNCTION"; break;
1.812 + default : zCode="????"; break;
1.813 + }
1.814 + Tcl_DStringInit(&str);
1.815 + Tcl_DStringAppend(&str, pDb->zAuth, -1);
1.816 + Tcl_DStringAppendElement(&str, zCode);
1.817 + Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");
1.818 + Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");
1.819 + Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");
1.820 + Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");
1.821 + rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str));
1.822 + Tcl_DStringFree(&str);
1.823 + zReply = Tcl_GetStringResult(pDb->interp);
1.824 + if( strcmp(zReply,"SQLITE_OK")==0 ){
1.825 + rc = SQLITE_OK;
1.826 + }else if( strcmp(zReply,"SQLITE_DENY")==0 ){
1.827 + rc = SQLITE_DENY;
1.828 + }else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){
1.829 + rc = SQLITE_IGNORE;
1.830 + }else{
1.831 + rc = 999;
1.832 + }
1.833 + return rc;
1.834 +}
1.835 +#endif /* SQLITE_OMIT_AUTHORIZATION */
1.836 +
1.837 +/*
1.838 +** zText is a pointer to text obtained via an sqlite3_result_text()
1.839 +** or similar interface. This routine returns a Tcl string object,
1.840 +** reference count set to 0, containing the text. If a translation
1.841 +** between iso8859 and UTF-8 is required, it is preformed.
1.842 +*/
1.843 +static Tcl_Obj *dbTextToObj(char const *zText){
1.844 + Tcl_Obj *pVal;
1.845 +#ifdef UTF_TRANSLATION_NEEDED
1.846 + Tcl_DString dCol;
1.847 + Tcl_DStringInit(&dCol);
1.848 + Tcl_ExternalToUtfDString(NULL, zText, -1, &dCol);
1.849 + pVal = Tcl_NewStringObj(Tcl_DStringValue(&dCol), -1);
1.850 + Tcl_DStringFree(&dCol);
1.851 +#else
1.852 + pVal = Tcl_NewStringObj(zText, -1);
1.853 +#endif
1.854 + return pVal;
1.855 +}
1.856 +
1.857 +/*
1.858 +** This routine reads a line of text from FILE in, stores
1.859 +** the text in memory obtained from malloc() and returns a pointer
1.860 +** to the text. NULL is returned at end of file, or if malloc()
1.861 +** fails.
1.862 +**
1.863 +** The interface is like "readline" but no command-line editing
1.864 +** is done.
1.865 +**
1.866 +** copied from shell.c from '.import' command
1.867 +*/
1.868 +static char *local_getline(char *zPrompt, FILE *in){
1.869 + char *zLine;
1.870 + int nLine;
1.871 + int n;
1.872 + int eol;
1.873 +
1.874 + nLine = 100;
1.875 + zLine = malloc( nLine );
1.876 + if( zLine==0 ) return 0;
1.877 + n = 0;
1.878 + eol = 0;
1.879 + while( !eol ){
1.880 + if( n+100>nLine ){
1.881 + nLine = nLine*2 + 100;
1.882 + zLine = realloc(zLine, nLine);
1.883 + if( zLine==0 ) return 0;
1.884 + }
1.885 + if( fgets(&zLine[n], nLine - n, in)==0 ){
1.886 + if( n==0 ){
1.887 + free(zLine);
1.888 + return 0;
1.889 + }
1.890 + zLine[n] = 0;
1.891 + eol = 1;
1.892 + break;
1.893 + }
1.894 + while( zLine[n] ){ n++; }
1.895 + if( n>0 && zLine[n-1]=='\n' ){
1.896 + n--;
1.897 + zLine[n] = 0;
1.898 + eol = 1;
1.899 + }
1.900 + }
1.901 + zLine = realloc( zLine, n+1 );
1.902 + return zLine;
1.903 +}
1.904 +
1.905 +
1.906 +/*
1.907 +** Figure out the column names for the data returned by the statement
1.908 +** passed as the second argument.
1.909 +**
1.910 +** If parameter papColName is not NULL, then *papColName is set to point
1.911 +** at an array allocated using Tcl_Alloc(). It is the callers responsibility
1.912 +** to free this array using Tcl_Free(), and to decrement the reference
1.913 +** count of each Tcl_Obj* member of the array.
1.914 +**
1.915 +** The return value of this function is the number of columns of data
1.916 +** returned by pStmt (and hence the size of the *papColName array).
1.917 +**
1.918 +** If pArray is not NULL, then it contains the name of a Tcl array
1.919 +** variable. The "*" member of this array is set to a list containing
1.920 +** the names of the columns returned by the statement, in order from
1.921 +** left to right. e.g. if the names of the returned columns are a, b and
1.922 +** c, it does the equivalent of the tcl command:
1.923 +**
1.924 +** set ${pArray}(*) {a b c}
1.925 +*/
1.926 +static int
1.927 +computeColumnNames(
1.928 + Tcl_Interp *interp,
1.929 + sqlite3_stmt *pStmt, /* SQL statement */
1.930 + Tcl_Obj ***papColName, /* OUT: Array of column names */
1.931 + Tcl_Obj *pArray /* Name of array variable (may be null) */
1.932 +){
1.933 + int nCol;
1.934 +
1.935 + /* Compute column names */
1.936 + nCol = sqlite3_column_count(pStmt);
1.937 + if( papColName ){
1.938 + int i;
1.939 + Tcl_Obj **apColName = (Tcl_Obj**)Tcl_Alloc( sizeof(Tcl_Obj*)*nCol );
1.940 + for(i=0; i<nCol; i++){
1.941 + apColName[i] = dbTextToObj(sqlite3_column_name(pStmt,i));
1.942 + Tcl_IncrRefCount(apColName[i]);
1.943 + }
1.944 +
1.945 + /* If results are being stored in an array variable, then create
1.946 + ** the array(*) entry for that array
1.947 + */
1.948 + if( pArray ){
1.949 + Tcl_Obj *pColList = Tcl_NewObj();
1.950 + Tcl_Obj *pStar = Tcl_NewStringObj("*", -1);
1.951 + Tcl_IncrRefCount(pColList);
1.952 + for(i=0; i<nCol; i++){
1.953 + Tcl_ListObjAppendElement(interp, pColList, apColName[i]);
1.954 + }
1.955 + Tcl_IncrRefCount(pStar);
1.956 + Tcl_ObjSetVar2(interp, pArray, pStar, pColList,0);
1.957 + Tcl_DecrRefCount(pColList);
1.958 + Tcl_DecrRefCount(pStar);
1.959 + }
1.960 + *papColName = apColName;
1.961 + }
1.962 +
1.963 + return nCol;
1.964 +}
1.965 +
1.966 +/*
1.967 +** The "sqlite" command below creates a new Tcl command for each
1.968 +** connection it opens to an SQLite database. This routine is invoked
1.969 +** whenever one of those connection-specific commands is executed
1.970 +** in Tcl. For example, if you run Tcl code like this:
1.971 +**
1.972 +** sqlite3 db1 "my_database"
1.973 +** db1 close
1.974 +**
1.975 +** The first command opens a connection to the "my_database" database
1.976 +** and calls that connection "db1". The second command causes this
1.977 +** subroutine to be invoked.
1.978 +*/
1.979 +static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
1.980 + SqliteDb *pDb = (SqliteDb*)cd;
1.981 + int choice;
1.982 + int rc = TCL_OK;
1.983 + static const char *DB_strs[] = {
1.984 + "authorizer", "busy", "cache",
1.985 + "changes", "close", "collate",
1.986 + "collation_needed", "commit_hook", "complete",
1.987 + "copy", "enable_load_extension","errorcode",
1.988 + "eval", "exists", "function",
1.989 + "incrblob", "interrupt", "last_insert_rowid",
1.990 + "nullvalue", "onecolumn", "profile",
1.991 + "progress", "rekey", "rollback_hook",
1.992 + "timeout", "total_changes", "trace",
1.993 + "transaction", "update_hook", "version",
1.994 + 0
1.995 + };
1.996 + enum DB_enum {
1.997 + DB_AUTHORIZER, DB_BUSY, DB_CACHE,
1.998 + DB_CHANGES, DB_CLOSE, DB_COLLATE,
1.999 + DB_COLLATION_NEEDED, DB_COMMIT_HOOK, DB_COMPLETE,
1.1000 + DB_COPY, DB_ENABLE_LOAD_EXTENSION,DB_ERRORCODE,
1.1001 + DB_EVAL, DB_EXISTS, DB_FUNCTION,
1.1002 + DB_INCRBLOB, DB_INTERRUPT, DB_LAST_INSERT_ROWID,
1.1003 + DB_NULLVALUE, DB_ONECOLUMN, DB_PROFILE,
1.1004 + DB_PROGRESS, DB_REKEY, DB_ROLLBACK_HOOK,
1.1005 + DB_TIMEOUT, DB_TOTAL_CHANGES, DB_TRACE,
1.1006 + DB_TRANSACTION, DB_UPDATE_HOOK, DB_VERSION
1.1007 + };
1.1008 + /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
1.1009 +
1.1010 + if( objc<2 ){
1.1011 + Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
1.1012 + return TCL_ERROR;
1.1013 + }
1.1014 + if( Tcl_GetIndexFromObj(interp, objv[1], DB_strs, "option", 0, &choice) ){
1.1015 + return TCL_ERROR;
1.1016 + }
1.1017 +
1.1018 + switch( (enum DB_enum)choice ){
1.1019 +
1.1020 + /* $db authorizer ?CALLBACK?
1.1021 + **
1.1022 + ** Invoke the given callback to authorize each SQL operation as it is
1.1023 + ** compiled. 5 arguments are appended to the callback before it is
1.1024 + ** invoked:
1.1025 + **
1.1026 + ** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
1.1027 + ** (2) First descriptive name (depends on authorization type)
1.1028 + ** (3) Second descriptive name
1.1029 + ** (4) Name of the database (ex: "main", "temp")
1.1030 + ** (5) Name of trigger that is doing the access
1.1031 + **
1.1032 + ** The callback should return on of the following strings: SQLITE_OK,
1.1033 + ** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error.
1.1034 + **
1.1035 + ** If this method is invoked with no arguments, the current authorization
1.1036 + ** callback string is returned.
1.1037 + */
1.1038 + case DB_AUTHORIZER: {
1.1039 +#ifdef SQLITE_OMIT_AUTHORIZATION
1.1040 + Tcl_AppendResult(interp, "authorization not available in this build", 0);
1.1041 + return TCL_ERROR;
1.1042 +#else
1.1043 + if( objc>3 ){
1.1044 + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
1.1045 + return TCL_ERROR;
1.1046 + }else if( objc==2 ){
1.1047 + if( pDb->zAuth ){
1.1048 + Tcl_AppendResult(interp, pDb->zAuth, 0);
1.1049 + }
1.1050 + }else{
1.1051 + char *zAuth;
1.1052 + int len;
1.1053 + if( pDb->zAuth ){
1.1054 + Tcl_Free(pDb->zAuth);
1.1055 + }
1.1056 + zAuth = Tcl_GetStringFromObj(objv[2], &len);
1.1057 + if( zAuth && len>0 ){
1.1058 + pDb->zAuth = Tcl_Alloc( len + 1 );
1.1059 + memcpy(pDb->zAuth, zAuth, len+1);
1.1060 + }else{
1.1061 + pDb->zAuth = 0;
1.1062 + }
1.1063 + if( pDb->zAuth ){
1.1064 + pDb->interp = interp;
1.1065 + sqlite3_set_authorizer(pDb->db, auth_callback, pDb);
1.1066 + }else{
1.1067 + sqlite3_set_authorizer(pDb->db, 0, 0);
1.1068 + }
1.1069 + }
1.1070 +#endif
1.1071 + break;
1.1072 + }
1.1073 +
1.1074 + /* $db busy ?CALLBACK?
1.1075 + **
1.1076 + ** Invoke the given callback if an SQL statement attempts to open
1.1077 + ** a locked database file.
1.1078 + */
1.1079 + case DB_BUSY: {
1.1080 + if( objc>3 ){
1.1081 + Tcl_WrongNumArgs(interp, 2, objv, "CALLBACK");
1.1082 + return TCL_ERROR;
1.1083 + }else if( objc==2 ){
1.1084 + if( pDb->zBusy ){
1.1085 + Tcl_AppendResult(interp, pDb->zBusy, 0);
1.1086 + }
1.1087 + }else{
1.1088 + char *zBusy;
1.1089 + int len;
1.1090 + if( pDb->zBusy ){
1.1091 + Tcl_Free(pDb->zBusy);
1.1092 + }
1.1093 + zBusy = Tcl_GetStringFromObj(objv[2], &len);
1.1094 + if( zBusy && len>0 ){
1.1095 + pDb->zBusy = Tcl_Alloc( len + 1 );
1.1096 + memcpy(pDb->zBusy, zBusy, len+1);
1.1097 + }else{
1.1098 + pDb->zBusy = 0;
1.1099 + }
1.1100 + if( pDb->zBusy ){
1.1101 + pDb->interp = interp;
1.1102 + sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb);
1.1103 + }else{
1.1104 + sqlite3_busy_handler(pDb->db, 0, 0);
1.1105 + }
1.1106 + }
1.1107 + break;
1.1108 + }
1.1109 +
1.1110 + /* $db cache flush
1.1111 + ** $db cache size n
1.1112 + **
1.1113 + ** Flush the prepared statement cache, or set the maximum number of
1.1114 + ** cached statements.
1.1115 + */
1.1116 + case DB_CACHE: {
1.1117 + char *subCmd;
1.1118 + int n;
1.1119 +
1.1120 + if( objc<=2 ){
1.1121 + Tcl_WrongNumArgs(interp, 1, objv, "cache option ?arg?");
1.1122 + return TCL_ERROR;
1.1123 + }
1.1124 + subCmd = Tcl_GetStringFromObj( objv[2], 0 );
1.1125 + if( *subCmd=='f' && strcmp(subCmd,"flush")==0 ){
1.1126 + if( objc!=3 ){
1.1127 + Tcl_WrongNumArgs(interp, 2, objv, "flush");
1.1128 + return TCL_ERROR;
1.1129 + }else{
1.1130 + flushStmtCache( pDb );
1.1131 + }
1.1132 + }else if( *subCmd=='s' && strcmp(subCmd,"size")==0 ){
1.1133 + if( objc!=4 ){
1.1134 + Tcl_WrongNumArgs(interp, 2, objv, "size n");
1.1135 + return TCL_ERROR;
1.1136 + }else{
1.1137 + if( TCL_ERROR==Tcl_GetIntFromObj(interp, objv[3], &n) ){
1.1138 + Tcl_AppendResult( interp, "cannot convert \"",
1.1139 + Tcl_GetStringFromObj(objv[3],0), "\" to integer", 0);
1.1140 + return TCL_ERROR;
1.1141 + }else{
1.1142 + if( n<0 ){
1.1143 + flushStmtCache( pDb );
1.1144 + n = 0;
1.1145 + }else if( n>MAX_PREPARED_STMTS ){
1.1146 + n = MAX_PREPARED_STMTS;
1.1147 + }
1.1148 + pDb->maxStmt = n;
1.1149 + }
1.1150 + }
1.1151 + }else{
1.1152 + Tcl_AppendResult( interp, "bad option \"",
1.1153 + Tcl_GetStringFromObj(objv[2],0), "\": must be flush or size", 0);
1.1154 + return TCL_ERROR;
1.1155 + }
1.1156 + break;
1.1157 + }
1.1158 +
1.1159 + /* $db changes
1.1160 + **
1.1161 + ** Return the number of rows that were modified, inserted, or deleted by
1.1162 + ** the most recent INSERT, UPDATE or DELETE statement, not including
1.1163 + ** any changes made by trigger programs.
1.1164 + */
1.1165 + case DB_CHANGES: {
1.1166 + Tcl_Obj *pResult;
1.1167 + if( objc!=2 ){
1.1168 + Tcl_WrongNumArgs(interp, 2, objv, "");
1.1169 + return TCL_ERROR;
1.1170 + }
1.1171 + pResult = Tcl_GetObjResult(interp);
1.1172 + Tcl_SetIntObj(pResult, sqlite3_changes(pDb->db));
1.1173 + break;
1.1174 + }
1.1175 +
1.1176 + /* $db close
1.1177 + **
1.1178 + ** Shutdown the database
1.1179 + */
1.1180 + case DB_CLOSE: {
1.1181 + Tcl_DeleteCommand(interp, Tcl_GetStringFromObj(objv[0], 0));
1.1182 + break;
1.1183 + }
1.1184 +
1.1185 + /*
1.1186 + ** $db collate NAME SCRIPT
1.1187 + **
1.1188 + ** Create a new SQL collation function called NAME. Whenever
1.1189 + ** that function is called, invoke SCRIPT to evaluate the function.
1.1190 + */
1.1191 + case DB_COLLATE: {
1.1192 + SqlCollate *pCollate;
1.1193 + char *zName;
1.1194 + char *zScript;
1.1195 + int nScript;
1.1196 + if( objc!=4 ){
1.1197 + Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");
1.1198 + return TCL_ERROR;
1.1199 + }
1.1200 + zName = Tcl_GetStringFromObj(objv[2], 0);
1.1201 + zScript = Tcl_GetStringFromObj(objv[3], &nScript);
1.1202 + pCollate = (SqlCollate*)Tcl_Alloc( sizeof(*pCollate) + nScript + 1 );
1.1203 + if( pCollate==0 ) return TCL_ERROR;
1.1204 + pCollate->interp = interp;
1.1205 + pCollate->pNext = pDb->pCollate;
1.1206 + pCollate->zScript = (char*)&pCollate[1];
1.1207 + pDb->pCollate = pCollate;
1.1208 + memcpy(pCollate->zScript, zScript, nScript+1);
1.1209 + if( sqlite3_create_collation(pDb->db, zName, SQLITE_UTF8,
1.1210 + pCollate, tclSqlCollate) ){
1.1211 + Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
1.1212 + return TCL_ERROR;
1.1213 + }
1.1214 + break;
1.1215 + }
1.1216 +
1.1217 + /*
1.1218 + ** $db collation_needed SCRIPT
1.1219 + **
1.1220 + ** Create a new SQL collation function called NAME. Whenever
1.1221 + ** that function is called, invoke SCRIPT to evaluate the function.
1.1222 + */
1.1223 + case DB_COLLATION_NEEDED: {
1.1224 + if( objc!=3 ){
1.1225 + Tcl_WrongNumArgs(interp, 2, objv, "SCRIPT");
1.1226 + return TCL_ERROR;
1.1227 + }
1.1228 + if( pDb->pCollateNeeded ){
1.1229 + Tcl_DecrRefCount(pDb->pCollateNeeded);
1.1230 + }
1.1231 + pDb->pCollateNeeded = Tcl_DuplicateObj(objv[2]);
1.1232 + Tcl_IncrRefCount(pDb->pCollateNeeded);
1.1233 + sqlite3_collation_needed(pDb->db, pDb, tclCollateNeeded);
1.1234 + break;
1.1235 + }
1.1236 +
1.1237 + /* $db commit_hook ?CALLBACK?
1.1238 + **
1.1239 + ** Invoke the given callback just before committing every SQL transaction.
1.1240 + ** If the callback throws an exception or returns non-zero, then the
1.1241 + ** transaction is aborted. If CALLBACK is an empty string, the callback
1.1242 + ** is disabled.
1.1243 + */
1.1244 + case DB_COMMIT_HOOK: {
1.1245 + if( objc>3 ){
1.1246 + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
1.1247 + return TCL_ERROR;
1.1248 + }else if( objc==2 ){
1.1249 + if( pDb->zCommit ){
1.1250 + Tcl_AppendResult(interp, pDb->zCommit, 0);
1.1251 + }
1.1252 + }else{
1.1253 + char *zCommit;
1.1254 + int len;
1.1255 + if( pDb->zCommit ){
1.1256 + Tcl_Free(pDb->zCommit);
1.1257 + }
1.1258 + zCommit = Tcl_GetStringFromObj(objv[2], &len);
1.1259 + if( zCommit && len>0 ){
1.1260 + pDb->zCommit = Tcl_Alloc( len + 1 );
1.1261 + memcpy(pDb->zCommit, zCommit, len+1);
1.1262 + }else{
1.1263 + pDb->zCommit = 0;
1.1264 + }
1.1265 + if( pDb->zCommit ){
1.1266 + pDb->interp = interp;
1.1267 + sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb);
1.1268 + }else{
1.1269 + sqlite3_commit_hook(pDb->db, 0, 0);
1.1270 + }
1.1271 + }
1.1272 + break;
1.1273 + }
1.1274 +
1.1275 + /* $db complete SQL
1.1276 + **
1.1277 + ** Return TRUE if SQL is a complete SQL statement. Return FALSE if
1.1278 + ** additional lines of input are needed. This is similar to the
1.1279 + ** built-in "info complete" command of Tcl.
1.1280 + */
1.1281 + case DB_COMPLETE: {
1.1282 +#ifndef SQLITE_OMIT_COMPLETE
1.1283 + Tcl_Obj *pResult;
1.1284 + int isComplete;
1.1285 + if( objc!=3 ){
1.1286 + Tcl_WrongNumArgs(interp, 2, objv, "SQL");
1.1287 + return TCL_ERROR;
1.1288 + }
1.1289 + isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) );
1.1290 + pResult = Tcl_GetObjResult(interp);
1.1291 + Tcl_SetBooleanObj(pResult, isComplete);
1.1292 +#endif
1.1293 + break;
1.1294 + }
1.1295 +
1.1296 + /* $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
1.1297 + **
1.1298 + ** Copy data into table from filename, optionally using SEPARATOR
1.1299 + ** as column separators. If a column contains a null string, or the
1.1300 + ** value of NULLINDICATOR, a NULL is inserted for the column.
1.1301 + ** conflict-algorithm is one of the sqlite conflict algorithms:
1.1302 + ** rollback, abort, fail, ignore, replace
1.1303 + ** On success, return the number of lines processed, not necessarily same
1.1304 + ** as 'db changes' due to conflict-algorithm selected.
1.1305 + **
1.1306 + ** This code is basically an implementation/enhancement of
1.1307 + ** the sqlite3 shell.c ".import" command.
1.1308 + **
1.1309 + ** This command usage is equivalent to the sqlite2.x COPY statement,
1.1310 + ** which imports file data into a table using the PostgreSQL COPY file format:
1.1311 + ** $db copy $conflit_algo $table_name $filename \t \\N
1.1312 + */
1.1313 + case DB_COPY: {
1.1314 + char *zTable; /* Insert data into this table */
1.1315 + char *zFile; /* The file from which to extract data */
1.1316 + char *zConflict; /* The conflict algorithm to use */
1.1317 + sqlite3_stmt *pStmt; /* A statement */
1.1318 + int nCol; /* Number of columns in the table */
1.1319 + int nByte; /* Number of bytes in an SQL string */
1.1320 + int i, j; /* Loop counters */
1.1321 + int nSep; /* Number of bytes in zSep[] */
1.1322 + int nNull; /* Number of bytes in zNull[] */
1.1323 + char *zSql; /* An SQL statement */
1.1324 + char *zLine; /* A single line of input from the file */
1.1325 + char **azCol; /* zLine[] broken up into columns */
1.1326 + char *zCommit; /* How to commit changes */
1.1327 + FILE *in; /* The input file */
1.1328 + int lineno = 0; /* Line number of input file */
1.1329 + char zLineNum[80]; /* Line number print buffer */
1.1330 + Tcl_Obj *pResult; /* interp result */
1.1331 +
1.1332 + char *zSep;
1.1333 + char *zNull;
1.1334 + if( objc<5 || objc>7 ){
1.1335 + Tcl_WrongNumArgs(interp, 2, objv,
1.1336 + "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");
1.1337 + return TCL_ERROR;
1.1338 + }
1.1339 + if( objc>=6 ){
1.1340 + zSep = Tcl_GetStringFromObj(objv[5], 0);
1.1341 + }else{
1.1342 + zSep = "\t";
1.1343 + }
1.1344 + if( objc>=7 ){
1.1345 + zNull = Tcl_GetStringFromObj(objv[6], 0);
1.1346 + }else{
1.1347 + zNull = "";
1.1348 + }
1.1349 + zConflict = Tcl_GetStringFromObj(objv[2], 0);
1.1350 + zTable = Tcl_GetStringFromObj(objv[3], 0);
1.1351 + zFile = Tcl_GetStringFromObj(objv[4], 0);
1.1352 + nSep = strlen(zSep);
1.1353 + nNull = strlen(zNull);
1.1354 + if( nSep==0 ){
1.1355 + Tcl_AppendResult(interp,"Error: non-null separator required for copy",0);
1.1356 + return TCL_ERROR;
1.1357 + }
1.1358 + if(strcmp(zConflict, "rollback") != 0 &&
1.1359 + strcmp(zConflict, "abort" ) != 0 &&
1.1360 + strcmp(zConflict, "fail" ) != 0 &&
1.1361 + strcmp(zConflict, "ignore" ) != 0 &&
1.1362 + strcmp(zConflict, "replace" ) != 0 ) {
1.1363 + Tcl_AppendResult(interp, "Error: \"", zConflict,
1.1364 + "\", conflict-algorithm must be one of: rollback, "
1.1365 + "abort, fail, ignore, or replace", 0);
1.1366 + return TCL_ERROR;
1.1367 + }
1.1368 + zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
1.1369 + if( zSql==0 ){
1.1370 + Tcl_AppendResult(interp, "Error: no such table: ", zTable, 0);
1.1371 + return TCL_ERROR;
1.1372 + }
1.1373 + nByte = strlen(zSql);
1.1374 + rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
1.1375 + sqlite3_free(zSql);
1.1376 + if( rc ){
1.1377 + Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), 0);
1.1378 + nCol = 0;
1.1379 + }else{
1.1380 + nCol = sqlite3_column_count(pStmt);
1.1381 + }
1.1382 + sqlite3_finalize(pStmt);
1.1383 + if( nCol==0 ) {
1.1384 + return TCL_ERROR;
1.1385 + }
1.1386 + zSql = malloc( nByte + 50 + nCol*2 );
1.1387 + if( zSql==0 ) {
1.1388 + Tcl_AppendResult(interp, "Error: can't malloc()", 0);
1.1389 + return TCL_ERROR;
1.1390 + }
1.1391 + sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",
1.1392 + zConflict, zTable);
1.1393 + j = strlen(zSql);
1.1394 + for(i=1; i<nCol; i++){
1.1395 + zSql[j++] = ',';
1.1396 + zSql[j++] = '?';
1.1397 + }
1.1398 + zSql[j++] = ')';
1.1399 + zSql[j] = 0;
1.1400 + rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
1.1401 + free(zSql);
1.1402 + if( rc ){
1.1403 + Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), 0);
1.1404 + sqlite3_finalize(pStmt);
1.1405 + return TCL_ERROR;
1.1406 + }
1.1407 + in = fopen(zFile, "rb");
1.1408 + if( in==0 ){
1.1409 + Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, NULL);
1.1410 + sqlite3_finalize(pStmt);
1.1411 + return TCL_ERROR;
1.1412 + }
1.1413 + azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1.1414 + if( azCol==0 ) {
1.1415 + Tcl_AppendResult(interp, "Error: can't malloc()", 0);
1.1416 + fclose(in);
1.1417 + return TCL_ERROR;
1.1418 + }
1.1419 + (void)sqlite3_exec(pDb->db, "BEGIN", 0, 0, 0);
1.1420 + zCommit = "COMMIT";
1.1421 + while( (zLine = local_getline(0, in))!=0 ){
1.1422 + char *z;
1.1423 + i = 0;
1.1424 + lineno++;
1.1425 + azCol[0] = zLine;
1.1426 + for(i=0, z=zLine; *z; z++){
1.1427 + if( *z==zSep[0] && strncmp(z, zSep, nSep)==0 ){
1.1428 + *z = 0;
1.1429 + i++;
1.1430 + if( i<nCol ){
1.1431 + azCol[i] = &z[nSep];
1.1432 + z += nSep-1;
1.1433 + }
1.1434 + }
1.1435 + }
1.1436 + if( i+1!=nCol ){
1.1437 + char *zErr;
1.1438 + int nErr = strlen(zFile) + 200;
1.1439 + zErr = malloc(nErr);
1.1440 + if( zErr ){
1.1441 + sqlite3_snprintf(nErr, zErr,
1.1442 + "Error: %s line %d: expected %d columns of data but found %d",
1.1443 + zFile, lineno, nCol, i+1);
1.1444 + Tcl_AppendResult(interp, zErr, 0);
1.1445 + free(zErr);
1.1446 + }
1.1447 + zCommit = "ROLLBACK";
1.1448 + break;
1.1449 + }
1.1450 + for(i=0; i<nCol; i++){
1.1451 + /* check for null data, if so, bind as null */
1.1452 + if ((nNull>0 && strcmp(azCol[i], zNull)==0) || strlen(azCol[i])==0) {
1.1453 + sqlite3_bind_null(pStmt, i+1);
1.1454 + }else{
1.1455 + sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1.1456 + }
1.1457 + }
1.1458 + sqlite3_step(pStmt);
1.1459 + rc = sqlite3_reset(pStmt);
1.1460 + free(zLine);
1.1461 + if( rc!=SQLITE_OK ){
1.1462 + Tcl_AppendResult(interp,"Error: ", sqlite3_errmsg(pDb->db), 0);
1.1463 + zCommit = "ROLLBACK";
1.1464 + break;
1.1465 + }
1.1466 + }
1.1467 + free(azCol);
1.1468 + fclose(in);
1.1469 + sqlite3_finalize(pStmt);
1.1470 + (void)sqlite3_exec(pDb->db, zCommit, 0, 0, 0);
1.1471 +
1.1472 + if( zCommit[0] == 'C' ){
1.1473 + /* success, set result as number of lines processed */
1.1474 + pResult = Tcl_GetObjResult(interp);
1.1475 + Tcl_SetIntObj(pResult, lineno);
1.1476 + rc = TCL_OK;
1.1477 + }else{
1.1478 + /* failure, append lineno where failed */
1.1479 + sqlite3_snprintf(sizeof(zLineNum), zLineNum,"%d",lineno);
1.1480 + Tcl_AppendResult(interp,", failed while processing line: ",zLineNum,0);
1.1481 + rc = TCL_ERROR;
1.1482 + }
1.1483 + break;
1.1484 + }
1.1485 +
1.1486 + /*
1.1487 + ** $db enable_load_extension BOOLEAN
1.1488 + **
1.1489 + ** Turn the extension loading feature on or off. It if off by
1.1490 + ** default.
1.1491 + */
1.1492 + case DB_ENABLE_LOAD_EXTENSION: {
1.1493 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.1494 + int onoff;
1.1495 + if( objc!=3 ){
1.1496 + Tcl_WrongNumArgs(interp, 2, objv, "BOOLEAN");
1.1497 + return TCL_ERROR;
1.1498 + }
1.1499 + if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){
1.1500 + return TCL_ERROR;
1.1501 + }
1.1502 + sqlite3_enable_load_extension(pDb->db, onoff);
1.1503 + break;
1.1504 +#else
1.1505 + Tcl_AppendResult(interp, "extension loading is turned off at compile-time",
1.1506 + 0);
1.1507 + return TCL_ERROR;
1.1508 +#endif
1.1509 + }
1.1510 +
1.1511 + /*
1.1512 + ** $db errorcode
1.1513 + **
1.1514 + ** Return the numeric error code that was returned by the most recent
1.1515 + ** call to sqlite3_exec().
1.1516 + */
1.1517 + case DB_ERRORCODE: {
1.1518 + Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_errcode(pDb->db)));
1.1519 + break;
1.1520 + }
1.1521 +
1.1522 + /*
1.1523 + ** $db eval $sql ?array? ?{ ...code... }?
1.1524 + ** $db onecolumn $sql
1.1525 + **
1.1526 + ** The SQL statement in $sql is evaluated. For each row, the values are
1.1527 + ** placed in elements of the array named "array" and ...code... is executed.
1.1528 + ** If "array" and "code" are omitted, then no callback is every invoked.
1.1529 + ** If "array" is an empty string, then the values are placed in variables
1.1530 + ** that have the same name as the fields extracted by the query.
1.1531 + **
1.1532 + ** The onecolumn method is the equivalent of:
1.1533 + ** lindex [$db eval $sql] 0
1.1534 + */
1.1535 + case DB_ONECOLUMN:
1.1536 + case DB_EVAL:
1.1537 + case DB_EXISTS: {
1.1538 + char const *zSql; /* Next SQL statement to execute */
1.1539 + char const *zLeft; /* What is left after first stmt in zSql */
1.1540 + sqlite3_stmt *pStmt; /* Compiled SQL statment */
1.1541 + Tcl_Obj *pArray; /* Name of array into which results are written */
1.1542 + Tcl_Obj *pScript; /* Script to run for each result set */
1.1543 + Tcl_Obj **apParm; /* Parameters that need a Tcl_DecrRefCount() */
1.1544 + int nParm; /* Number of entries used in apParm[] */
1.1545 + Tcl_Obj *aParm[10]; /* Static space for apParm[] in the common case */
1.1546 + Tcl_Obj *pRet; /* Value to be returned */
1.1547 + SqlPreparedStmt *pPreStmt; /* Pointer to a prepared statement */
1.1548 + int rc2;
1.1549 +
1.1550 + if( choice==DB_EVAL ){
1.1551 + if( objc<3 || objc>5 ){
1.1552 + Tcl_WrongNumArgs(interp, 2, objv, "SQL ?ARRAY-NAME? ?SCRIPT?");
1.1553 + return TCL_ERROR;
1.1554 + }
1.1555 + pRet = Tcl_NewObj();
1.1556 + Tcl_IncrRefCount(pRet);
1.1557 + }else{
1.1558 + if( objc!=3 ){
1.1559 + Tcl_WrongNumArgs(interp, 2, objv, "SQL");
1.1560 + return TCL_ERROR;
1.1561 + }
1.1562 + if( choice==DB_EXISTS ){
1.1563 + pRet = Tcl_NewBooleanObj(0);
1.1564 + Tcl_IncrRefCount(pRet);
1.1565 + }else{
1.1566 + pRet = 0;
1.1567 + }
1.1568 + }
1.1569 + if( objc==3 ){
1.1570 + pArray = pScript = 0;
1.1571 + }else if( objc==4 ){
1.1572 + pArray = 0;
1.1573 + pScript = objv[3];
1.1574 + }else{
1.1575 + pArray = objv[3];
1.1576 + if( Tcl_GetString(pArray)[0]==0 ) pArray = 0;
1.1577 + pScript = objv[4];
1.1578 + }
1.1579 +
1.1580 + Tcl_IncrRefCount(objv[2]);
1.1581 + zSql = Tcl_GetStringFromObj(objv[2], 0);
1.1582 + while( rc==TCL_OK && zSql[0] ){
1.1583 + int i; /* Loop counter */
1.1584 + int nVar; /* Number of bind parameters in the pStmt */
1.1585 + int nCol = -1; /* Number of columns in the result set */
1.1586 + Tcl_Obj **apColName = 0; /* Array of column names */
1.1587 + int len; /* String length of zSql */
1.1588 +
1.1589 + /* Try to find a SQL statement that has already been compiled and
1.1590 + ** which matches the next sequence of SQL.
1.1591 + */
1.1592 + pStmt = 0;
1.1593 + len = strlen(zSql);
1.1594 + for(pPreStmt = pDb->stmtList; pPreStmt; pPreStmt=pPreStmt->pNext){
1.1595 + int n = pPreStmt->nSql;
1.1596 + if( len>=n
1.1597 + && memcmp(pPreStmt->zSql, zSql, n)==0
1.1598 + && (zSql[n]==0 || zSql[n-1]==';')
1.1599 + ){
1.1600 + pStmt = pPreStmt->pStmt;
1.1601 + zLeft = &zSql[pPreStmt->nSql];
1.1602 +
1.1603 + /* When a prepared statement is found, unlink it from the
1.1604 + ** cache list. It will later be added back to the beginning
1.1605 + ** of the cache list in order to implement LRU replacement.
1.1606 + */
1.1607 + if( pPreStmt->pPrev ){
1.1608 + pPreStmt->pPrev->pNext = pPreStmt->pNext;
1.1609 + }else{
1.1610 + pDb->stmtList = pPreStmt->pNext;
1.1611 + }
1.1612 + if( pPreStmt->pNext ){
1.1613 + pPreStmt->pNext->pPrev = pPreStmt->pPrev;
1.1614 + }else{
1.1615 + pDb->stmtLast = pPreStmt->pPrev;
1.1616 + }
1.1617 + pDb->nStmt--;
1.1618 + break;
1.1619 + }
1.1620 + }
1.1621 +
1.1622 + /* If no prepared statement was found. Compile the SQL text
1.1623 + */
1.1624 + if( pStmt==0 ){
1.1625 + if( SQLITE_OK!=sqlite3_prepare_v2(pDb->db, zSql, -1, &pStmt, &zLeft) ){
1.1626 + Tcl_SetObjResult(interp, dbTextToObj(sqlite3_errmsg(pDb->db)));
1.1627 + rc = TCL_ERROR;
1.1628 + break;
1.1629 + }
1.1630 + if( pStmt==0 ){
1.1631 + if( SQLITE_OK!=sqlite3_errcode(pDb->db) ){
1.1632 + /* A compile-time error in the statement
1.1633 + */
1.1634 + Tcl_SetObjResult(interp, dbTextToObj(sqlite3_errmsg(pDb->db)));
1.1635 + rc = TCL_ERROR;
1.1636 + break;
1.1637 + }else{
1.1638 + /* The statement was a no-op. Continue to the next statement
1.1639 + ** in the SQL string.
1.1640 + */
1.1641 + zSql = zLeft;
1.1642 + continue;
1.1643 + }
1.1644 + }
1.1645 + assert( pPreStmt==0 );
1.1646 + }
1.1647 +
1.1648 + /* Bind values to parameters that begin with $ or :
1.1649 + */
1.1650 + nVar = sqlite3_bind_parameter_count(pStmt);
1.1651 + nParm = 0;
1.1652 + if( nVar>sizeof(aParm)/sizeof(aParm[0]) ){
1.1653 + apParm = (Tcl_Obj**)Tcl_Alloc(nVar*sizeof(apParm[0]));
1.1654 + }else{
1.1655 + apParm = aParm;
1.1656 + }
1.1657 + for(i=1; i<=nVar; i++){
1.1658 + const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
1.1659 + if( zVar!=0 && (zVar[0]=='$' || zVar[0]==':' || zVar[0]=='@') ){
1.1660 + Tcl_Obj *pVar = Tcl_GetVar2Ex(interp, &zVar[1], 0, 0);
1.1661 + if( pVar ){
1.1662 + int n;
1.1663 + u8 *data;
1.1664 + char *zType = pVar->typePtr ? pVar->typePtr->name : "";
1.1665 + char c = zType[0];
1.1666 + if( zVar[0]=='@' ||
1.1667 + (c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0) ){
1.1668 + /* Load a BLOB type if the Tcl variable is a bytearray and
1.1669 + ** it has no string representation or the host
1.1670 + ** parameter name begins with "@". */
1.1671 + data = Tcl_GetByteArrayFromObj(pVar, &n);
1.1672 + sqlite3_bind_blob(pStmt, i, data, n, SQLITE_STATIC);
1.1673 + Tcl_IncrRefCount(pVar);
1.1674 + apParm[nParm++] = pVar;
1.1675 + }else if( c=='b' && strcmp(zType,"boolean")==0 ){
1.1676 + Tcl_GetIntFromObj(interp, pVar, &n);
1.1677 + sqlite3_bind_int(pStmt, i, n);
1.1678 + }else if( c=='d' && strcmp(zType,"double")==0 ){
1.1679 + double r;
1.1680 + Tcl_GetDoubleFromObj(interp, pVar, &r);
1.1681 + sqlite3_bind_double(pStmt, i, r);
1.1682 + }else if( (c=='w' && strcmp(zType,"wideInt")==0) ||
1.1683 + (c=='i' && strcmp(zType,"int")==0) ){
1.1684 + Tcl_WideInt v;
1.1685 + Tcl_GetWideIntFromObj(interp, pVar, &v);
1.1686 + sqlite3_bind_int64(pStmt, i, v);
1.1687 + }else{
1.1688 + data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);
1.1689 + sqlite3_bind_text(pStmt, i, (char *)data, n, SQLITE_STATIC);
1.1690 + Tcl_IncrRefCount(pVar);
1.1691 + apParm[nParm++] = pVar;
1.1692 + }
1.1693 + }else{
1.1694 + sqlite3_bind_null( pStmt, i );
1.1695 + }
1.1696 + }
1.1697 + }
1.1698 +
1.1699 + /* Execute the SQL
1.1700 + */
1.1701 + while( rc==TCL_OK && pStmt && SQLITE_ROW==sqlite3_step(pStmt) ){
1.1702 +
1.1703 + /* Compute column names. This must be done after the first successful
1.1704 + ** call to sqlite3_step(), in case the query is recompiled and the
1.1705 + ** number or names of the returned columns changes.
1.1706 + */
1.1707 + assert(!pArray||pScript);
1.1708 + if (nCol < 0) {
1.1709 + Tcl_Obj ***ap = (pScript?&apColName:0);
1.1710 + nCol = computeColumnNames(interp, pStmt, ap, pArray);
1.1711 + }
1.1712 +
1.1713 + for(i=0; i<nCol; i++){
1.1714 + Tcl_Obj *pVal;
1.1715 +
1.1716 + /* Set pVal to contain the i'th column of this row. */
1.1717 + switch( sqlite3_column_type(pStmt, i) ){
1.1718 + case SQLITE_BLOB: {
1.1719 + int bytes = sqlite3_column_bytes(pStmt, i);
1.1720 + const char *zBlob = sqlite3_column_blob(pStmt, i);
1.1721 + if( !zBlob ) bytes = 0;
1.1722 + pVal = Tcl_NewByteArrayObj((u8*)zBlob, bytes);
1.1723 + break;
1.1724 + }
1.1725 + case SQLITE_INTEGER: {
1.1726 + sqlite_int64 v = sqlite3_column_int64(pStmt, i);
1.1727 + if( v>=-2147483647 && v<=2147483647 ){
1.1728 + pVal = Tcl_NewIntObj(v);
1.1729 + }else{
1.1730 + pVal = Tcl_NewWideIntObj(v);
1.1731 + }
1.1732 + break;
1.1733 + }
1.1734 + case SQLITE_FLOAT: {
1.1735 + double r = sqlite3_column_double(pStmt, i);
1.1736 + pVal = Tcl_NewDoubleObj(r);
1.1737 + break;
1.1738 + }
1.1739 + case SQLITE_NULL: {
1.1740 + pVal = dbTextToObj(pDb->zNull);
1.1741 + break;
1.1742 + }
1.1743 + default: {
1.1744 + pVal = dbTextToObj((char *)sqlite3_column_text(pStmt, i));
1.1745 + break;
1.1746 + }
1.1747 + }
1.1748 +
1.1749 + if( pScript ){
1.1750 + if( pArray==0 ){
1.1751 + Tcl_ObjSetVar2(interp, apColName[i], 0, pVal, 0);
1.1752 + }else{
1.1753 + Tcl_ObjSetVar2(interp, pArray, apColName[i], pVal, 0);
1.1754 + }
1.1755 + }else if( choice==DB_ONECOLUMN ){
1.1756 + assert( pRet==0 );
1.1757 + if( pRet==0 ){
1.1758 + pRet = pVal;
1.1759 + Tcl_IncrRefCount(pRet);
1.1760 + }
1.1761 + rc = TCL_BREAK;
1.1762 + i = nCol;
1.1763 + }else if( choice==DB_EXISTS ){
1.1764 + Tcl_DecrRefCount(pRet);
1.1765 + pRet = Tcl_NewBooleanObj(1);
1.1766 + Tcl_IncrRefCount(pRet);
1.1767 + rc = TCL_BREAK;
1.1768 + i = nCol;
1.1769 + }else{
1.1770 + Tcl_ListObjAppendElement(interp, pRet, pVal);
1.1771 + }
1.1772 + }
1.1773 +
1.1774 + if( pScript ){
1.1775 + rc = Tcl_EvalObjEx(interp, pScript, 0);
1.1776 + if( rc==TCL_CONTINUE ){
1.1777 + rc = TCL_OK;
1.1778 + }
1.1779 + }
1.1780 + }
1.1781 + if( rc==TCL_BREAK ){
1.1782 + rc = TCL_OK;
1.1783 + }
1.1784 +
1.1785 + /* Free the column name objects */
1.1786 + if( pScript ){
1.1787 + /* If the query returned no rows, but an array variable was
1.1788 + ** specified, call computeColumnNames() now to populate the
1.1789 + ** arrayname(*) variable.
1.1790 + */
1.1791 + if (pArray && nCol < 0) {
1.1792 + Tcl_Obj ***ap = (pScript?&apColName:0);
1.1793 + nCol = computeColumnNames(interp, pStmt, ap, pArray);
1.1794 + }
1.1795 + for(i=0; i<nCol; i++){
1.1796 + Tcl_DecrRefCount(apColName[i]);
1.1797 + }
1.1798 + Tcl_Free((char*)apColName);
1.1799 + }
1.1800 +
1.1801 + /* Free the bound string and blob parameters */
1.1802 + for(i=0; i<nParm; i++){
1.1803 + Tcl_DecrRefCount(apParm[i]);
1.1804 + }
1.1805 + if( apParm!=aParm ){
1.1806 + Tcl_Free((char*)apParm);
1.1807 + }
1.1808 +
1.1809 + /* Reset the statement. If the result code is SQLITE_SCHEMA, then
1.1810 + ** flush the statement cache and try the statement again.
1.1811 + */
1.1812 + rc2 = sqlite3_reset(pStmt);
1.1813 + if( SQLITE_OK!=rc2 ){
1.1814 + /* If a run-time error occurs, report the error and stop reading
1.1815 + ** the SQL
1.1816 + */
1.1817 + Tcl_SetObjResult(interp, dbTextToObj(sqlite3_errmsg(pDb->db)));
1.1818 + sqlite3_finalize(pStmt);
1.1819 + rc = TCL_ERROR;
1.1820 + if( pPreStmt ) Tcl_Free((char*)pPreStmt);
1.1821 + break;
1.1822 + }else if( pDb->maxStmt<=0 ){
1.1823 + /* If the cache is turned off, deallocated the statement */
1.1824 + if( pPreStmt ) Tcl_Free((char*)pPreStmt);
1.1825 + sqlite3_finalize(pStmt);
1.1826 + }else{
1.1827 + /* Everything worked and the cache is operational.
1.1828 + ** Create a new SqlPreparedStmt structure if we need one.
1.1829 + ** (If we already have one we can just reuse it.)
1.1830 + */
1.1831 + if( pPreStmt==0 ){
1.1832 + len = zLeft - zSql;
1.1833 + pPreStmt = (SqlPreparedStmt*)Tcl_Alloc( sizeof(*pPreStmt) );
1.1834 + if( pPreStmt==0 ) return TCL_ERROR;
1.1835 + pPreStmt->pStmt = pStmt;
1.1836 + pPreStmt->nSql = len;
1.1837 + pPreStmt->zSql = sqlite3_sql(pStmt);
1.1838 + assert( strlen(pPreStmt->zSql)==len );
1.1839 + assert( 0==memcmp(pPreStmt->zSql, zSql, len) );
1.1840 + }
1.1841 +
1.1842 + /* Add the prepared statement to the beginning of the cache list
1.1843 + */
1.1844 + pPreStmt->pNext = pDb->stmtList;
1.1845 + pPreStmt->pPrev = 0;
1.1846 + if( pDb->stmtList ){
1.1847 + pDb->stmtList->pPrev = pPreStmt;
1.1848 + }
1.1849 + pDb->stmtList = pPreStmt;
1.1850 + if( pDb->stmtLast==0 ){
1.1851 + assert( pDb->nStmt==0 );
1.1852 + pDb->stmtLast = pPreStmt;
1.1853 + }else{
1.1854 + assert( pDb->nStmt>0 );
1.1855 + }
1.1856 + pDb->nStmt++;
1.1857 +
1.1858 + /* If we have too many statement in cache, remove the surplus from the
1.1859 + ** end of the cache list.
1.1860 + */
1.1861 + while( pDb->nStmt>pDb->maxStmt ){
1.1862 + sqlite3_finalize(pDb->stmtLast->pStmt);
1.1863 + pDb->stmtLast = pDb->stmtLast->pPrev;
1.1864 + Tcl_Free((char*)pDb->stmtLast->pNext);
1.1865 + pDb->stmtLast->pNext = 0;
1.1866 + pDb->nStmt--;
1.1867 + }
1.1868 + }
1.1869 +
1.1870 + /* Proceed to the next statement */
1.1871 + zSql = zLeft;
1.1872 + }
1.1873 + Tcl_DecrRefCount(objv[2]);
1.1874 +
1.1875 + if( pRet ){
1.1876 + if( rc==TCL_OK ){
1.1877 + Tcl_SetObjResult(interp, pRet);
1.1878 + }
1.1879 + Tcl_DecrRefCount(pRet);
1.1880 + }else if( rc==TCL_OK ){
1.1881 + Tcl_ResetResult(interp);
1.1882 + }
1.1883 + break;
1.1884 + }
1.1885 +
1.1886 + /*
1.1887 + ** $db function NAME [-argcount N] SCRIPT
1.1888 + **
1.1889 + ** Create a new SQL function called NAME. Whenever that function is
1.1890 + ** called, invoke SCRIPT to evaluate the function.
1.1891 + */
1.1892 + case DB_FUNCTION: {
1.1893 + SqlFunc *pFunc;
1.1894 + Tcl_Obj *pScript;
1.1895 + char *zName;
1.1896 + int nArg = -1;
1.1897 + if( objc==6 ){
1.1898 + const char *z = Tcl_GetString(objv[3]);
1.1899 + int n = strlen(z);
1.1900 + if( n>2 && strncmp(z, "-argcount",n)==0 ){
1.1901 + if( Tcl_GetIntFromObj(interp, objv[4], &nArg) ) return TCL_ERROR;
1.1902 + if( nArg<0 ){
1.1903 + Tcl_AppendResult(interp, "number of arguments must be non-negative",
1.1904 + (char*)0);
1.1905 + return TCL_ERROR;
1.1906 + }
1.1907 + }
1.1908 + pScript = objv[5];
1.1909 + }else if( objc!=4 ){
1.1910 + Tcl_WrongNumArgs(interp, 2, objv, "NAME [-argcount N] SCRIPT");
1.1911 + return TCL_ERROR;
1.1912 + }else{
1.1913 + pScript = objv[3];
1.1914 + }
1.1915 + zName = Tcl_GetStringFromObj(objv[2], 0);
1.1916 + pFunc = findSqlFunc(pDb, zName);
1.1917 + if( pFunc==0 ) return TCL_ERROR;
1.1918 + if( pFunc->pScript ){
1.1919 + Tcl_DecrRefCount(pFunc->pScript);
1.1920 + }
1.1921 + pFunc->pScript = pScript;
1.1922 + Tcl_IncrRefCount(pScript);
1.1923 + pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript);
1.1924 + rc = sqlite3_create_function(pDb->db, zName, nArg, SQLITE_UTF8,
1.1925 + pFunc, tclSqlFunc, 0, 0);
1.1926 + if( rc!=SQLITE_OK ){
1.1927 + rc = TCL_ERROR;
1.1928 + Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
1.1929 + }
1.1930 + break;
1.1931 + }
1.1932 +
1.1933 + /*
1.1934 + ** $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
1.1935 + */
1.1936 + case DB_INCRBLOB: {
1.1937 +#ifdef SQLITE_OMIT_INCRBLOB
1.1938 + Tcl_AppendResult(interp, "incrblob not available in this build", 0);
1.1939 + return TCL_ERROR;
1.1940 +#else
1.1941 + int isReadonly = 0;
1.1942 + const char *zDb = "main";
1.1943 + const char *zTable;
1.1944 + const char *zColumn;
1.1945 + sqlite_int64 iRow;
1.1946 +
1.1947 + /* Check for the -readonly option */
1.1948 + if( objc>3 && strcmp(Tcl_GetString(objv[2]), "-readonly")==0 ){
1.1949 + isReadonly = 1;
1.1950 + }
1.1951 +
1.1952 + if( objc!=(5+isReadonly) && objc!=(6+isReadonly) ){
1.1953 + Tcl_WrongNumArgs(interp, 2, objv, "?-readonly? ?DB? TABLE COLUMN ROWID");
1.1954 + return TCL_ERROR;
1.1955 + }
1.1956 +
1.1957 + if( objc==(6+isReadonly) ){
1.1958 + zDb = Tcl_GetString(objv[2]);
1.1959 + }
1.1960 + zTable = Tcl_GetString(objv[objc-3]);
1.1961 + zColumn = Tcl_GetString(objv[objc-2]);
1.1962 + rc = Tcl_GetWideIntFromObj(interp, objv[objc-1], &iRow);
1.1963 +
1.1964 + if( rc==TCL_OK ){
1.1965 + rc = createIncrblobChannel(
1.1966 + interp, pDb, zDb, zTable, zColumn, iRow, isReadonly
1.1967 + );
1.1968 + }
1.1969 +#endif
1.1970 + break;
1.1971 + }
1.1972 +
1.1973 + /*
1.1974 + ** $db interrupt
1.1975 + **
1.1976 + ** Interrupt the execution of the inner-most SQL interpreter. This
1.1977 + ** causes the SQL statement to return an error of SQLITE_INTERRUPT.
1.1978 + */
1.1979 + case DB_INTERRUPT: {
1.1980 + sqlite3_interrupt(pDb->db);
1.1981 + break;
1.1982 + }
1.1983 +
1.1984 + /*
1.1985 + ** $db nullvalue ?STRING?
1.1986 + **
1.1987 + ** Change text used when a NULL comes back from the database. If ?STRING?
1.1988 + ** is not present, then the current string used for NULL is returned.
1.1989 + ** If STRING is present, then STRING is returned.
1.1990 + **
1.1991 + */
1.1992 + case DB_NULLVALUE: {
1.1993 + if( objc!=2 && objc!=3 ){
1.1994 + Tcl_WrongNumArgs(interp, 2, objv, "NULLVALUE");
1.1995 + return TCL_ERROR;
1.1996 + }
1.1997 + if( objc==3 ){
1.1998 + int len;
1.1999 + char *zNull = Tcl_GetStringFromObj(objv[2], &len);
1.2000 + if( pDb->zNull ){
1.2001 + Tcl_Free(pDb->zNull);
1.2002 + }
1.2003 + if( zNull && len>0 ){
1.2004 + pDb->zNull = Tcl_Alloc( len + 1 );
1.2005 + strncpy(pDb->zNull, zNull, len);
1.2006 + pDb->zNull[len] = '\0';
1.2007 + }else{
1.2008 + pDb->zNull = 0;
1.2009 + }
1.2010 + }
1.2011 + Tcl_SetObjResult(interp, dbTextToObj(pDb->zNull));
1.2012 + break;
1.2013 + }
1.2014 +
1.2015 + /*
1.2016 + ** $db last_insert_rowid
1.2017 + **
1.2018 + ** Return an integer which is the ROWID for the most recent insert.
1.2019 + */
1.2020 + case DB_LAST_INSERT_ROWID: {
1.2021 + Tcl_Obj *pResult;
1.2022 + Tcl_WideInt rowid;
1.2023 + if( objc!=2 ){
1.2024 + Tcl_WrongNumArgs(interp, 2, objv, "");
1.2025 + return TCL_ERROR;
1.2026 + }
1.2027 + rowid = sqlite3_last_insert_rowid(pDb->db);
1.2028 + pResult = Tcl_GetObjResult(interp);
1.2029 + Tcl_SetWideIntObj(pResult, rowid);
1.2030 + break;
1.2031 + }
1.2032 +
1.2033 + /*
1.2034 + ** The DB_ONECOLUMN method is implemented together with DB_EVAL.
1.2035 + */
1.2036 +
1.2037 + /* $db progress ?N CALLBACK?
1.2038 + **
1.2039 + ** Invoke the given callback every N virtual machine opcodes while executing
1.2040 + ** queries.
1.2041 + */
1.2042 + case DB_PROGRESS: {
1.2043 + if( objc==2 ){
1.2044 + if( pDb->zProgress ){
1.2045 + Tcl_AppendResult(interp, pDb->zProgress, 0);
1.2046 + }
1.2047 + }else if( objc==4 ){
1.2048 + char *zProgress;
1.2049 + int len;
1.2050 + int N;
1.2051 + if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &N) ){
1.2052 + return TCL_ERROR;
1.2053 + };
1.2054 + if( pDb->zProgress ){
1.2055 + Tcl_Free(pDb->zProgress);
1.2056 + }
1.2057 + zProgress = Tcl_GetStringFromObj(objv[3], &len);
1.2058 + if( zProgress && len>0 ){
1.2059 + pDb->zProgress = Tcl_Alloc( len + 1 );
1.2060 + memcpy(pDb->zProgress, zProgress, len+1);
1.2061 + }else{
1.2062 + pDb->zProgress = 0;
1.2063 + }
1.2064 +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1.2065 + if( pDb->zProgress ){
1.2066 + pDb->interp = interp;
1.2067 + sqlite3_progress_handler(pDb->db, N, DbProgressHandler, pDb);
1.2068 + }else{
1.2069 + sqlite3_progress_handler(pDb->db, 0, 0, 0);
1.2070 + }
1.2071 +#endif
1.2072 + }else{
1.2073 + Tcl_WrongNumArgs(interp, 2, objv, "N CALLBACK");
1.2074 + return TCL_ERROR;
1.2075 + }
1.2076 + break;
1.2077 + }
1.2078 +
1.2079 + /* $db profile ?CALLBACK?
1.2080 + **
1.2081 + ** Make arrangements to invoke the CALLBACK routine after each SQL statement
1.2082 + ** that has run. The text of the SQL and the amount of elapse time are
1.2083 + ** appended to CALLBACK before the script is run.
1.2084 + */
1.2085 + case DB_PROFILE: {
1.2086 + if( objc>3 ){
1.2087 + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
1.2088 + return TCL_ERROR;
1.2089 + }else if( objc==2 ){
1.2090 + if( pDb->zProfile ){
1.2091 + Tcl_AppendResult(interp, pDb->zProfile, 0);
1.2092 + }
1.2093 + }else{
1.2094 + char *zProfile;
1.2095 + int len;
1.2096 + if( pDb->zProfile ){
1.2097 + Tcl_Free(pDb->zProfile);
1.2098 + }
1.2099 + zProfile = Tcl_GetStringFromObj(objv[2], &len);
1.2100 + if( zProfile && len>0 ){
1.2101 + pDb->zProfile = Tcl_Alloc( len + 1 );
1.2102 + memcpy(pDb->zProfile, zProfile, len+1);
1.2103 + }else{
1.2104 + pDb->zProfile = 0;
1.2105 + }
1.2106 +#ifndef SQLITE_OMIT_TRACE
1.2107 + if( pDb->zProfile ){
1.2108 + pDb->interp = interp;
1.2109 + sqlite3_profile(pDb->db, DbProfileHandler, pDb);
1.2110 + }else{
1.2111 + sqlite3_profile(pDb->db, 0, 0);
1.2112 + }
1.2113 +#endif
1.2114 + }
1.2115 + break;
1.2116 + }
1.2117 +
1.2118 + /*
1.2119 + ** $db rekey KEY
1.2120 + **
1.2121 + ** Change the encryption key on the currently open database.
1.2122 + */
1.2123 + case DB_REKEY: {
1.2124 + int nKey;
1.2125 + void *pKey;
1.2126 + if( objc!=3 ){
1.2127 + Tcl_WrongNumArgs(interp, 2, objv, "KEY");
1.2128 + return TCL_ERROR;
1.2129 + }
1.2130 + pKey = Tcl_GetByteArrayFromObj(objv[2], &nKey);
1.2131 +#ifdef SQLITE_HAS_CODEC
1.2132 + rc = sqlite3_rekey(pDb->db, pKey, nKey);
1.2133 + if( rc ){
1.2134 + Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
1.2135 + rc = TCL_ERROR;
1.2136 + }
1.2137 +#endif
1.2138 + break;
1.2139 + }
1.2140 +
1.2141 + /*
1.2142 + ** $db timeout MILLESECONDS
1.2143 + **
1.2144 + ** Delay for the number of milliseconds specified when a file is locked.
1.2145 + */
1.2146 + case DB_TIMEOUT: {
1.2147 + int ms;
1.2148 + if( objc!=3 ){
1.2149 + Tcl_WrongNumArgs(interp, 2, objv, "MILLISECONDS");
1.2150 + return TCL_ERROR;
1.2151 + }
1.2152 + if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR;
1.2153 + sqlite3_busy_timeout(pDb->db, ms);
1.2154 + break;
1.2155 + }
1.2156 +
1.2157 + /*
1.2158 + ** $db total_changes
1.2159 + **
1.2160 + ** Return the number of rows that were modified, inserted, or deleted
1.2161 + ** since the database handle was created.
1.2162 + */
1.2163 + case DB_TOTAL_CHANGES: {
1.2164 + Tcl_Obj *pResult;
1.2165 + if( objc!=2 ){
1.2166 + Tcl_WrongNumArgs(interp, 2, objv, "");
1.2167 + return TCL_ERROR;
1.2168 + }
1.2169 + pResult = Tcl_GetObjResult(interp);
1.2170 + Tcl_SetIntObj(pResult, sqlite3_total_changes(pDb->db));
1.2171 + break;
1.2172 + }
1.2173 +
1.2174 + /* $db trace ?CALLBACK?
1.2175 + **
1.2176 + ** Make arrangements to invoke the CALLBACK routine for each SQL statement
1.2177 + ** that is executed. The text of the SQL is appended to CALLBACK before
1.2178 + ** it is executed.
1.2179 + */
1.2180 + case DB_TRACE: {
1.2181 + if( objc>3 ){
1.2182 + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
1.2183 + return TCL_ERROR;
1.2184 + }else if( objc==2 ){
1.2185 + if( pDb->zTrace ){
1.2186 + Tcl_AppendResult(interp, pDb->zTrace, 0);
1.2187 + }
1.2188 + }else{
1.2189 + char *zTrace;
1.2190 + int len;
1.2191 + if( pDb->zTrace ){
1.2192 + Tcl_Free(pDb->zTrace);
1.2193 + }
1.2194 + zTrace = Tcl_GetStringFromObj(objv[2], &len);
1.2195 + if( zTrace && len>0 ){
1.2196 + pDb->zTrace = Tcl_Alloc( len + 1 );
1.2197 + memcpy(pDb->zTrace, zTrace, len+1);
1.2198 + }else{
1.2199 + pDb->zTrace = 0;
1.2200 + }
1.2201 +#ifndef SQLITE_OMIT_TRACE
1.2202 + if( pDb->zTrace ){
1.2203 + pDb->interp = interp;
1.2204 + sqlite3_trace(pDb->db, DbTraceHandler, pDb);
1.2205 + }else{
1.2206 + sqlite3_trace(pDb->db, 0, 0);
1.2207 + }
1.2208 +#endif
1.2209 + }
1.2210 + break;
1.2211 + }
1.2212 +
1.2213 + /* $db transaction [-deferred|-immediate|-exclusive] SCRIPT
1.2214 + **
1.2215 + ** Start a new transaction (if we are not already in the midst of a
1.2216 + ** transaction) and execute the TCL script SCRIPT. After SCRIPT
1.2217 + ** completes, either commit the transaction or roll it back if SCRIPT
1.2218 + ** throws an exception. Or if no new transation was started, do nothing.
1.2219 + ** pass the exception on up the stack.
1.2220 + **
1.2221 + ** This command was inspired by Dave Thomas's talk on Ruby at the
1.2222 + ** 2005 O'Reilly Open Source Convention (OSCON).
1.2223 + */
1.2224 + case DB_TRANSACTION: {
1.2225 + int inTrans;
1.2226 + Tcl_Obj *pScript;
1.2227 + const char *zBegin = "BEGIN";
1.2228 + if( objc!=3 && objc!=4 ){
1.2229 + Tcl_WrongNumArgs(interp, 2, objv, "[TYPE] SCRIPT");
1.2230 + return TCL_ERROR;
1.2231 + }
1.2232 + if( objc==3 ){
1.2233 + pScript = objv[2];
1.2234 + } else {
1.2235 + static const char *TTYPE_strs[] = {
1.2236 + "deferred", "exclusive", "immediate", 0
1.2237 + };
1.2238 + enum TTYPE_enum {
1.2239 + TTYPE_DEFERRED, TTYPE_EXCLUSIVE, TTYPE_IMMEDIATE
1.2240 + };
1.2241 + int ttype;
1.2242 + if( Tcl_GetIndexFromObj(interp, objv[2], TTYPE_strs, "transaction type",
1.2243 + 0, &ttype) ){
1.2244 + return TCL_ERROR;
1.2245 + }
1.2246 + switch( (enum TTYPE_enum)ttype ){
1.2247 + case TTYPE_DEFERRED: /* no-op */; break;
1.2248 + case TTYPE_EXCLUSIVE: zBegin = "BEGIN EXCLUSIVE"; break;
1.2249 + case TTYPE_IMMEDIATE: zBegin = "BEGIN IMMEDIATE"; break;
1.2250 + }
1.2251 + pScript = objv[3];
1.2252 + }
1.2253 + inTrans = !sqlite3_get_autocommit(pDb->db);
1.2254 + if( !inTrans ){
1.2255 + pDb->disableAuth++;
1.2256 + (void)sqlite3_exec(pDb->db, zBegin, 0, 0, 0);
1.2257 + pDb->disableAuth--;
1.2258 + }
1.2259 + rc = Tcl_EvalObjEx(interp, pScript, 0);
1.2260 + if( !inTrans ){
1.2261 + const char *zEnd;
1.2262 + if( rc==TCL_ERROR ){
1.2263 + zEnd = "ROLLBACK";
1.2264 + } else {
1.2265 + zEnd = "COMMIT";
1.2266 + }
1.2267 + pDb->disableAuth++;
1.2268 + if( sqlite3_exec(pDb->db, zEnd, 0, 0, 0) ){
1.2269 + sqlite3_exec(pDb->db, "ROLLBACK", 0, 0, 0);
1.2270 + }
1.2271 + pDb->disableAuth--;
1.2272 + }
1.2273 + break;
1.2274 + }
1.2275 +
1.2276 + /*
1.2277 + ** $db update_hook ?script?
1.2278 + ** $db rollback_hook ?script?
1.2279 + */
1.2280 + case DB_UPDATE_HOOK:
1.2281 + case DB_ROLLBACK_HOOK: {
1.2282 +
1.2283 + /* set ppHook to point at pUpdateHook or pRollbackHook, depending on
1.2284 + ** whether [$db update_hook] or [$db rollback_hook] was invoked.
1.2285 + */
1.2286 + Tcl_Obj **ppHook;
1.2287 + if( choice==DB_UPDATE_HOOK ){
1.2288 + ppHook = &pDb->pUpdateHook;
1.2289 + }else{
1.2290 + ppHook = &pDb->pRollbackHook;
1.2291 + }
1.2292 +
1.2293 + if( objc!=2 && objc!=3 ){
1.2294 + Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
1.2295 + return TCL_ERROR;
1.2296 + }
1.2297 + if( *ppHook ){
1.2298 + Tcl_SetObjResult(interp, *ppHook);
1.2299 + if( objc==3 ){
1.2300 + Tcl_DecrRefCount(*ppHook);
1.2301 + *ppHook = 0;
1.2302 + }
1.2303 + }
1.2304 + if( objc==3 ){
1.2305 + assert( !(*ppHook) );
1.2306 + if( Tcl_GetCharLength(objv[2])>0 ){
1.2307 + *ppHook = objv[2];
1.2308 + Tcl_IncrRefCount(*ppHook);
1.2309 + }
1.2310 + }
1.2311 +
1.2312 + sqlite3_update_hook(pDb->db, (pDb->pUpdateHook?DbUpdateHandler:0), pDb);
1.2313 + sqlite3_rollback_hook(pDb->db,(pDb->pRollbackHook?DbRollbackHandler:0),pDb);
1.2314 +
1.2315 + break;
1.2316 + }
1.2317 +
1.2318 + /* $db version
1.2319 + **
1.2320 + ** Return the version string for this database.
1.2321 + */
1.2322 + case DB_VERSION: {
1.2323 + Tcl_SetResult(interp, (char *)sqlite3_libversion(), TCL_STATIC);
1.2324 + break;
1.2325 + }
1.2326 +
1.2327 +
1.2328 + } /* End of the SWITCH statement */
1.2329 + return rc;
1.2330 +}
1.2331 +
1.2332 +/*
1.2333 +** sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?
1.2334 +** ?-create BOOLEAN? ?-nomutex BOOLEAN?
1.2335 +**
1.2336 +** This is the main Tcl command. When the "sqlite" Tcl command is
1.2337 +** invoked, this routine runs to process that command.
1.2338 +**
1.2339 +** The first argument, DBNAME, is an arbitrary name for a new
1.2340 +** database connection. This command creates a new command named
1.2341 +** DBNAME that is used to control that connection. The database
1.2342 +** connection is deleted when the DBNAME command is deleted.
1.2343 +**
1.2344 +** The second argument is the name of the database file.
1.2345 +**
1.2346 +*/
1.2347 +static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
1.2348 + SqliteDb *p;
1.2349 + void *pKey = 0;
1.2350 + int nKey = 0;
1.2351 + const char *zArg;
1.2352 + char *zErrMsg;
1.2353 + int i;
1.2354 + const char *zFile;
1.2355 + const char *zVfs = 0;
1.2356 + int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX;
1.2357 + Tcl_DString translatedFilename;
1.2358 + if( objc==2 ){
1.2359 + zArg = Tcl_GetStringFromObj(objv[1], 0);
1.2360 + if( strcmp(zArg,"-version")==0 ){
1.2361 + Tcl_AppendResult(interp,sqlite3_version,0);
1.2362 + return TCL_OK;
1.2363 + }
1.2364 + if( strcmp(zArg,"-has-codec")==0 ){
1.2365 +#ifdef SQLITE_HAS_CODEC
1.2366 + Tcl_AppendResult(interp,"1",0);
1.2367 +#else
1.2368 + Tcl_AppendResult(interp,"0",0);
1.2369 +#endif
1.2370 + return TCL_OK;
1.2371 + }
1.2372 + }
1.2373 + for(i=3; i+1<objc; i+=2){
1.2374 + zArg = Tcl_GetString(objv[i]);
1.2375 + if( strcmp(zArg,"-key")==0 ){
1.2376 + pKey = Tcl_GetByteArrayFromObj(objv[i+1], &nKey);
1.2377 + }else if( strcmp(zArg, "-vfs")==0 ){
1.2378 + i++;
1.2379 + zVfs = Tcl_GetString(objv[i]);
1.2380 + }else if( strcmp(zArg, "-readonly")==0 ){
1.2381 + int b;
1.2382 + if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;
1.2383 + if( b ){
1.2384 + flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
1.2385 + flags |= SQLITE_OPEN_READONLY;
1.2386 + }else{
1.2387 + flags &= ~SQLITE_OPEN_READONLY;
1.2388 + flags |= SQLITE_OPEN_READWRITE;
1.2389 + }
1.2390 + }else if( strcmp(zArg, "-create")==0 ){
1.2391 + int b;
1.2392 + if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;
1.2393 + if( b && (flags & SQLITE_OPEN_READONLY)==0 ){
1.2394 + flags |= SQLITE_OPEN_CREATE;
1.2395 + }else{
1.2396 + flags &= ~SQLITE_OPEN_CREATE;
1.2397 + }
1.2398 + }else if( strcmp(zArg, "-nomutex")==0 ){
1.2399 + int b;
1.2400 + if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;
1.2401 + if( b ){
1.2402 + flags |= SQLITE_OPEN_NOMUTEX;
1.2403 + flags &= ~SQLITE_OPEN_FULLMUTEX;
1.2404 + }else{
1.2405 + flags &= ~SQLITE_OPEN_NOMUTEX;
1.2406 + }
1.2407 + }else if( strcmp(zArg, "-fullmutex")==0 ){
1.2408 + int b;
1.2409 + if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;
1.2410 + if( b ){
1.2411 + flags |= SQLITE_OPEN_FULLMUTEX;
1.2412 + flags &= ~SQLITE_OPEN_NOMUTEX;
1.2413 + }else{
1.2414 + flags &= ~SQLITE_OPEN_FULLMUTEX;
1.2415 + }
1.2416 + }else{
1.2417 + Tcl_AppendResult(interp, "unknown option: ", zArg, (char*)0);
1.2418 + return TCL_ERROR;
1.2419 + }
1.2420 + }
1.2421 + if( objc<3 || (objc&1)!=1 ){
1.2422 + Tcl_WrongNumArgs(interp, 1, objv,
1.2423 + "HANDLE FILENAME ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"
1.2424 + " ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN?"
1.2425 +#ifdef SQLITE_HAS_CODEC
1.2426 + " ?-key CODECKEY?"
1.2427 +#endif
1.2428 + );
1.2429 + return TCL_ERROR;
1.2430 + }
1.2431 + zErrMsg = 0;
1.2432 + p = (SqliteDb*)Tcl_Alloc( sizeof(*p) );
1.2433 + if( p==0 ){
1.2434 + Tcl_SetResult(interp, "malloc failed", TCL_STATIC);
1.2435 + return TCL_ERROR;
1.2436 + }
1.2437 + memset(p, 0, sizeof(*p));
1.2438 + zFile = Tcl_GetStringFromObj(objv[2], 0);
1.2439 + zFile = Tcl_TranslateFileName(interp, zFile, &translatedFilename);
1.2440 + sqlite3_open_v2(zFile, &p->db, flags, zVfs);
1.2441 + Tcl_DStringFree(&translatedFilename);
1.2442 + if( SQLITE_OK!=sqlite3_errcode(p->db) ){
1.2443 + zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));
1.2444 + sqlite3_close(p->db);
1.2445 + p->db = 0;
1.2446 + }
1.2447 +#ifdef SQLITE_HAS_CODEC
1.2448 + if( p->db ){
1.2449 + sqlite3_key(p->db, pKey, nKey);
1.2450 + }
1.2451 +#endif
1.2452 + if( p->db==0 ){
1.2453 + Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE);
1.2454 + Tcl_Free((char*)p);
1.2455 + sqlite3_free(zErrMsg);
1.2456 + return TCL_ERROR;
1.2457 + }
1.2458 + p->maxStmt = NUM_PREPARED_STMTS;
1.2459 + p->interp = interp;
1.2460 + zArg = Tcl_GetStringFromObj(objv[1], 0);
1.2461 + Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd);
1.2462 + return TCL_OK;
1.2463 +}
1.2464 +
1.2465 +/*
1.2466 +** Provide a dummy Tcl_InitStubs if we are using this as a static
1.2467 +** library.
1.2468 +*/
1.2469 +#ifndef USE_TCL_STUBS
1.2470 +# undef Tcl_InitStubs
1.2471 +# define Tcl_InitStubs(a,b,c)
1.2472 +#endif
1.2473 +
1.2474 +/*
1.2475 +** Make sure we have a PACKAGE_VERSION macro defined. This will be
1.2476 +** defined automatically by the TEA makefile. But other makefiles
1.2477 +** do not define it.
1.2478 +*/
1.2479 +#ifndef PACKAGE_VERSION
1.2480 +# define PACKAGE_VERSION SQLITE_VERSION
1.2481 +#endif
1.2482 +
1.2483 +/*
1.2484 +** Initialize this module.
1.2485 +**
1.2486 +** This Tcl module contains only a single new Tcl command named "sqlite".
1.2487 +** (Hence there is no namespace. There is no point in using a namespace
1.2488 +** if the extension only supplies one new name!) The "sqlite" command is
1.2489 +** used to open a new SQLite database. See the DbMain() routine above
1.2490 +** for additional information.
1.2491 +*/
1.2492 +EXTERN int Sqlite3_Init(Tcl_Interp *interp){
1.2493 + Tcl_InitStubs(interp, "8.4", 0);
1.2494 + Tcl_CreateObjCommand(interp, "sqlite3", (Tcl_ObjCmdProc*)DbMain, 0, 0);
1.2495 + Tcl_PkgProvide(interp, "sqlite3", PACKAGE_VERSION);
1.2496 + Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0);
1.2497 + Tcl_PkgProvide(interp, "sqlite", PACKAGE_VERSION);
1.2498 + return TCL_OK;
1.2499 +}
1.2500 +EXTERN int Tclsqlite3_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
1.2501 +EXTERN int Sqlite3_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
1.2502 +EXTERN int Tclsqlite3_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
1.2503 +EXTERN int Sqlite3_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
1.2504 +EXTERN int Tclsqlite3_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
1.2505 +EXTERN int Sqlite3_SafeUnload(Tcl_Interp *interp, int flags){ return TCL_OK; }
1.2506 +EXTERN int Tclsqlite3_SafeUnload(Tcl_Interp *interp, int flags){ return TCL_OK;}
1.2507 +
1.2508 +
1.2509 +#ifndef SQLITE_3_SUFFIX_ONLY
1.2510 +EXTERN int Sqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
1.2511 +EXTERN int Tclsqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
1.2512 +EXTERN int Sqlite_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
1.2513 +EXTERN int Tclsqlite_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
1.2514 +EXTERN int Sqlite_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
1.2515 +EXTERN int Tclsqlite_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }
1.2516 +EXTERN int Sqlite_SafeUnload(Tcl_Interp *interp, int flags){ return TCL_OK; }
1.2517 +EXTERN int Tclsqlite_SafeUnload(Tcl_Interp *interp, int flags){ return TCL_OK;}
1.2518 +#endif
1.2519 +
1.2520 +#ifdef TCLSH
1.2521 +/*****************************************************************************
1.2522 +** The code that follows is used to build standalone TCL interpreters
1.2523 +** that are statically linked with SQLite.
1.2524 +*/
1.2525 +
1.2526 +/*
1.2527 +** If the macro TCLSH is one, then put in code this for the
1.2528 +** "main" routine that will initialize Tcl and take input from
1.2529 +** standard input, or if a file is named on the command line
1.2530 +** the TCL interpreter reads and evaluates that file.
1.2531 +*/
1.2532 +#if TCLSH==1
1.2533 +static char zMainloop[] =
1.2534 + "set line {}\n"
1.2535 + "while {![eof stdin]} {\n"
1.2536 + "if {$line!=\"\"} {\n"
1.2537 + "puts -nonewline \"> \"\n"
1.2538 + "} else {\n"
1.2539 + "puts -nonewline \"% \"\n"
1.2540 + "}\n"
1.2541 + "flush stdout\n"
1.2542 + "append line [gets stdin]\n"
1.2543 + "if {[info complete $line]} {\n"
1.2544 + "if {[catch {uplevel #0 $line} result]} {\n"
1.2545 + "puts stderr \"Error: $result\"\n"
1.2546 + "} elseif {$result!=\"\"} {\n"
1.2547 + "puts $result\n"
1.2548 + "}\n"
1.2549 + "set line {}\n"
1.2550 + "} else {\n"
1.2551 + "append line \\n\n"
1.2552 + "}\n"
1.2553 + "}\n"
1.2554 +;
1.2555 +#endif
1.2556 +
1.2557 +/*
1.2558 +** If the macro TCLSH is two, then get the main loop code out of
1.2559 +** the separate file "spaceanal_tcl.h".
1.2560 +*/
1.2561 +#if TCLSH==2
1.2562 +static char zMainloop[] =
1.2563 +#include "spaceanal_tcl.h"
1.2564 +;
1.2565 +#endif
1.2566 +
1.2567 +#define TCLSH_MAIN main /* Needed to fake out mktclapp */
1.2568 +int TCLSH_MAIN(int argc, char **argv){
1.2569 + Tcl_Interp *interp;
1.2570 +#if defined(__SYMBIAN32__)
1.2571 + int isChildProcess = 0;
1.2572 + int oldArgc = 0;
1.2573 + int err = 0;
1.2574 + #endif
1.2575 +
1.2576 + PrintS("###TclSqlite3: New instance");
1.2577 + Tcl_FindExecutable(argv[0]);
1.2578 + PrintS("###TclSqlite3: Create interpreter");
1.2579 + interp = Tcl_CreateInterp();
1.2580 +#if defined(__SYMBIAN32__)
1.2581 + PrintS("###TclSqlite3: Child process init");
1.2582 + if (ChildProcessInit(&argc, &argv))
1.2583 + {
1.2584 + oldArgc = argc;
1.2585 + argc = argc-4;
1.2586 + isChildProcess = 1;
1.2587 + }
1.2588 + else
1.2589 + {
1.2590 + err = CopyTestFiles();
1.2591 + if(err != 0)
1.2592 + {
1.2593 + PrintS("###TclSqlite3: Exit-1");
1.2594 + return 1;
1.2595 + }
1.2596 + }
1.2597 +#endif
1.2598 + PrintS("###TclSqlite3: Init");
1.2599 + Sqlite3_Init(interp);
1.2600 +#ifdef SQLITE_TEST
1.2601 + {
1.2602 + extern int Md5_Init(Tcl_Interp*);
1.2603 + extern int Sqliteconfig_Init(Tcl_Interp*);
1.2604 + extern int Sqlitetest1_Init(Tcl_Interp*);
1.2605 + extern int Sqlitetest2_Init(Tcl_Interp*);
1.2606 + extern int Sqlitetest3_Init(Tcl_Interp*);
1.2607 + extern int Sqlitetest4_Init(Tcl_Interp*);
1.2608 + extern int Sqlitetest5_Init(Tcl_Interp*);
1.2609 + extern int Sqlitetest6_Init(Tcl_Interp*);
1.2610 + extern int Sqlitetest7_Init(Tcl_Interp*);
1.2611 + extern int Sqlitetest8_Init(Tcl_Interp*);
1.2612 + extern int Sqlitetest9_Init(Tcl_Interp*);
1.2613 + extern int Sqlitetestasync_Init(Tcl_Interp*);
1.2614 + extern int Sqlitetest_autoext_Init(Tcl_Interp*);
1.2615 + extern int Sqlitetest_func_Init(Tcl_Interp*);
1.2616 + extern int Sqlitetest_hexio_Init(Tcl_Interp*);
1.2617 + extern int Sqlitetest_malloc_Init(Tcl_Interp*);
1.2618 + extern int Sqlitetest_mutex_Init(Tcl_Interp*);
1.2619 + extern int Sqlitetestschema_Init(Tcl_Interp*);
1.2620 + extern int Sqlitetestsse_Init(Tcl_Interp*);
1.2621 + extern int Sqlitetesttclvar_Init(Tcl_Interp*);
1.2622 + extern int SqlitetestThread_Init(Tcl_Interp*);
1.2623 + extern int SqlitetestOnefile_Init();
1.2624 + extern int SqlitetestOsinst_Init(Tcl_Interp*);
1.2625 +
1.2626 + Md5_Init(interp);
1.2627 + Sqliteconfig_Init(interp);
1.2628 + Sqlitetest1_Init(interp);
1.2629 + Sqlitetest2_Init(interp);
1.2630 + Sqlitetest3_Init(interp);
1.2631 + Sqlitetest4_Init(interp);
1.2632 + Sqlitetest5_Init(interp);
1.2633 + Sqlitetest6_Init(interp);
1.2634 + Sqlitetest7_Init(interp);
1.2635 + Sqlitetest8_Init(interp);
1.2636 + Sqlitetest9_Init(interp);
1.2637 + Sqlitetestasync_Init(interp);
1.2638 + Sqlitetest_autoext_Init(interp);
1.2639 + Sqlitetest_func_Init(interp);
1.2640 + Sqlitetest_hexio_Init(interp);
1.2641 + Sqlitetest_malloc_Init(interp);
1.2642 + Sqlitetest_mutex_Init(interp);
1.2643 + Sqlitetestschema_Init(interp);
1.2644 + Sqlitetesttclvar_Init(interp);
1.2645 + SqlitetestThread_Init(interp);
1.2646 + SqlitetestOnefile_Init(interp);
1.2647 + SqlitetestOsinst_Init(interp);
1.2648 +
1.2649 +#ifdef SQLITE_SSE
1.2650 + Sqlitetestsse_Init(interp);
1.2651 +#endif
1.2652 + }
1.2653 +#endif
1.2654 + if( argc>=2 || TCLSH==2 ){
1.2655 + int i;
1.2656 + char zArgc[32];
1.2657 + sqlite3_snprintf(sizeof(zArgc), zArgc, "%d", argc-(3-TCLSH));
1.2658 + Tcl_SetVar(interp,"argc", zArgc, TCL_GLOBAL_ONLY);
1.2659 + Tcl_SetVar(interp,"argv0",argv[1],TCL_GLOBAL_ONLY);
1.2660 + Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY);
1.2661 + for(i=3-TCLSH; i<argc; i++){
1.2662 + Tcl_SetVar(interp, "argv", argv[i],
1.2663 + TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT | TCL_APPEND_VALUE);
1.2664 + }
1.2665 +#ifdef __SYMBIAN32__
1.2666 + Tcl_CreateObjCommand(interp, "delete_test_files", (Tcl_ObjCmdProc*)DeleteTestFiles, 0, 0);
1.2667 + Tcl_CreateObjCommand(interp, "print_text", (Tcl_ObjCmdProc*)PrintText, 0, 0);
1.2668 +#endif
1.2669 + PrintS("###TclSqlite3: Tests begin");
1.2670 + if( TCLSH==1 && Tcl_EvalFile(interp, argv[1])!=TCL_OK ){
1.2671 + char errMsg[1024];
1.2672 + const char *zInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
1.2673 + if( zInfo==0 )
1.2674 + zInfo = interp->result;
1.2675 + sprintf(errMsg, "###TclSqlite3: Error, argv=%s, zInfo=%s", *argv, zInfo);
1.2676 + PrintS(errMsg);
1.2677 +#ifdef __SYMBIAN32__
1.2678 + ChildProcessCleanup(isChildProcess, oldArgc, argv);
1.2679 +#endif
1.2680 + PrintS("###TclSqlite3: Exit-2");
1.2681 + return 1;
1.2682 + }
1.2683 + PrintS("###TclSqlite3: Tests end");
1.2684 + }
1.2685 + if( argc<=1 || TCLSH==2 ){
1.2686 + Tcl_GlobalEval(interp, zMainloop);
1.2687 + }
1.2688 +#if defined(__SYMBIAN32__)
1.2689 + ChildProcessCleanup(isChildProcess, oldArgc, argv);
1.2690 +#endif
1.2691 + PrintS("###TclSqlite3: Exit-3");
1.2692 + return 0;
1.2693 +}
1.2694 +#endif /* TCLSH */