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