4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
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.
15 ** Compile-time options:
17 ** -DTCLSH Add a "main()" routine that works as a tclsh.
19 ** -DTCLSH_INIT_PROC=name
21 ** Invoke name(interp) to initialize the Tcl interpreter.
22 ** If name(interp) returns a non-NULL string, then run
23 ** that string as a Tcl script to launch the application.
24 ** If name(interp) returns NULL, then run the regular
25 ** tclsh-emulator code.
27 #ifdef TCLSH_INIT_PROC
32 ** If requested, include the SQLite compiler options file for MSVC.
34 #if defined(INCLUDE_MSVC_H)
38 #if defined(INCLUDE_SQLITE_TCL_H)
39 # include "sqlite_tcl.h"
42 # ifndef SQLITE_TCLAPI
43 # define SQLITE_TCLAPI
49 ** Some additional include files are needed if this file is not
50 ** appended to the amalgamation.
52 #ifndef SQLITE_AMALGAMATION
57 typedef unsigned char u8
;
61 /* Used to get the current process ID */
64 # define GETPID getpid
65 #elif !defined(_WIN32_WCE)
66 # ifndef SQLITE_AMALGAMATION
67 # ifndef WIN32_LEAN_AND_MEAN
68 # define WIN32_LEAN_AND_MEAN
72 # define GETPID (int)GetCurrentProcessId
76 * Windows needs to know which symbols to export. Unix does not.
77 * BUILD_sqlite should be undefined for Unix.
80 #undef TCL_STORAGE_CLASS
81 #define TCL_STORAGE_CLASS DLLEXPORT
82 #endif /* BUILD_sqlite */
84 #define NUM_PREPARED_STMTS 10
85 #define MAX_PREPARED_STMTS 100
87 /* Forward declaration */
88 typedef struct SqliteDb SqliteDb
;
91 ** New SQL functions can be created as TCL scripts. Each such function
92 ** is described by an instance of the following structure.
94 typedef struct SqlFunc SqlFunc
;
96 Tcl_Interp
*interp
; /* The TCL interpret to execute the function */
97 Tcl_Obj
*pScript
; /* The Tcl_Obj representation of the script */
98 SqliteDb
*pDb
; /* Database connection that owns this function */
99 int useEvalObjv
; /* True if it is safe to use Tcl_EvalObjv */
100 char *zName
; /* Name of this function */
101 SqlFunc
*pNext
; /* Next function on the list of them all */
105 ** New collation sequences function can be created as TCL scripts. Each such
106 ** function is described by an instance of the following structure.
108 typedef struct SqlCollate SqlCollate
;
110 Tcl_Interp
*interp
; /* The TCL interpret to execute the function */
111 char *zScript
; /* The script to be run */
112 SqlCollate
*pNext
; /* Next function on the list of them all */
116 ** Prepared statements are cached for faster execution. Each prepared
117 ** statement is described by an instance of the following structure.
119 typedef struct SqlPreparedStmt SqlPreparedStmt
;
120 struct SqlPreparedStmt
{
121 SqlPreparedStmt
*pNext
; /* Next in linked list */
122 SqlPreparedStmt
*pPrev
; /* Previous on the list */
123 sqlite3_stmt
*pStmt
; /* The prepared statement */
124 int nSql
; /* chars in zSql[] */
125 const char *zSql
; /* Text of the SQL statement */
126 int nParm
; /* Size of apParm array */
127 Tcl_Obj
**apParm
; /* Array of referenced object pointers */
130 typedef struct IncrblobChannel IncrblobChannel
;
133 ** There is one instance of this structure for each SQLite database
134 ** that has been opened by the SQLite TCL interface.
136 ** If this module is built with SQLITE_TEST defined (to create the SQLite
137 ** testfixture executable), then it may be configured to use either
138 ** sqlite3_prepare_v2() or sqlite3_prepare() to prepare SQL statements.
139 ** If SqliteDb.bLegacyPrepare is true, sqlite3_prepare() is used.
142 sqlite3
*db
; /* The "real" database structure. MUST BE FIRST */
143 Tcl_Interp
*interp
; /* The interpreter used for this database */
144 char *zBusy
; /* The busy callback routine */
145 char *zCommit
; /* The commit hook callback routine */
146 char *zTrace
; /* The trace callback routine */
147 char *zTraceV2
; /* The trace_v2 callback routine */
148 char *zProfile
; /* The profile callback routine */
149 char *zProgress
; /* The progress callback routine */
150 char *zAuth
; /* The authorization callback routine */
151 int disableAuth
; /* Disable the authorizer if it exists */
152 char *zNull
; /* Text to substitute for an SQL NULL value */
153 SqlFunc
*pFunc
; /* List of SQL functions */
154 Tcl_Obj
*pUpdateHook
; /* Update hook script (if any) */
155 Tcl_Obj
*pPreUpdateHook
; /* Pre-update hook script (if any) */
156 Tcl_Obj
*pRollbackHook
; /* Rollback hook script (if any) */
157 Tcl_Obj
*pWalHook
; /* WAL hook script (if any) */
158 Tcl_Obj
*pUnlockNotify
; /* Unlock notify script (if any) */
159 SqlCollate
*pCollate
; /* List of SQL collation functions */
160 int rc
; /* Return code of most recent sqlite3_exec() */
161 Tcl_Obj
*pCollateNeeded
; /* Collation needed script */
162 SqlPreparedStmt
*stmtList
; /* List of prepared statements*/
163 SqlPreparedStmt
*stmtLast
; /* Last statement in the list */
164 int maxStmt
; /* The next maximum number of stmtList */
165 int nStmt
; /* Number of statements in stmtList */
166 IncrblobChannel
*pIncrblob
;/* Linked list of open incrblob channels */
167 int nStep
, nSort
, nIndex
; /* Statistics for most recent operation */
168 int nVMStep
; /* Another statistic for most recent operation */
169 int nTransaction
; /* Number of nested [transaction] methods */
170 int openFlags
; /* Flags used to open. (SQLITE_OPEN_URI) */
172 int bLegacyPrepare
; /* True to use sqlite3_prepare() */
176 struct IncrblobChannel
{
177 sqlite3_blob
*pBlob
; /* sqlite3 blob handle */
178 SqliteDb
*pDb
; /* Associated database connection */
179 int iSeek
; /* Current seek offset */
180 Tcl_Channel channel
; /* Channel identifier */
181 IncrblobChannel
*pNext
; /* Linked list of all open incrblob channels */
182 IncrblobChannel
*pPrev
; /* Linked list of all open incrblob channels */
186 ** Compute a string length that is limited to what can be stored in
187 ** lower 30 bits of a 32-bit signed integer.
189 static int strlen30(const char *z
){
191 while( *z2
){ z2
++; }
192 return 0x3fffffff & (int)(z2
- z
);
196 #ifndef SQLITE_OMIT_INCRBLOB
198 ** Close all incrblob channels opened using database connection pDb.
199 ** This is called when shutting down the database connection.
201 static void closeIncrblobChannels(SqliteDb
*pDb
){
203 IncrblobChannel
*pNext
;
205 for(p
=pDb
->pIncrblob
; p
; p
=pNext
){
208 /* Note: Calling unregister here call Tcl_Close on the incrblob channel,
209 ** which deletes the IncrblobChannel structure at *p. So do not
210 ** call Tcl_Free() here.
212 Tcl_UnregisterChannel(pDb
->interp
, p
->channel
);
217 ** Close an incremental blob channel.
219 static int SQLITE_TCLAPI
incrblobClose(
220 ClientData instanceData
,
223 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
224 int rc
= sqlite3_blob_close(p
->pBlob
);
225 sqlite3
*db
= p
->pDb
->db
;
227 /* Remove the channel from the SqliteDb.pIncrblob list. */
229 p
->pNext
->pPrev
= p
->pPrev
;
232 p
->pPrev
->pNext
= p
->pNext
;
234 if( p
->pDb
->pIncrblob
==p
){
235 p
->pDb
->pIncrblob
= p
->pNext
;
238 /* Free the IncrblobChannel structure */
242 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(db
), TCL_VOLATILE
);
249 ** Read data from an incremental blob channel.
251 static int SQLITE_TCLAPI
incrblobInput(
252 ClientData instanceData
,
257 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
258 int nRead
= bufSize
; /* Number of bytes to read */
259 int nBlob
; /* Total size of the blob */
260 int rc
; /* sqlite error code */
262 nBlob
= sqlite3_blob_bytes(p
->pBlob
);
263 if( (p
->iSeek
+nRead
)>nBlob
){
264 nRead
= nBlob
-p
->iSeek
;
270 rc
= sqlite3_blob_read(p
->pBlob
, (void *)buf
, nRead
, p
->iSeek
);
281 ** Write data to an incremental blob channel.
283 static int SQLITE_TCLAPI
incrblobOutput(
284 ClientData instanceData
,
289 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
290 int nWrite
= toWrite
; /* Number of bytes to write */
291 int nBlob
; /* Total size of the blob */
292 int rc
; /* sqlite error code */
294 nBlob
= sqlite3_blob_bytes(p
->pBlob
);
295 if( (p
->iSeek
+nWrite
)>nBlob
){
296 *errorCodePtr
= EINVAL
;
303 rc
= sqlite3_blob_write(p
->pBlob
, (void *)buf
, nWrite
, p
->iSeek
);
314 ** Seek an incremental blob channel.
316 static int SQLITE_TCLAPI
incrblobSeek(
317 ClientData instanceData
,
322 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
332 p
->iSeek
= sqlite3_blob_bytes(p
->pBlob
) + offset
;
335 default: assert(!"Bad seekMode");
342 static void SQLITE_TCLAPI
incrblobWatch(
343 ClientData instanceData
,
348 static int SQLITE_TCLAPI
incrblobHandle(
349 ClientData instanceData
,
356 static Tcl_ChannelType IncrblobChannelType
= {
357 "incrblob", /* typeName */
358 TCL_CHANNEL_VERSION_2
, /* version */
359 incrblobClose
, /* closeProc */
360 incrblobInput
, /* inputProc */
361 incrblobOutput
, /* outputProc */
362 incrblobSeek
, /* seekProc */
363 0, /* setOptionProc */
364 0, /* getOptionProc */
365 incrblobWatch
, /* watchProc (this is a no-op) */
366 incrblobHandle
, /* getHandleProc (always returns error) */
368 0, /* blockModeProc */
371 0, /* wideSeekProc */
375 ** Create a new incrblob channel.
377 static int createIncrblobChannel(
387 sqlite3
*db
= pDb
->db
;
390 int flags
= TCL_READABLE
|(isReadonly
? 0 : TCL_WRITABLE
);
392 /* This variable is used to name the channels: "incrblob_[incr count]" */
393 static int count
= 0;
396 rc
= sqlite3_blob_open(db
, zDb
, zTable
, zColumn
, iRow
, !isReadonly
, &pBlob
);
398 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
402 p
= (IncrblobChannel
*)Tcl_Alloc(sizeof(IncrblobChannel
));
406 sqlite3_snprintf(sizeof(zChannel
), zChannel
, "incrblob_%d", ++count
);
407 p
->channel
= Tcl_CreateChannel(&IncrblobChannelType
, zChannel
, p
, flags
);
408 Tcl_RegisterChannel(interp
, p
->channel
);
410 /* Link the new channel into the SqliteDb.pIncrblob list. */
411 p
->pNext
= pDb
->pIncrblob
;
419 Tcl_SetResult(interp
, (char *)Tcl_GetChannelName(p
->channel
), TCL_VOLATILE
);
422 #else /* else clause for "#ifndef SQLITE_OMIT_INCRBLOB" */
423 #define closeIncrblobChannels(pDb)
427 ** Look at the script prefix in pCmd. We will be executing this script
428 ** after first appending one or more arguments. This routine analyzes
429 ** the script to see if it is safe to use Tcl_EvalObjv() on the script
430 ** rather than the more general Tcl_EvalEx(). Tcl_EvalObjv() is much
433 ** Scripts that are safe to use with Tcl_EvalObjv() consists of a
434 ** command name followed by zero or more arguments with no [...] or $
435 ** or {...} or ; to be seen anywhere. Most callback scripts consist
436 ** of just a single procedure name and they meet this requirement.
438 static int safeToUseEvalObjv(Tcl_Interp
*interp
, Tcl_Obj
*pCmd
){
439 /* We could try to do something with Tcl_Parse(). But we will instead
440 ** just do a search for forbidden characters. If any of the forbidden
441 ** characters appear in pCmd, we will report the string as unsafe.
445 z
= Tcl_GetStringFromObj(pCmd
, &n
);
448 if( c
=='$' || c
=='[' || c
==';' ) return 0;
454 ** Find an SqlFunc structure with the given name. Or create a new
455 ** one if an existing one cannot be found. Return a pointer to the
458 static SqlFunc
*findSqlFunc(SqliteDb
*pDb
, const char *zName
){
460 int nName
= strlen30(zName
);
461 pNew
= (SqlFunc
*)Tcl_Alloc( sizeof(*pNew
) + nName
+ 1 );
462 pNew
->zName
= (char*)&pNew
[1];
463 memcpy(pNew
->zName
, zName
, nName
+1);
464 for(p
=pDb
->pFunc
; p
; p
=p
->pNext
){
465 if( sqlite3_stricmp(p
->zName
, pNew
->zName
)==0 ){
466 Tcl_Free((char*)pNew
);
470 pNew
->interp
= pDb
->interp
;
473 pNew
->pNext
= pDb
->pFunc
;
479 ** Free a single SqlPreparedStmt object.
481 static void dbFreeStmt(SqlPreparedStmt
*pStmt
){
483 if( sqlite3_sql(pStmt
->pStmt
)==0 ){
484 Tcl_Free((char *)pStmt
->zSql
);
487 sqlite3_finalize(pStmt
->pStmt
);
488 Tcl_Free((char *)pStmt
);
492 ** Finalize and free a list of prepared statements
494 static void flushStmtCache(SqliteDb
*pDb
){
495 SqlPreparedStmt
*pPreStmt
;
496 SqlPreparedStmt
*pNext
;
498 for(pPreStmt
= pDb
->stmtList
; pPreStmt
; pPreStmt
=pNext
){
499 pNext
= pPreStmt
->pNext
;
500 dbFreeStmt(pPreStmt
);
508 ** TCL calls this procedure when an sqlite3 database command is
511 static void SQLITE_TCLAPI
DbDeleteCmd(void *db
){
512 SqliteDb
*pDb
= (SqliteDb
*)db
;
514 closeIncrblobChannels(pDb
);
515 sqlite3_close(pDb
->db
);
517 SqlFunc
*pFunc
= pDb
->pFunc
;
518 pDb
->pFunc
= pFunc
->pNext
;
519 assert( pFunc
->pDb
==pDb
);
520 Tcl_DecrRefCount(pFunc
->pScript
);
521 Tcl_Free((char*)pFunc
);
523 while( pDb
->pCollate
){
524 SqlCollate
*pCollate
= pDb
->pCollate
;
525 pDb
->pCollate
= pCollate
->pNext
;
526 Tcl_Free((char*)pCollate
);
529 Tcl_Free(pDb
->zBusy
);
532 Tcl_Free(pDb
->zTrace
);
535 Tcl_Free(pDb
->zTraceV2
);
538 Tcl_Free(pDb
->zProfile
);
541 Tcl_Free(pDb
->zAuth
);
544 Tcl_Free(pDb
->zNull
);
546 if( pDb
->pUpdateHook
){
547 Tcl_DecrRefCount(pDb
->pUpdateHook
);
549 if( pDb
->pPreUpdateHook
){
550 Tcl_DecrRefCount(pDb
->pPreUpdateHook
);
552 if( pDb
->pRollbackHook
){
553 Tcl_DecrRefCount(pDb
->pRollbackHook
);
556 Tcl_DecrRefCount(pDb
->pWalHook
);
558 if( pDb
->pCollateNeeded
){
559 Tcl_DecrRefCount(pDb
->pCollateNeeded
);
561 Tcl_Free((char*)pDb
);
565 ** This routine is called when a database file is locked while trying
568 static int DbBusyHandler(void *cd
, int nTries
){
569 SqliteDb
*pDb
= (SqliteDb
*)cd
;
573 sqlite3_snprintf(sizeof(zVal
), zVal
, "%d", nTries
);
574 rc
= Tcl_VarEval(pDb
->interp
, pDb
->zBusy
, " ", zVal
, (char*)0);
575 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
581 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
583 ** This routine is invoked as the 'progress callback' for the database.
585 static int DbProgressHandler(void *cd
){
586 SqliteDb
*pDb
= (SqliteDb
*)cd
;
589 assert( pDb
->zProgress
);
590 rc
= Tcl_Eval(pDb
->interp
, pDb
->zProgress
);
591 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
598 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
599 !defined(SQLITE_OMIT_DEPRECATED)
601 ** This routine is called by the SQLite trace handler whenever a new
602 ** block of SQL is executed. The TCL script in pDb->zTrace is executed.
604 static void DbTraceHandler(void *cd
, const char *zSql
){
605 SqliteDb
*pDb
= (SqliteDb
*)cd
;
608 Tcl_DStringInit(&str
);
609 Tcl_DStringAppend(&str
, pDb
->zTrace
, -1);
610 Tcl_DStringAppendElement(&str
, zSql
);
611 Tcl_Eval(pDb
->interp
, Tcl_DStringValue(&str
));
612 Tcl_DStringFree(&str
);
613 Tcl_ResetResult(pDb
->interp
);
617 #ifndef SQLITE_OMIT_TRACE
619 ** This routine is called by the SQLite trace_v2 handler whenever a new
620 ** supported event is generated. Unsupported event types are ignored.
621 ** The TCL script in pDb->zTraceV2 is executed, with the arguments for
622 ** the event appended to it (as list elements).
624 static int DbTraceV2Handler(
625 unsigned type
, /* One of the SQLITE_TRACE_* event types. */
626 void *cd
, /* The original context data pointer. */
627 void *pd
, /* Primary event data, depends on event type. */
628 void *xd
/* Extra event data, depends on event type. */
630 SqliteDb
*pDb
= (SqliteDb
*)cd
;
634 case SQLITE_TRACE_STMT
: {
635 sqlite3_stmt
*pStmt
= (sqlite3_stmt
*)pd
;
636 char *zSql
= (char *)xd
;
638 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
639 Tcl_IncrRefCount(pCmd
);
640 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
641 Tcl_NewWideIntObj((Tcl_WideInt
)pStmt
));
642 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
643 Tcl_NewStringObj(zSql
, -1));
644 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
645 Tcl_DecrRefCount(pCmd
);
646 Tcl_ResetResult(pDb
->interp
);
649 case SQLITE_TRACE_PROFILE
: {
650 sqlite3_stmt
*pStmt
= (sqlite3_stmt
*)pd
;
651 sqlite3_int64 ns
= (sqlite3_int64
)xd
;
653 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
654 Tcl_IncrRefCount(pCmd
);
655 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
656 Tcl_NewWideIntObj((Tcl_WideInt
)pStmt
));
657 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
658 Tcl_NewWideIntObj((Tcl_WideInt
)ns
));
659 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
660 Tcl_DecrRefCount(pCmd
);
661 Tcl_ResetResult(pDb
->interp
);
664 case SQLITE_TRACE_ROW
: {
665 sqlite3_stmt
*pStmt
= (sqlite3_stmt
*)pd
;
667 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
668 Tcl_IncrRefCount(pCmd
);
669 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
670 Tcl_NewWideIntObj((Tcl_WideInt
)pStmt
));
671 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
672 Tcl_DecrRefCount(pCmd
);
673 Tcl_ResetResult(pDb
->interp
);
676 case SQLITE_TRACE_CLOSE
: {
677 sqlite3
*db
= (sqlite3
*)pd
;
679 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
680 Tcl_IncrRefCount(pCmd
);
681 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
682 Tcl_NewWideIntObj((Tcl_WideInt
)db
));
683 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
684 Tcl_DecrRefCount(pCmd
);
685 Tcl_ResetResult(pDb
->interp
);
693 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
694 !defined(SQLITE_OMIT_DEPRECATED)
696 ** This routine is called by the SQLite profile handler after a statement
697 ** SQL has executed. The TCL script in pDb->zProfile is evaluated.
699 static void DbProfileHandler(void *cd
, const char *zSql
, sqlite_uint64 tm
){
700 SqliteDb
*pDb
= (SqliteDb
*)cd
;
704 sqlite3_snprintf(sizeof(zTm
)-1, zTm
, "%lld", tm
);
705 Tcl_DStringInit(&str
);
706 Tcl_DStringAppend(&str
, pDb
->zProfile
, -1);
707 Tcl_DStringAppendElement(&str
, zSql
);
708 Tcl_DStringAppendElement(&str
, zTm
);
709 Tcl_Eval(pDb
->interp
, Tcl_DStringValue(&str
));
710 Tcl_DStringFree(&str
);
711 Tcl_ResetResult(pDb
->interp
);
716 ** This routine is called when a transaction is committed. The
717 ** TCL script in pDb->zCommit is executed. If it returns non-zero or
718 ** if it throws an exception, the transaction is rolled back instead
719 ** of being committed.
721 static int DbCommitHandler(void *cd
){
722 SqliteDb
*pDb
= (SqliteDb
*)cd
;
725 rc
= Tcl_Eval(pDb
->interp
, pDb
->zCommit
);
726 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
732 static void DbRollbackHandler(void *clientData
){
733 SqliteDb
*pDb
= (SqliteDb
*)clientData
;
734 assert(pDb
->pRollbackHook
);
735 if( TCL_OK
!=Tcl_EvalObjEx(pDb
->interp
, pDb
->pRollbackHook
, 0) ){
736 Tcl_BackgroundError(pDb
->interp
);
741 ** This procedure handles wal_hook callbacks.
743 static int DbWalHandler(
751 SqliteDb
*pDb
= (SqliteDb
*)clientData
;
752 Tcl_Interp
*interp
= pDb
->interp
;
753 assert(pDb
->pWalHook
);
755 assert( db
==pDb
->db
);
756 p
= Tcl_DuplicateObj(pDb
->pWalHook
);
758 Tcl_ListObjAppendElement(interp
, p
, Tcl_NewStringObj(zDb
, -1));
759 Tcl_ListObjAppendElement(interp
, p
, Tcl_NewIntObj(nEntry
));
760 if( TCL_OK
!=Tcl_EvalObjEx(interp
, p
, 0)
761 || TCL_OK
!=Tcl_GetIntFromObj(interp
, Tcl_GetObjResult(interp
), &ret
)
763 Tcl_BackgroundError(interp
);
770 #if defined(SQLITE_TEST) && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
771 static void setTestUnlockNotifyVars(Tcl_Interp
*interp
, int iArg
, int nArg
){
773 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%d", iArg
);
774 Tcl_SetVar(interp
, "sqlite_unlock_notify_arg", zBuf
, TCL_GLOBAL_ONLY
);
775 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%d", nArg
);
776 Tcl_SetVar(interp
, "sqlite_unlock_notify_argcount", zBuf
, TCL_GLOBAL_ONLY
);
779 # define setTestUnlockNotifyVars(x,y,z)
782 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
783 static void DbUnlockNotify(void **apArg
, int nArg
){
785 for(i
=0; i
<nArg
; i
++){
786 const int flags
= (TCL_EVAL_GLOBAL
|TCL_EVAL_DIRECT
);
787 SqliteDb
*pDb
= (SqliteDb
*)apArg
[i
];
788 setTestUnlockNotifyVars(pDb
->interp
, i
, nArg
);
789 assert( pDb
->pUnlockNotify
);
790 Tcl_EvalObjEx(pDb
->interp
, pDb
->pUnlockNotify
, flags
);
791 Tcl_DecrRefCount(pDb
->pUnlockNotify
);
792 pDb
->pUnlockNotify
= 0;
797 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
799 ** Pre-update hook callback.
801 static void DbPreUpdateHandler(
810 SqliteDb
*pDb
= (SqliteDb
*)p
;
812 static const char *azStr
[] = {"DELETE", "INSERT", "UPDATE"};
814 assert( (SQLITE_DELETE
-1)/9 == 0 );
815 assert( (SQLITE_INSERT
-1)/9 == 1 );
816 assert( (SQLITE_UPDATE
-1)/9 == 2 );
817 assert( pDb
->pPreUpdateHook
);
818 assert( db
==pDb
->db
);
819 assert( op
==SQLITE_INSERT
|| op
==SQLITE_UPDATE
|| op
==SQLITE_DELETE
);
821 pCmd
= Tcl_DuplicateObj(pDb
->pPreUpdateHook
);
822 Tcl_IncrRefCount(pCmd
);
823 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(azStr
[(op
-1)/9], -1));
824 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zDb
, -1));
825 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zTbl
, -1));
826 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewWideIntObj(iKey1
));
827 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewWideIntObj(iKey2
));
828 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
829 Tcl_DecrRefCount(pCmd
);
831 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
833 static void DbUpdateHandler(
840 SqliteDb
*pDb
= (SqliteDb
*)p
;
842 static const char *azStr
[] = {"DELETE", "INSERT", "UPDATE"};
844 assert( (SQLITE_DELETE
-1)/9 == 0 );
845 assert( (SQLITE_INSERT
-1)/9 == 1 );
846 assert( (SQLITE_UPDATE
-1)/9 == 2 );
848 assert( pDb
->pUpdateHook
);
849 assert( op
==SQLITE_INSERT
|| op
==SQLITE_UPDATE
|| op
==SQLITE_DELETE
);
851 pCmd
= Tcl_DuplicateObj(pDb
->pUpdateHook
);
852 Tcl_IncrRefCount(pCmd
);
853 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(azStr
[(op
-1)/9], -1));
854 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zDb
, -1));
855 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zTbl
, -1));
856 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewWideIntObj(rowid
));
857 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
858 Tcl_DecrRefCount(pCmd
);
861 static void tclCollateNeeded(
867 SqliteDb
*pDb
= (SqliteDb
*)pCtx
;
868 Tcl_Obj
*pScript
= Tcl_DuplicateObj(pDb
->pCollateNeeded
);
869 Tcl_IncrRefCount(pScript
);
870 Tcl_ListObjAppendElement(0, pScript
, Tcl_NewStringObj(zName
, -1));
871 Tcl_EvalObjEx(pDb
->interp
, pScript
, 0);
872 Tcl_DecrRefCount(pScript
);
876 ** This routine is called to evaluate an SQL collation function implemented
879 static int tclSqlCollate(
886 SqlCollate
*p
= (SqlCollate
*)pCtx
;
889 pCmd
= Tcl_NewStringObj(p
->zScript
, -1);
890 Tcl_IncrRefCount(pCmd
);
891 Tcl_ListObjAppendElement(p
->interp
, pCmd
, Tcl_NewStringObj(zA
, nA
));
892 Tcl_ListObjAppendElement(p
->interp
, pCmd
, Tcl_NewStringObj(zB
, nB
));
893 Tcl_EvalObjEx(p
->interp
, pCmd
, TCL_EVAL_DIRECT
);
894 Tcl_DecrRefCount(pCmd
);
895 return (atoi(Tcl_GetStringResult(p
->interp
)));
899 ** This routine is called to evaluate an SQL function implemented
902 static void tclSqlFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
903 SqlFunc
*p
= sqlite3_user_data(context
);
909 /* If there are no arguments to the function, call Tcl_EvalObjEx on the
910 ** script object directly. This allows the TCL compiler to generate
911 ** bytecode for the command on the first invocation and thus make
912 ** subsequent invocations much faster. */
914 Tcl_IncrRefCount(pCmd
);
915 rc
= Tcl_EvalObjEx(p
->interp
, pCmd
, 0);
916 Tcl_DecrRefCount(pCmd
);
918 /* If there are arguments to the function, make a shallow copy of the
919 ** script object, lappend the arguments, then evaluate the copy.
921 ** By "shallow" copy, we mean only the outer list Tcl_Obj is duplicated.
922 ** The new Tcl_Obj contains pointers to the original list elements.
923 ** That way, when Tcl_EvalObjv() is run and shimmers the first element
924 ** of the list to tclCmdNameType, that alternate representation will
925 ** be preserved and reused on the next invocation.
929 if( Tcl_ListObjGetElements(p
->interp
, p
->pScript
, &nArg
, &aArg
) ){
930 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
933 pCmd
= Tcl_NewListObj(nArg
, aArg
);
934 Tcl_IncrRefCount(pCmd
);
935 for(i
=0; i
<argc
; i
++){
936 sqlite3_value
*pIn
= argv
[i
];
939 /* Set pVal to contain the i'th column of this row. */
940 switch( sqlite3_value_type(pIn
) ){
942 int bytes
= sqlite3_value_bytes(pIn
);
943 pVal
= Tcl_NewByteArrayObj(sqlite3_value_blob(pIn
), bytes
);
946 case SQLITE_INTEGER
: {
947 sqlite_int64 v
= sqlite3_value_int64(pIn
);
948 if( v
>=-2147483647 && v
<=2147483647 ){
949 pVal
= Tcl_NewIntObj((int)v
);
951 pVal
= Tcl_NewWideIntObj(v
);
956 double r
= sqlite3_value_double(pIn
);
957 pVal
= Tcl_NewDoubleObj(r
);
961 pVal
= Tcl_NewStringObj(p
->pDb
->zNull
, -1);
965 int bytes
= sqlite3_value_bytes(pIn
);
966 pVal
= Tcl_NewStringObj((char *)sqlite3_value_text(pIn
), bytes
);
970 rc
= Tcl_ListObjAppendElement(p
->interp
, pCmd
, pVal
);
972 Tcl_DecrRefCount(pCmd
);
973 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
977 if( !p
->useEvalObjv
){
978 /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd
979 ** is a list without a string representation. To prevent this from
980 ** happening, make sure pCmd has a valid string representation */
983 rc
= Tcl_EvalObjEx(p
->interp
, pCmd
, TCL_EVAL_DIRECT
);
984 Tcl_DecrRefCount(pCmd
);
987 if( rc
&& rc
!=TCL_RETURN
){
988 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
990 Tcl_Obj
*pVar
= Tcl_GetObjResult(p
->interp
);
993 const char *zType
= (pVar
->typePtr
? pVar
->typePtr
->name
: "");
995 if( c
=='b' && strcmp(zType
,"bytearray")==0 && pVar
->bytes
==0 ){
996 /* Only return a BLOB type if the Tcl variable is a bytearray and
997 ** has no string representation. */
998 data
= Tcl_GetByteArrayFromObj(pVar
, &n
);
999 sqlite3_result_blob(context
, data
, n
, SQLITE_TRANSIENT
);
1000 }else if( c
=='b' && strcmp(zType
,"boolean")==0 ){
1001 Tcl_GetIntFromObj(0, pVar
, &n
);
1002 sqlite3_result_int(context
, n
);
1003 }else if( c
=='d' && strcmp(zType
,"double")==0 ){
1005 Tcl_GetDoubleFromObj(0, pVar
, &r
);
1006 sqlite3_result_double(context
, r
);
1007 }else if( (c
=='w' && strcmp(zType
,"wideInt")==0) ||
1008 (c
=='i' && strcmp(zType
,"int")==0) ){
1010 Tcl_GetWideIntFromObj(0, pVar
, &v
);
1011 sqlite3_result_int64(context
, v
);
1013 data
= (unsigned char *)Tcl_GetStringFromObj(pVar
, &n
);
1014 sqlite3_result_text(context
, (char *)data
, n
, SQLITE_TRANSIENT
);
1019 #ifndef SQLITE_OMIT_AUTHORIZATION
1021 ** This is the authentication function. It appends the authentication
1022 ** type code and the two arguments to zCmd[] then invokes the result
1023 ** on the interpreter. The reply is examined to determine if the
1024 ** authentication fails or succeeds.
1026 static int auth_callback(
1033 #ifdef SQLITE_USER_AUTHENTICATION
1041 /* EVIDENCE-OF: R-38590-62769 The first parameter to the authorizer
1042 ** callback is a copy of the third parameter to the
1043 ** sqlite3_set_authorizer() interface.
1045 SqliteDb
*pDb
= (SqliteDb
*)pArg
;
1046 if( pDb
->disableAuth
) return SQLITE_OK
;
1048 /* EVIDENCE-OF: R-56518-44310 The second parameter to the callback is an
1049 ** integer action code that specifies the particular action to be
1052 case SQLITE_COPY
: zCode
="SQLITE_COPY"; break;
1053 case SQLITE_CREATE_INDEX
: zCode
="SQLITE_CREATE_INDEX"; break;
1054 case SQLITE_CREATE_TABLE
: zCode
="SQLITE_CREATE_TABLE"; break;
1055 case SQLITE_CREATE_TEMP_INDEX
: zCode
="SQLITE_CREATE_TEMP_INDEX"; break;
1056 case SQLITE_CREATE_TEMP_TABLE
: zCode
="SQLITE_CREATE_TEMP_TABLE"; break;
1057 case SQLITE_CREATE_TEMP_TRIGGER
: zCode
="SQLITE_CREATE_TEMP_TRIGGER"; break;
1058 case SQLITE_CREATE_TEMP_VIEW
: zCode
="SQLITE_CREATE_TEMP_VIEW"; break;
1059 case SQLITE_CREATE_TRIGGER
: zCode
="SQLITE_CREATE_TRIGGER"; break;
1060 case SQLITE_CREATE_VIEW
: zCode
="SQLITE_CREATE_VIEW"; break;
1061 case SQLITE_DELETE
: zCode
="SQLITE_DELETE"; break;
1062 case SQLITE_DROP_INDEX
: zCode
="SQLITE_DROP_INDEX"; break;
1063 case SQLITE_DROP_TABLE
: zCode
="SQLITE_DROP_TABLE"; break;
1064 case SQLITE_DROP_TEMP_INDEX
: zCode
="SQLITE_DROP_TEMP_INDEX"; break;
1065 case SQLITE_DROP_TEMP_TABLE
: zCode
="SQLITE_DROP_TEMP_TABLE"; break;
1066 case SQLITE_DROP_TEMP_TRIGGER
: zCode
="SQLITE_DROP_TEMP_TRIGGER"; break;
1067 case SQLITE_DROP_TEMP_VIEW
: zCode
="SQLITE_DROP_TEMP_VIEW"; break;
1068 case SQLITE_DROP_TRIGGER
: zCode
="SQLITE_DROP_TRIGGER"; break;
1069 case SQLITE_DROP_VIEW
: zCode
="SQLITE_DROP_VIEW"; break;
1070 case SQLITE_INSERT
: zCode
="SQLITE_INSERT"; break;
1071 case SQLITE_PRAGMA
: zCode
="SQLITE_PRAGMA"; break;
1072 case SQLITE_READ
: zCode
="SQLITE_READ"; break;
1073 case SQLITE_SELECT
: zCode
="SQLITE_SELECT"; break;
1074 case SQLITE_TRANSACTION
: zCode
="SQLITE_TRANSACTION"; break;
1075 case SQLITE_UPDATE
: zCode
="SQLITE_UPDATE"; break;
1076 case SQLITE_ATTACH
: zCode
="SQLITE_ATTACH"; break;
1077 case SQLITE_DETACH
: zCode
="SQLITE_DETACH"; break;
1078 case SQLITE_ALTER_TABLE
: zCode
="SQLITE_ALTER_TABLE"; break;
1079 case SQLITE_REINDEX
: zCode
="SQLITE_REINDEX"; break;
1080 case SQLITE_ANALYZE
: zCode
="SQLITE_ANALYZE"; break;
1081 case SQLITE_CREATE_VTABLE
: zCode
="SQLITE_CREATE_VTABLE"; break;
1082 case SQLITE_DROP_VTABLE
: zCode
="SQLITE_DROP_VTABLE"; break;
1083 case SQLITE_FUNCTION
: zCode
="SQLITE_FUNCTION"; break;
1084 case SQLITE_SAVEPOINT
: zCode
="SQLITE_SAVEPOINT"; break;
1085 case SQLITE_RECURSIVE
: zCode
="SQLITE_RECURSIVE"; break;
1086 default : zCode
="????"; break;
1088 Tcl_DStringInit(&str
);
1089 Tcl_DStringAppend(&str
, pDb
->zAuth
, -1);
1090 Tcl_DStringAppendElement(&str
, zCode
);
1091 Tcl_DStringAppendElement(&str
, zArg1
? zArg1
: "");
1092 Tcl_DStringAppendElement(&str
, zArg2
? zArg2
: "");
1093 Tcl_DStringAppendElement(&str
, zArg3
? zArg3
: "");
1094 Tcl_DStringAppendElement(&str
, zArg4
? zArg4
: "");
1095 #ifdef SQLITE_USER_AUTHENTICATION
1096 Tcl_DStringAppendElement(&str
, zArg5
? zArg5
: "");
1098 rc
= Tcl_GlobalEval(pDb
->interp
, Tcl_DStringValue(&str
));
1099 Tcl_DStringFree(&str
);
1100 zReply
= rc
==TCL_OK
? Tcl_GetStringResult(pDb
->interp
) : "SQLITE_DENY";
1101 if( strcmp(zReply
,"SQLITE_OK")==0 ){
1103 }else if( strcmp(zReply
,"SQLITE_DENY")==0 ){
1105 }else if( strcmp(zReply
,"SQLITE_IGNORE")==0 ){
1112 #endif /* SQLITE_OMIT_AUTHORIZATION */
1115 ** This routine reads a line of text from FILE in, stores
1116 ** the text in memory obtained from malloc() and returns a pointer
1117 ** to the text. NULL is returned at end of file, or if malloc()
1120 ** The interface is like "readline" but no command-line editing
1123 ** copied from shell.c from '.import' command
1125 static char *local_getline(char *zPrompt
, FILE *in
){
1131 zLine
= malloc( nLine
);
1132 if( zLine
==0 ) return 0;
1136 nLine
= nLine
*2 + 100;
1137 zLine
= realloc(zLine
, nLine
);
1138 if( zLine
==0 ) return 0;
1140 if( fgets(&zLine
[n
], nLine
- n
, in
)==0 ){
1148 while( zLine
[n
] ){ n
++; }
1149 if( n
>0 && zLine
[n
-1]=='\n' ){
1155 zLine
= realloc( zLine
, n
+1 );
1161 ** This function is part of the implementation of the command:
1163 ** $db transaction [-deferred|-immediate|-exclusive] SCRIPT
1165 ** It is invoked after evaluating the script SCRIPT to commit or rollback
1166 ** the transaction or savepoint opened by the [transaction] command.
1168 static int SQLITE_TCLAPI
DbTransPostCmd(
1169 ClientData data
[], /* data[0] is the Sqlite3Db* for $db */
1170 Tcl_Interp
*interp
, /* Tcl interpreter */
1171 int result
/* Result of evaluating SCRIPT */
1173 static const char *const azEnd
[] = {
1174 "RELEASE _tcl_transaction", /* rc==TCL_ERROR, nTransaction!=0 */
1175 "COMMIT", /* rc!=TCL_ERROR, nTransaction==0 */
1176 "ROLLBACK TO _tcl_transaction ; RELEASE _tcl_transaction",
1177 "ROLLBACK" /* rc==TCL_ERROR, nTransaction==0 */
1179 SqliteDb
*pDb
= (SqliteDb
*)data
[0];
1183 pDb
->nTransaction
--;
1184 zEnd
= azEnd
[(rc
==TCL_ERROR
)*2 + (pDb
->nTransaction
==0)];
1187 if( sqlite3_exec(pDb
->db
, zEnd
, 0, 0, 0) ){
1188 /* This is a tricky scenario to handle. The most likely cause of an
1189 ** error is that the exec() above was an attempt to commit the
1190 ** top-level transaction that returned SQLITE_BUSY. Or, less likely,
1191 ** that an IO-error has occurred. In either case, throw a Tcl exception
1192 ** and try to rollback the transaction.
1194 ** But it could also be that the user executed one or more BEGIN,
1195 ** COMMIT, SAVEPOINT, RELEASE or ROLLBACK commands that are confusing
1196 ** this method's logic. Not clear how this would be best handled.
1198 if( rc
!=TCL_ERROR
){
1199 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
1202 sqlite3_exec(pDb
->db
, "ROLLBACK", 0, 0, 0);
1210 ** Unless SQLITE_TEST is defined, this function is a simple wrapper around
1211 ** sqlite3_prepare_v2(). If SQLITE_TEST is defined, then it uses either
1212 ** sqlite3_prepare_v2() or legacy interface sqlite3_prepare(), depending
1213 ** on whether or not the [db_use_legacy_prepare] command has been used to
1214 ** configure the connection.
1216 static int dbPrepare(
1217 SqliteDb
*pDb
, /* Database object */
1218 const char *zSql
, /* SQL to compile */
1219 sqlite3_stmt
**ppStmt
, /* OUT: Prepared statement */
1220 const char **pzOut
/* OUT: Pointer to next SQL statement */
1222 unsigned int prepFlags
= 0;
1224 if( pDb
->bLegacyPrepare
){
1225 return sqlite3_prepare(pDb
->db
, zSql
, -1, ppStmt
, pzOut
);
1228 /* If the statement cache is large, use the SQLITE_PREPARE_PERSISTENT
1229 ** flags, which uses less lookaside memory. But if the cache is small,
1230 ** omit that flag to make full use of lookaside */
1231 if( pDb
->maxStmt
>5 ) prepFlags
= SQLITE_PREPARE_PERSISTENT
;
1233 return sqlite3_prepare_v3(pDb
->db
, zSql
, -1, prepFlags
, ppStmt
, pzOut
);
1237 ** Search the cache for a prepared-statement object that implements the
1238 ** first SQL statement in the buffer pointed to by parameter zIn. If
1239 ** no such prepared-statement can be found, allocate and prepare a new
1240 ** one. In either case, bind the current values of the relevant Tcl
1241 ** variables to any $var, :var or @var variables in the statement. Before
1242 ** returning, set *ppPreStmt to point to the prepared-statement object.
1244 ** Output parameter *pzOut is set to point to the next SQL statement in
1245 ** buffer zIn, or to the '\0' byte at the end of zIn if there is no
1248 ** If successful, TCL_OK is returned. Otherwise, TCL_ERROR is returned
1249 ** and an error message loaded into interpreter pDb->interp.
1251 static int dbPrepareAndBind(
1252 SqliteDb
*pDb
, /* Database object */
1253 char const *zIn
, /* SQL to compile */
1254 char const **pzOut
, /* OUT: Pointer to next SQL statement */
1255 SqlPreparedStmt
**ppPreStmt
/* OUT: Object used to cache statement */
1257 const char *zSql
= zIn
; /* Pointer to first SQL statement in zIn */
1258 sqlite3_stmt
*pStmt
= 0; /* Prepared statement object */
1259 SqlPreparedStmt
*pPreStmt
; /* Pointer to cached statement */
1260 int nSql
; /* Length of zSql in bytes */
1261 int nVar
= 0; /* Number of variables in statement */
1262 int iParm
= 0; /* Next free entry in apParm */
1265 Tcl_Interp
*interp
= pDb
->interp
;
1269 /* Trim spaces from the start of zSql and calculate the remaining length. */
1270 while( (c
= zSql
[0])==' ' || c
=='\t' || c
=='\r' || c
=='\n' ){ zSql
++; }
1271 nSql
= strlen30(zSql
);
1273 for(pPreStmt
= pDb
->stmtList
; pPreStmt
; pPreStmt
=pPreStmt
->pNext
){
1274 int n
= pPreStmt
->nSql
;
1276 && memcmp(pPreStmt
->zSql
, zSql
, n
)==0
1277 && (zSql
[n
]==0 || zSql
[n
-1]==';')
1279 pStmt
= pPreStmt
->pStmt
;
1280 *pzOut
= &zSql
[pPreStmt
->nSql
];
1282 /* When a prepared statement is found, unlink it from the
1283 ** cache list. It will later be added back to the beginning
1284 ** of the cache list in order to implement LRU replacement.
1286 if( pPreStmt
->pPrev
){
1287 pPreStmt
->pPrev
->pNext
= pPreStmt
->pNext
;
1289 pDb
->stmtList
= pPreStmt
->pNext
;
1291 if( pPreStmt
->pNext
){
1292 pPreStmt
->pNext
->pPrev
= pPreStmt
->pPrev
;
1294 pDb
->stmtLast
= pPreStmt
->pPrev
;
1297 nVar
= sqlite3_bind_parameter_count(pStmt
);
1302 /* If no prepared statement was found. Compile the SQL text. Also allocate
1303 ** a new SqlPreparedStmt structure. */
1307 if( SQLITE_OK
!=dbPrepare(pDb
, zSql
, &pStmt
, pzOut
) ){
1308 Tcl_SetObjResult(interp
, Tcl_NewStringObj(sqlite3_errmsg(pDb
->db
), -1));
1312 if( SQLITE_OK
!=sqlite3_errcode(pDb
->db
) ){
1313 /* A compile-time error in the statement. */
1314 Tcl_SetObjResult(interp
, Tcl_NewStringObj(sqlite3_errmsg(pDb
->db
), -1));
1317 /* The statement was a no-op. Continue to the next statement
1318 ** in the SQL string.
1324 assert( pPreStmt
==0 );
1325 nVar
= sqlite3_bind_parameter_count(pStmt
);
1326 nByte
= sizeof(SqlPreparedStmt
) + nVar
*sizeof(Tcl_Obj
*);
1327 pPreStmt
= (SqlPreparedStmt
*)Tcl_Alloc(nByte
);
1328 memset(pPreStmt
, 0, nByte
);
1330 pPreStmt
->pStmt
= pStmt
;
1331 pPreStmt
->nSql
= (int)(*pzOut
- zSql
);
1332 pPreStmt
->zSql
= sqlite3_sql(pStmt
);
1333 pPreStmt
->apParm
= (Tcl_Obj
**)&pPreStmt
[1];
1335 if( pPreStmt
->zSql
==0 ){
1336 char *zCopy
= Tcl_Alloc(pPreStmt
->nSql
+ 1);
1337 memcpy(zCopy
, zSql
, pPreStmt
->nSql
);
1338 zCopy
[pPreStmt
->nSql
] = '\0';
1339 pPreStmt
->zSql
= zCopy
;
1344 assert( strlen30(pPreStmt
->zSql
)==pPreStmt
->nSql
);
1345 assert( 0==memcmp(pPreStmt
->zSql
, zSql
, pPreStmt
->nSql
) );
1347 /* Bind values to parameters that begin with $ or : */
1348 for(i
=1; i
<=nVar
; i
++){
1349 const char *zVar
= sqlite3_bind_parameter_name(pStmt
, i
);
1350 if( zVar
!=0 && (zVar
[0]=='$' || zVar
[0]==':' || zVar
[0]=='@') ){
1351 Tcl_Obj
*pVar
= Tcl_GetVar2Ex(interp
, &zVar
[1], 0, 0);
1355 const char *zType
= (pVar
->typePtr
? pVar
->typePtr
->name
: "");
1358 (c
=='b' && strcmp(zType
,"bytearray")==0 && pVar
->bytes
==0) ){
1359 /* Load a BLOB type if the Tcl variable is a bytearray and
1360 ** it has no string representation or the host
1361 ** parameter name begins with "@". */
1362 data
= Tcl_GetByteArrayFromObj(pVar
, &n
);
1363 sqlite3_bind_blob(pStmt
, i
, data
, n
, SQLITE_STATIC
);
1364 Tcl_IncrRefCount(pVar
);
1365 pPreStmt
->apParm
[iParm
++] = pVar
;
1366 }else if( c
=='b' && strcmp(zType
,"boolean")==0 ){
1367 Tcl_GetIntFromObj(interp
, pVar
, &n
);
1368 sqlite3_bind_int(pStmt
, i
, n
);
1369 }else if( c
=='d' && strcmp(zType
,"double")==0 ){
1371 Tcl_GetDoubleFromObj(interp
, pVar
, &r
);
1372 sqlite3_bind_double(pStmt
, i
, r
);
1373 }else if( (c
=='w' && strcmp(zType
,"wideInt")==0) ||
1374 (c
=='i' && strcmp(zType
,"int")==0) ){
1376 Tcl_GetWideIntFromObj(interp
, pVar
, &v
);
1377 sqlite3_bind_int64(pStmt
, i
, v
);
1379 data
= (unsigned char *)Tcl_GetStringFromObj(pVar
, &n
);
1380 sqlite3_bind_text(pStmt
, i
, (char *)data
, n
, SQLITE_STATIC
);
1381 Tcl_IncrRefCount(pVar
);
1382 pPreStmt
->apParm
[iParm
++] = pVar
;
1385 sqlite3_bind_null(pStmt
, i
);
1389 pPreStmt
->nParm
= iParm
;
1390 *ppPreStmt
= pPreStmt
;
1396 ** Release a statement reference obtained by calling dbPrepareAndBind().
1397 ** There should be exactly one call to this function for each call to
1398 ** dbPrepareAndBind().
1400 ** If the discard parameter is non-zero, then the statement is deleted
1401 ** immediately. Otherwise it is added to the LRU list and may be returned
1402 ** by a subsequent call to dbPrepareAndBind().
1404 static void dbReleaseStmt(
1405 SqliteDb
*pDb
, /* Database handle */
1406 SqlPreparedStmt
*pPreStmt
, /* Prepared statement handle to release */
1407 int discard
/* True to delete (not cache) the pPreStmt */
1411 /* Free the bound string and blob parameters */
1412 for(i
=0; i
<pPreStmt
->nParm
; i
++){
1413 Tcl_DecrRefCount(pPreStmt
->apParm
[i
]);
1415 pPreStmt
->nParm
= 0;
1417 if( pDb
->maxStmt
<=0 || discard
){
1418 /* If the cache is turned off, deallocated the statement */
1419 dbFreeStmt(pPreStmt
);
1421 /* Add the prepared statement to the beginning of the cache list. */
1422 pPreStmt
->pNext
= pDb
->stmtList
;
1423 pPreStmt
->pPrev
= 0;
1424 if( pDb
->stmtList
){
1425 pDb
->stmtList
->pPrev
= pPreStmt
;
1427 pDb
->stmtList
= pPreStmt
;
1428 if( pDb
->stmtLast
==0 ){
1429 assert( pDb
->nStmt
==0 );
1430 pDb
->stmtLast
= pPreStmt
;
1432 assert( pDb
->nStmt
>0 );
1436 /* If we have too many statement in cache, remove the surplus from
1437 ** the end of the cache list. */
1438 while( pDb
->nStmt
>pDb
->maxStmt
){
1439 SqlPreparedStmt
*pLast
= pDb
->stmtLast
;
1440 pDb
->stmtLast
= pLast
->pPrev
;
1441 pDb
->stmtLast
->pNext
= 0;
1449 ** Structure used with dbEvalXXX() functions:
1455 ** dbEvalColumnValue()
1457 typedef struct DbEvalContext DbEvalContext
;
1458 struct DbEvalContext
{
1459 SqliteDb
*pDb
; /* Database handle */
1460 Tcl_Obj
*pSql
; /* Object holding string zSql */
1461 const char *zSql
; /* Remaining SQL to execute */
1462 SqlPreparedStmt
*pPreStmt
; /* Current statement */
1463 int nCol
; /* Number of columns returned by pStmt */
1464 int evalFlags
; /* Flags used */
1465 Tcl_Obj
*pArray
; /* Name of array variable */
1466 Tcl_Obj
**apColName
; /* Array of column names */
1469 #define SQLITE_EVAL_WITHOUTNULLS 0x00001 /* Unset array(*) for NULL */
1472 ** Release any cache of column names currently held as part of
1473 ** the DbEvalContext structure passed as the first argument.
1475 static void dbReleaseColumnNames(DbEvalContext
*p
){
1478 for(i
=0; i
<p
->nCol
; i
++){
1479 Tcl_DecrRefCount(p
->apColName
[i
]);
1481 Tcl_Free((char *)p
->apColName
);
1488 ** Initialize a DbEvalContext structure.
1490 ** If pArray is not NULL, then it contains the name of a Tcl array
1491 ** variable. The "*" member of this array is set to a list containing
1492 ** the names of the columns returned by the statement as part of each
1493 ** call to dbEvalStep(), in order from left to right. e.g. if the names
1494 ** of the returned columns are a, b and c, it does the equivalent of the
1497 ** set ${pArray}(*) {a b c}
1499 static void dbEvalInit(
1500 DbEvalContext
*p
, /* Pointer to structure to initialize */
1501 SqliteDb
*pDb
, /* Database handle */
1502 Tcl_Obj
*pSql
, /* Object containing SQL script */
1503 Tcl_Obj
*pArray
, /* Name of Tcl array to set (*) element of */
1504 int evalFlags
/* Flags controlling evaluation */
1506 memset(p
, 0, sizeof(DbEvalContext
));
1508 p
->zSql
= Tcl_GetString(pSql
);
1510 Tcl_IncrRefCount(pSql
);
1513 Tcl_IncrRefCount(pArray
);
1515 p
->evalFlags
= evalFlags
;
1519 ** Obtain information about the row that the DbEvalContext passed as the
1520 ** first argument currently points to.
1522 static void dbEvalRowInfo(
1523 DbEvalContext
*p
, /* Evaluation context */
1524 int *pnCol
, /* OUT: Number of column names */
1525 Tcl_Obj
***papColName
/* OUT: Array of column names */
1527 /* Compute column names */
1528 if( 0==p
->apColName
){
1529 sqlite3_stmt
*pStmt
= p
->pPreStmt
->pStmt
;
1530 int i
; /* Iterator variable */
1531 int nCol
; /* Number of columns returned by pStmt */
1532 Tcl_Obj
**apColName
= 0; /* Array of column names */
1534 p
->nCol
= nCol
= sqlite3_column_count(pStmt
);
1535 if( nCol
>0 && (papColName
|| p
->pArray
) ){
1536 apColName
= (Tcl_Obj
**)Tcl_Alloc( sizeof(Tcl_Obj
*)*nCol
);
1537 for(i
=0; i
<nCol
; i
++){
1538 apColName
[i
] = Tcl_NewStringObj(sqlite3_column_name(pStmt
,i
), -1);
1539 Tcl_IncrRefCount(apColName
[i
]);
1541 p
->apColName
= apColName
;
1544 /* If results are being stored in an array variable, then create
1545 ** the array(*) entry for that array
1548 Tcl_Interp
*interp
= p
->pDb
->interp
;
1549 Tcl_Obj
*pColList
= Tcl_NewObj();
1550 Tcl_Obj
*pStar
= Tcl_NewStringObj("*", -1);
1552 for(i
=0; i
<nCol
; i
++){
1553 Tcl_ListObjAppendElement(interp
, pColList
, apColName
[i
]);
1555 Tcl_IncrRefCount(pStar
);
1556 Tcl_ObjSetVar2(interp
, p
->pArray
, pStar
, pColList
, 0);
1557 Tcl_DecrRefCount(pStar
);
1562 *papColName
= p
->apColName
;
1570 ** Return one of TCL_OK, TCL_BREAK or TCL_ERROR. If TCL_ERROR is
1571 ** returned, then an error message is stored in the interpreter before
1574 ** A return value of TCL_OK means there is a row of data available. The
1575 ** data may be accessed using dbEvalRowInfo() and dbEvalColumnValue(). This
1576 ** is analogous to a return of SQLITE_ROW from sqlite3_step(). If TCL_BREAK
1577 ** is returned, then the SQL script has finished executing and there are
1578 ** no further rows available. This is similar to SQLITE_DONE.
1580 static int dbEvalStep(DbEvalContext
*p
){
1581 const char *zPrevSql
= 0; /* Previous value of p->zSql */
1583 while( p
->zSql
[0] || p
->pPreStmt
){
1585 if( p
->pPreStmt
==0 ){
1586 zPrevSql
= (p
->zSql
==zPrevSql
? 0 : p
->zSql
);
1587 rc
= dbPrepareAndBind(p
->pDb
, p
->zSql
, &p
->zSql
, &p
->pPreStmt
);
1588 if( rc
!=TCL_OK
) return rc
;
1591 SqliteDb
*pDb
= p
->pDb
;
1592 SqlPreparedStmt
*pPreStmt
= p
->pPreStmt
;
1593 sqlite3_stmt
*pStmt
= pPreStmt
->pStmt
;
1595 rcs
= sqlite3_step(pStmt
);
1596 if( rcs
==SQLITE_ROW
){
1600 dbEvalRowInfo(p
, 0, 0);
1602 rcs
= sqlite3_reset(pStmt
);
1604 pDb
->nStep
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_FULLSCAN_STEP
,1);
1605 pDb
->nSort
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_SORT
,1);
1606 pDb
->nIndex
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_AUTOINDEX
,1);
1607 pDb
->nVMStep
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_VM_STEP
,1);
1608 dbReleaseColumnNames(p
);
1611 if( rcs
!=SQLITE_OK
){
1612 /* If a run-time error occurs, report the error and stop reading
1614 dbReleaseStmt(pDb
, pPreStmt
, 1);
1616 if( p
->pDb
->bLegacyPrepare
&& rcs
==SQLITE_SCHEMA
&& zPrevSql
){
1617 /* If the runtime error was an SQLITE_SCHEMA, and the database
1618 ** handle is configured to use the legacy sqlite3_prepare()
1619 ** interface, retry prepare()/step() on the same SQL statement.
1620 ** This only happens once. If there is a second SQLITE_SCHEMA
1621 ** error, the error will be returned to the caller. */
1626 Tcl_SetObjResult(pDb
->interp
,
1627 Tcl_NewStringObj(sqlite3_errmsg(pDb
->db
), -1));
1630 dbReleaseStmt(pDb
, pPreStmt
, 0);
1640 ** Free all resources currently held by the DbEvalContext structure passed
1641 ** as the first argument. There should be exactly one call to this function
1642 ** for each call to dbEvalInit().
1644 static void dbEvalFinalize(DbEvalContext
*p
){
1646 sqlite3_reset(p
->pPreStmt
->pStmt
);
1647 dbReleaseStmt(p
->pDb
, p
->pPreStmt
, 0);
1651 Tcl_DecrRefCount(p
->pArray
);
1654 Tcl_DecrRefCount(p
->pSql
);
1655 dbReleaseColumnNames(p
);
1659 ** Return a pointer to a Tcl_Obj structure with ref-count 0 that contains
1660 ** the value for the iCol'th column of the row currently pointed to by
1661 ** the DbEvalContext structure passed as the first argument.
1663 static Tcl_Obj
*dbEvalColumnValue(DbEvalContext
*p
, int iCol
){
1664 sqlite3_stmt
*pStmt
= p
->pPreStmt
->pStmt
;
1665 switch( sqlite3_column_type(pStmt
, iCol
) ){
1667 int bytes
= sqlite3_column_bytes(pStmt
, iCol
);
1668 const char *zBlob
= sqlite3_column_blob(pStmt
, iCol
);
1669 if( !zBlob
) bytes
= 0;
1670 return Tcl_NewByteArrayObj((u8
*)zBlob
, bytes
);
1672 case SQLITE_INTEGER
: {
1673 sqlite_int64 v
= sqlite3_column_int64(pStmt
, iCol
);
1674 if( v
>=-2147483647 && v
<=2147483647 ){
1675 return Tcl_NewIntObj((int)v
);
1677 return Tcl_NewWideIntObj(v
);
1680 case SQLITE_FLOAT
: {
1681 return Tcl_NewDoubleObj(sqlite3_column_double(pStmt
, iCol
));
1684 return Tcl_NewStringObj(p
->pDb
->zNull
, -1);
1688 return Tcl_NewStringObj((char*)sqlite3_column_text(pStmt
, iCol
), -1);
1692 ** If using Tcl version 8.6 or greater, use the NR functions to avoid
1693 ** recursive evalution of scripts by the [db eval] and [db trans]
1694 ** commands. Even if the headers used while compiling the extension
1695 ** are 8.6 or newer, the code still tests the Tcl version at runtime.
1696 ** This allows stubs-enabled builds to be used with older Tcl libraries.
1698 #if TCL_MAJOR_VERSION>8 || (TCL_MAJOR_VERSION==8 && TCL_MINOR_VERSION>=6)
1699 # define SQLITE_TCL_NRE 1
1700 static int DbUseNre(void){
1702 Tcl_GetVersion(&major
, &minor
, 0, 0);
1703 return( (major
==8 && minor
>=6) || major
>8 );
1707 ** Compiling using headers earlier than 8.6. In this case NR cannot be
1708 ** used, so DbUseNre() to always return zero. Add #defines for the other
1709 ** Tcl_NRxxx() functions to prevent them from causing compilation errors,
1710 ** even though the only invocations of them are within conditional blocks
1713 ** if( DbUseNre() ) { ... }
1715 # define SQLITE_TCL_NRE 0
1716 # define DbUseNre() 0
1717 # define Tcl_NRAddCallback(a,b,c,d,e,f) (void)0
1718 # define Tcl_NREvalObj(a,b,c) 0
1719 # define Tcl_NRCreateCommand(a,b,c,d,e,f) (void)0
1723 ** This function is part of the implementation of the command:
1725 ** $db eval SQL ?ARRAYNAME? SCRIPT
1727 static int SQLITE_TCLAPI
DbEvalNextCmd(
1728 ClientData data
[], /* data[0] is the (DbEvalContext*) */
1729 Tcl_Interp
*interp
, /* Tcl interpreter */
1730 int result
/* Result so far */
1732 int rc
= result
; /* Return code */
1734 /* The first element of the data[] array is a pointer to a DbEvalContext
1735 ** structure allocated using Tcl_Alloc(). The second element of data[]
1736 ** is a pointer to a Tcl_Obj containing the script to run for each row
1737 ** returned by the queries encapsulated in data[0]. */
1738 DbEvalContext
*p
= (DbEvalContext
*)data
[0];
1739 Tcl_Obj
*pScript
= (Tcl_Obj
*)data
[1];
1740 Tcl_Obj
*pArray
= p
->pArray
;
1742 while( (rc
==TCL_OK
|| rc
==TCL_CONTINUE
) && TCL_OK
==(rc
= dbEvalStep(p
)) ){
1745 Tcl_Obj
**apColName
;
1746 dbEvalRowInfo(p
, &nCol
, &apColName
);
1747 for(i
=0; i
<nCol
; i
++){
1749 Tcl_ObjSetVar2(interp
, apColName
[i
], 0, dbEvalColumnValue(p
,i
), 0);
1750 }else if( (p
->evalFlags
& SQLITE_EVAL_WITHOUTNULLS
)!=0
1751 && sqlite3_column_type(p
->pPreStmt
->pStmt
, i
)==SQLITE_NULL
1753 Tcl_UnsetVar2(interp
, Tcl_GetString(pArray
),
1754 Tcl_GetString(apColName
[i
]), 0);
1756 Tcl_ObjSetVar2(interp
, pArray
, apColName
[i
], dbEvalColumnValue(p
,i
), 0);
1760 /* The required interpreter variables are now populated with the data
1761 ** from the current row. If using NRE, schedule callbacks to evaluate
1762 ** script pScript, then to invoke this function again to fetch the next
1763 ** row (or clean up if there is no next row or the script throws an
1764 ** exception). After scheduling the callbacks, return control to the
1767 ** If not using NRE, evaluate pScript directly and continue with the
1768 ** next iteration of this while(...) loop. */
1770 Tcl_NRAddCallback(interp
, DbEvalNextCmd
, (void*)p
, (void*)pScript
, 0, 0);
1771 return Tcl_NREvalObj(interp
, pScript
, 0);
1773 rc
= Tcl_EvalObjEx(interp
, pScript
, 0);
1777 Tcl_DecrRefCount(pScript
);
1779 Tcl_Free((char *)p
);
1781 if( rc
==TCL_OK
|| rc
==TCL_BREAK
){
1782 Tcl_ResetResult(interp
);
1789 ** This function is used by the implementations of the following database
1790 ** handle sub-commands:
1792 ** $db update_hook ?SCRIPT?
1793 ** $db wal_hook ?SCRIPT?
1794 ** $db commit_hook ?SCRIPT?
1795 ** $db preupdate hook ?SCRIPT?
1797 static void DbHookCmd(
1798 Tcl_Interp
*interp
, /* Tcl interpreter */
1799 SqliteDb
*pDb
, /* Database handle */
1800 Tcl_Obj
*pArg
, /* SCRIPT argument (or NULL) */
1801 Tcl_Obj
**ppHook
/* Pointer to member of SqliteDb */
1803 sqlite3
*db
= pDb
->db
;
1806 Tcl_SetObjResult(interp
, *ppHook
);
1808 Tcl_DecrRefCount(*ppHook
);
1813 assert( !(*ppHook
) );
1814 if( Tcl_GetCharLength(pArg
)>0 ){
1816 Tcl_IncrRefCount(*ppHook
);
1820 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1821 sqlite3_preupdate_hook(db
, (pDb
->pPreUpdateHook
?DbPreUpdateHandler
:0), pDb
);
1823 sqlite3_update_hook(db
, (pDb
->pUpdateHook
?DbUpdateHandler
:0), pDb
);
1824 sqlite3_rollback_hook(db
, (pDb
->pRollbackHook
?DbRollbackHandler
:0), pDb
);
1825 sqlite3_wal_hook(db
, (pDb
->pWalHook
?DbWalHandler
:0), pDb
);
1829 ** The "sqlite" command below creates a new Tcl command for each
1830 ** connection it opens to an SQLite database. This routine is invoked
1831 ** whenever one of those connection-specific commands is executed
1832 ** in Tcl. For example, if you run Tcl code like this:
1834 ** sqlite3 db1 "my_database"
1837 ** The first command opens a connection to the "my_database" database
1838 ** and calls that connection "db1". The second command causes this
1839 ** subroutine to be invoked.
1841 static int SQLITE_TCLAPI
DbObjCmd(
1847 SqliteDb
*pDb
= (SqliteDb
*)cd
;
1850 static const char *DB_strs
[] = {
1851 "authorizer", "backup", "busy",
1852 "cache", "changes", "close",
1853 "collate", "collation_needed", "commit_hook",
1854 "complete", "copy", "enable_load_extension",
1855 "errorcode", "eval", "exists",
1856 "function", "incrblob", "interrupt",
1857 "last_insert_rowid", "nullvalue", "onecolumn",
1858 "preupdate", "profile", "progress",
1859 "rekey", "restore", "rollback_hook",
1860 "status", "timeout", "total_changes",
1861 "trace", "trace_v2", "transaction",
1862 "unlock_notify", "update_hook", "version",
1867 DB_AUTHORIZER
, DB_BACKUP
, DB_BUSY
,
1868 DB_CACHE
, DB_CHANGES
, DB_CLOSE
,
1869 DB_COLLATE
, DB_COLLATION_NEEDED
, DB_COMMIT_HOOK
,
1870 DB_COMPLETE
, DB_COPY
, DB_ENABLE_LOAD_EXTENSION
,
1871 DB_ERRORCODE
, DB_EVAL
, DB_EXISTS
,
1872 DB_FUNCTION
, DB_INCRBLOB
, DB_INTERRUPT
,
1873 DB_LAST_INSERT_ROWID
, DB_NULLVALUE
, DB_ONECOLUMN
,
1874 DB_PREUPDATE
, DB_PROFILE
, DB_PROGRESS
,
1875 DB_REKEY
, DB_RESTORE
, DB_ROLLBACK_HOOK
,
1876 DB_STATUS
, DB_TIMEOUT
, DB_TOTAL_CHANGES
,
1877 DB_TRACE
, DB_TRACE_V2
, DB_TRANSACTION
,
1878 DB_UNLOCK_NOTIFY
, DB_UPDATE_HOOK
, DB_VERSION
,
1881 /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
1884 Tcl_WrongNumArgs(interp
, 1, objv
, "SUBCOMMAND ...");
1887 if( Tcl_GetIndexFromObj(interp
, objv
[1], DB_strs
, "option", 0, &choice
) ){
1891 switch( (enum DB_enum
)choice
){
1893 /* $db authorizer ?CALLBACK?
1895 ** Invoke the given callback to authorize each SQL operation as it is
1896 ** compiled. 5 arguments are appended to the callback before it is
1899 ** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
1900 ** (2) First descriptive name (depends on authorization type)
1901 ** (3) Second descriptive name
1902 ** (4) Name of the database (ex: "main", "temp")
1903 ** (5) Name of trigger that is doing the access
1905 ** The callback should return on of the following strings: SQLITE_OK,
1906 ** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error.
1908 ** If this method is invoked with no arguments, the current authorization
1909 ** callback string is returned.
1911 case DB_AUTHORIZER
: {
1912 #ifdef SQLITE_OMIT_AUTHORIZATION
1913 Tcl_AppendResult(interp
, "authorization not available in this build",
1918 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
1920 }else if( objc
==2 ){
1922 Tcl_AppendResult(interp
, pDb
->zAuth
, (char*)0);
1928 Tcl_Free(pDb
->zAuth
);
1930 zAuth
= Tcl_GetStringFromObj(objv
[2], &len
);
1931 if( zAuth
&& len
>0 ){
1932 pDb
->zAuth
= Tcl_Alloc( len
+ 1 );
1933 memcpy(pDb
->zAuth
, zAuth
, len
+1);
1938 typedef int (*sqlite3_auth_cb
)(
1939 void*,int,const char*,const char*,
1940 const char*,const char*);
1941 pDb
->interp
= interp
;
1942 sqlite3_set_authorizer(pDb
->db
,(sqlite3_auth_cb
)auth_callback
,pDb
);
1944 sqlite3_set_authorizer(pDb
->db
, 0, 0);
1951 /* $db backup ?DATABASE? FILENAME
1953 ** Open or create a database file named FILENAME. Transfer the
1954 ** content of local database DATABASE (default: "main") into the
1955 ** FILENAME database.
1958 const char *zDestFile
;
1961 sqlite3_backup
*pBackup
;
1965 zDestFile
= Tcl_GetString(objv
[2]);
1966 }else if( objc
==4 ){
1967 zSrcDb
= Tcl_GetString(objv
[2]);
1968 zDestFile
= Tcl_GetString(objv
[3]);
1970 Tcl_WrongNumArgs(interp
, 2, objv
, "?DATABASE? FILENAME");
1973 rc
= sqlite3_open_v2(zDestFile
, &pDest
,
1974 SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
| pDb
->openFlags
, 0);
1975 if( rc
!=SQLITE_OK
){
1976 Tcl_AppendResult(interp
, "cannot open target database: ",
1977 sqlite3_errmsg(pDest
), (char*)0);
1978 sqlite3_close(pDest
);
1981 pBackup
= sqlite3_backup_init(pDest
, "main", pDb
->db
, zSrcDb
);
1983 Tcl_AppendResult(interp
, "backup failed: ",
1984 sqlite3_errmsg(pDest
), (char*)0);
1985 sqlite3_close(pDest
);
1988 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
){}
1989 sqlite3_backup_finish(pBackup
);
1990 if( rc
==SQLITE_DONE
){
1993 Tcl_AppendResult(interp
, "backup failed: ",
1994 sqlite3_errmsg(pDest
), (char*)0);
1997 sqlite3_close(pDest
);
2001 /* $db busy ?CALLBACK?
2003 ** Invoke the given callback if an SQL statement attempts to open
2004 ** a locked database file.
2008 Tcl_WrongNumArgs(interp
, 2, objv
, "CALLBACK");
2010 }else if( objc
==2 ){
2012 Tcl_AppendResult(interp
, pDb
->zBusy
, (char*)0);
2018 Tcl_Free(pDb
->zBusy
);
2020 zBusy
= Tcl_GetStringFromObj(objv
[2], &len
);
2021 if( zBusy
&& len
>0 ){
2022 pDb
->zBusy
= Tcl_Alloc( len
+ 1 );
2023 memcpy(pDb
->zBusy
, zBusy
, len
+1);
2028 pDb
->interp
= interp
;
2029 sqlite3_busy_handler(pDb
->db
, DbBusyHandler
, pDb
);
2031 sqlite3_busy_handler(pDb
->db
, 0, 0);
2040 ** Flush the prepared statement cache, or set the maximum number of
2041 ** cached statements.
2048 Tcl_WrongNumArgs(interp
, 1, objv
, "cache option ?arg?");
2051 subCmd
= Tcl_GetStringFromObj( objv
[2], 0 );
2052 if( *subCmd
=='f' && strcmp(subCmd
,"flush")==0 ){
2054 Tcl_WrongNumArgs(interp
, 2, objv
, "flush");
2057 flushStmtCache( pDb
);
2059 }else if( *subCmd
=='s' && strcmp(subCmd
,"size")==0 ){
2061 Tcl_WrongNumArgs(interp
, 2, objv
, "size n");
2064 if( TCL_ERROR
==Tcl_GetIntFromObj(interp
, objv
[3], &n
) ){
2065 Tcl_AppendResult( interp
, "cannot convert \"",
2066 Tcl_GetStringFromObj(objv
[3],0), "\" to integer", (char*)0);
2070 flushStmtCache( pDb
);
2072 }else if( n
>MAX_PREPARED_STMTS
){
2073 n
= MAX_PREPARED_STMTS
;
2079 Tcl_AppendResult( interp
, "bad option \"",
2080 Tcl_GetStringFromObj(objv
[2],0), "\": must be flush or size",
2089 ** Return the number of rows that were modified, inserted, or deleted by
2090 ** the most recent INSERT, UPDATE or DELETE statement, not including
2091 ** any changes made by trigger programs.
2096 Tcl_WrongNumArgs(interp
, 2, objv
, "");
2099 pResult
= Tcl_GetObjResult(interp
);
2100 Tcl_SetIntObj(pResult
, sqlite3_changes(pDb
->db
));
2106 ** Shutdown the database
2109 Tcl_DeleteCommand(interp
, Tcl_GetStringFromObj(objv
[0], 0));
2114 ** $db collate NAME SCRIPT
2116 ** Create a new SQL collation function called NAME. Whenever
2117 ** that function is called, invoke SCRIPT to evaluate the function.
2120 SqlCollate
*pCollate
;
2125 Tcl_WrongNumArgs(interp
, 2, objv
, "NAME SCRIPT");
2128 zName
= Tcl_GetStringFromObj(objv
[2], 0);
2129 zScript
= Tcl_GetStringFromObj(objv
[3], &nScript
);
2130 pCollate
= (SqlCollate
*)Tcl_Alloc( sizeof(*pCollate
) + nScript
+ 1 );
2131 if( pCollate
==0 ) return TCL_ERROR
;
2132 pCollate
->interp
= interp
;
2133 pCollate
->pNext
= pDb
->pCollate
;
2134 pCollate
->zScript
= (char*)&pCollate
[1];
2135 pDb
->pCollate
= pCollate
;
2136 memcpy(pCollate
->zScript
, zScript
, nScript
+1);
2137 if( sqlite3_create_collation(pDb
->db
, zName
, SQLITE_UTF8
,
2138 pCollate
, tclSqlCollate
) ){
2139 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
2146 ** $db collation_needed SCRIPT
2148 ** Create a new SQL collation function called NAME. Whenever
2149 ** that function is called, invoke SCRIPT to evaluate the function.
2151 case DB_COLLATION_NEEDED
: {
2153 Tcl_WrongNumArgs(interp
, 2, objv
, "SCRIPT");
2156 if( pDb
->pCollateNeeded
){
2157 Tcl_DecrRefCount(pDb
->pCollateNeeded
);
2159 pDb
->pCollateNeeded
= Tcl_DuplicateObj(objv
[2]);
2160 Tcl_IncrRefCount(pDb
->pCollateNeeded
);
2161 sqlite3_collation_needed(pDb
->db
, pDb
, tclCollateNeeded
);
2165 /* $db commit_hook ?CALLBACK?
2167 ** Invoke the given callback just before committing every SQL transaction.
2168 ** If the callback throws an exception or returns non-zero, then the
2169 ** transaction is aborted. If CALLBACK is an empty string, the callback
2172 case DB_COMMIT_HOOK
: {
2174 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
2176 }else if( objc
==2 ){
2178 Tcl_AppendResult(interp
, pDb
->zCommit
, (char*)0);
2181 const char *zCommit
;
2184 Tcl_Free(pDb
->zCommit
);
2186 zCommit
= Tcl_GetStringFromObj(objv
[2], &len
);
2187 if( zCommit
&& len
>0 ){
2188 pDb
->zCommit
= Tcl_Alloc( len
+ 1 );
2189 memcpy(pDb
->zCommit
, zCommit
, len
+1);
2194 pDb
->interp
= interp
;
2195 sqlite3_commit_hook(pDb
->db
, DbCommitHandler
, pDb
);
2197 sqlite3_commit_hook(pDb
->db
, 0, 0);
2205 ** Return TRUE if SQL is a complete SQL statement. Return FALSE if
2206 ** additional lines of input are needed. This is similar to the
2207 ** built-in "info complete" command of Tcl.
2210 #ifndef SQLITE_OMIT_COMPLETE
2214 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL");
2217 isComplete
= sqlite3_complete( Tcl_GetStringFromObj(objv
[2], 0) );
2218 pResult
= Tcl_GetObjResult(interp
);
2219 Tcl_SetBooleanObj(pResult
, isComplete
);
2224 /* $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
2226 ** Copy data into table from filename, optionally using SEPARATOR
2227 ** as column separators. If a column contains a null string, or the
2228 ** value of NULLINDICATOR, a NULL is inserted for the column.
2229 ** conflict-algorithm is one of the sqlite conflict algorithms:
2230 ** rollback, abort, fail, ignore, replace
2231 ** On success, return the number of lines processed, not necessarily same
2232 ** as 'db changes' due to conflict-algorithm selected.
2234 ** This code is basically an implementation/enhancement of
2235 ** the sqlite3 shell.c ".import" command.
2237 ** This command usage is equivalent to the sqlite2.x COPY statement,
2238 ** which imports file data into a table using the PostgreSQL COPY file format:
2239 ** $db copy $conflit_algo $table_name $filename \t \\N
2242 char *zTable
; /* Insert data into this table */
2243 char *zFile
; /* The file from which to extract data */
2244 char *zConflict
; /* The conflict algorithm to use */
2245 sqlite3_stmt
*pStmt
; /* A statement */
2246 int nCol
; /* Number of columns in the table */
2247 int nByte
; /* Number of bytes in an SQL string */
2248 int i
, j
; /* Loop counters */
2249 int nSep
; /* Number of bytes in zSep[] */
2250 int nNull
; /* Number of bytes in zNull[] */
2251 char *zSql
; /* An SQL statement */
2252 char *zLine
; /* A single line of input from the file */
2253 char **azCol
; /* zLine[] broken up into columns */
2254 const char *zCommit
; /* How to commit changes */
2255 FILE *in
; /* The input file */
2256 int lineno
= 0; /* Line number of input file */
2257 char zLineNum
[80]; /* Line number print buffer */
2258 Tcl_Obj
*pResult
; /* interp result */
2262 if( objc
<5 || objc
>7 ){
2263 Tcl_WrongNumArgs(interp
, 2, objv
,
2264 "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");
2268 zSep
= Tcl_GetStringFromObj(objv
[5], 0);
2273 zNull
= Tcl_GetStringFromObj(objv
[6], 0);
2277 zConflict
= Tcl_GetStringFromObj(objv
[2], 0);
2278 zTable
= Tcl_GetStringFromObj(objv
[3], 0);
2279 zFile
= Tcl_GetStringFromObj(objv
[4], 0);
2280 nSep
= strlen30(zSep
);
2281 nNull
= strlen30(zNull
);
2283 Tcl_AppendResult(interp
,"Error: non-null separator required for copy",
2287 if(strcmp(zConflict
, "rollback") != 0 &&
2288 strcmp(zConflict
, "abort" ) != 0 &&
2289 strcmp(zConflict
, "fail" ) != 0 &&
2290 strcmp(zConflict
, "ignore" ) != 0 &&
2291 strcmp(zConflict
, "replace" ) != 0 ) {
2292 Tcl_AppendResult(interp
, "Error: \"", zConflict
,
2293 "\", conflict-algorithm must be one of: rollback, "
2294 "abort, fail, ignore, or replace", (char*)0);
2297 zSql
= sqlite3_mprintf("SELECT * FROM '%q'", zTable
);
2299 Tcl_AppendResult(interp
, "Error: no such table: ", zTable
, (char*)0);
2302 nByte
= strlen30(zSql
);
2303 rc
= sqlite3_prepare(pDb
->db
, zSql
, -1, &pStmt
, 0);
2306 Tcl_AppendResult(interp
, "Error: ", sqlite3_errmsg(pDb
->db
), (char*)0);
2309 nCol
= sqlite3_column_count(pStmt
);
2311 sqlite3_finalize(pStmt
);
2315 zSql
= malloc( nByte
+ 50 + nCol
*2 );
2317 Tcl_AppendResult(interp
, "Error: can't malloc()", (char*)0);
2320 sqlite3_snprintf(nByte
+50, zSql
, "INSERT OR %q INTO '%q' VALUES(?",
2323 for(i
=1; i
<nCol
; i
++){
2329 rc
= sqlite3_prepare(pDb
->db
, zSql
, -1, &pStmt
, 0);
2332 Tcl_AppendResult(interp
, "Error: ", sqlite3_errmsg(pDb
->db
), (char*)0);
2333 sqlite3_finalize(pStmt
);
2336 in
= fopen(zFile
, "rb");
2338 Tcl_AppendResult(interp
, "Error: cannot open file: ", zFile
, (char*)0);
2339 sqlite3_finalize(pStmt
);
2342 azCol
= malloc( sizeof(azCol
[0])*(nCol
+1) );
2344 Tcl_AppendResult(interp
, "Error: can't malloc()", (char*)0);
2348 (void)sqlite3_exec(pDb
->db
, "BEGIN", 0, 0, 0);
2350 while( (zLine
= local_getline(0, in
))!=0 ){
2354 for(i
=0, z
=zLine
; *z
; z
++){
2355 if( *z
==zSep
[0] && strncmp(z
, zSep
, nSep
)==0 ){
2359 azCol
[i
] = &z
[nSep
];
2366 int nErr
= strlen30(zFile
) + 200;
2367 zErr
= malloc(nErr
);
2369 sqlite3_snprintf(nErr
, zErr
,
2370 "Error: %s line %d: expected %d columns of data but found %d",
2371 zFile
, lineno
, nCol
, i
+1);
2372 Tcl_AppendResult(interp
, zErr
, (char*)0);
2375 zCommit
= "ROLLBACK";
2378 for(i
=0; i
<nCol
; i
++){
2379 /* check for null data, if so, bind as null */
2380 if( (nNull
>0 && strcmp(azCol
[i
], zNull
)==0)
2381 || strlen30(azCol
[i
])==0
2383 sqlite3_bind_null(pStmt
, i
+1);
2385 sqlite3_bind_text(pStmt
, i
+1, azCol
[i
], -1, SQLITE_STATIC
);
2388 sqlite3_step(pStmt
);
2389 rc
= sqlite3_reset(pStmt
);
2391 if( rc
!=SQLITE_OK
){
2392 Tcl_AppendResult(interp
,"Error: ", sqlite3_errmsg(pDb
->db
), (char*)0);
2393 zCommit
= "ROLLBACK";
2399 sqlite3_finalize(pStmt
);
2400 (void)sqlite3_exec(pDb
->db
, zCommit
, 0, 0, 0);
2402 if( zCommit
[0] == 'C' ){
2403 /* success, set result as number of lines processed */
2404 pResult
= Tcl_GetObjResult(interp
);
2405 Tcl_SetIntObj(pResult
, lineno
);
2408 /* failure, append lineno where failed */
2409 sqlite3_snprintf(sizeof(zLineNum
), zLineNum
,"%d",lineno
);
2410 Tcl_AppendResult(interp
,", failed while processing line: ",zLineNum
,
2418 ** $db enable_load_extension BOOLEAN
2420 ** Turn the extension loading feature on or off. It if off by
2423 case DB_ENABLE_LOAD_EXTENSION
: {
2424 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2427 Tcl_WrongNumArgs(interp
, 2, objv
, "BOOLEAN");
2430 if( Tcl_GetBooleanFromObj(interp
, objv
[2], &onoff
) ){
2433 sqlite3_enable_load_extension(pDb
->db
, onoff
);
2436 Tcl_AppendResult(interp
, "extension loading is turned off at compile-time",
2445 ** Return the numeric error code that was returned by the most recent
2446 ** call to sqlite3_exec().
2448 case DB_ERRORCODE
: {
2449 Tcl_SetObjResult(interp
, Tcl_NewIntObj(sqlite3_errcode(pDb
->db
)));
2455 ** $db onecolumn $sql
2457 ** The onecolumn method is the equivalent of:
2458 ** lindex [$db eval $sql] 0
2461 case DB_ONECOLUMN
: {
2462 Tcl_Obj
*pResult
= 0;
2463 DbEvalContext sEval
;
2465 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL");
2469 dbEvalInit(&sEval
, pDb
, objv
[2], 0, 0);
2470 rc
= dbEvalStep(&sEval
);
2471 if( choice
==DB_ONECOLUMN
){
2473 pResult
= dbEvalColumnValue(&sEval
, 0);
2474 }else if( rc
==TCL_BREAK
){
2475 Tcl_ResetResult(interp
);
2477 }else if( rc
==TCL_BREAK
|| rc
==TCL_OK
){
2478 pResult
= Tcl_NewBooleanObj(rc
==TCL_OK
);
2480 dbEvalFinalize(&sEval
);
2481 if( pResult
) Tcl_SetObjResult(interp
, pResult
);
2483 if( rc
==TCL_BREAK
){
2490 ** $db eval ?options? $sql ?array? ?{ ...code... }?
2492 ** The SQL statement in $sql is evaluated. For each row, the values are
2493 ** placed in elements of the array named "array" and ...code... is executed.
2494 ** If "array" and "code" are omitted, then no callback is every invoked.
2495 ** If "array" is an empty string, then the values are placed in variables
2496 ** that have the same name as the fields extracted by the query.
2501 while( objc
>3 && (zOpt
= Tcl_GetString(objv
[2]))!=0 && zOpt
[0]=='-' ){
2502 if( strcmp(zOpt
, "-withoutnulls")==0 ){
2503 evalFlags
|= SQLITE_EVAL_WITHOUTNULLS
;
2506 Tcl_AppendResult(interp
, "unknown option: \"", zOpt
, "\"", (void*)0);
2512 if( objc
<3 || objc
>5 ){
2513 Tcl_WrongNumArgs(interp
, 2, objv
,
2514 "?OPTIONS? SQL ?ARRAY-NAME? ?SCRIPT?");
2519 DbEvalContext sEval
;
2520 Tcl_Obj
*pRet
= Tcl_NewObj();
2521 Tcl_IncrRefCount(pRet
);
2522 dbEvalInit(&sEval
, pDb
, objv
[2], 0, 0);
2523 while( TCL_OK
==(rc
= dbEvalStep(&sEval
)) ){
2526 dbEvalRowInfo(&sEval
, &nCol
, 0);
2527 for(i
=0; i
<nCol
; i
++){
2528 Tcl_ListObjAppendElement(interp
, pRet
, dbEvalColumnValue(&sEval
, i
));
2531 dbEvalFinalize(&sEval
);
2532 if( rc
==TCL_BREAK
){
2533 Tcl_SetObjResult(interp
, pRet
);
2536 Tcl_DecrRefCount(pRet
);
2540 Tcl_Obj
*pArray
= 0;
2543 if( objc
>=5 && *(char *)Tcl_GetString(objv
[3]) ){
2546 pScript
= objv
[objc
-1];
2547 Tcl_IncrRefCount(pScript
);
2549 p
= (DbEvalContext
*)Tcl_Alloc(sizeof(DbEvalContext
));
2550 dbEvalInit(p
, pDb
, objv
[2], pArray
, evalFlags
);
2553 cd2
[1] = (void *)pScript
;
2554 rc
= DbEvalNextCmd(cd2
, interp
, TCL_OK
);
2560 ** $db function NAME [-argcount N] [-deterministic] SCRIPT
2562 ** Create a new SQL function called NAME. Whenever that function is
2563 ** called, invoke SCRIPT to evaluate the function.
2566 int flags
= SQLITE_UTF8
;
2573 Tcl_WrongNumArgs(interp
, 2, objv
, "NAME ?SWITCHES? SCRIPT");
2576 for(i
=3; i
<(objc
-1); i
++){
2577 const char *z
= Tcl_GetString(objv
[i
]);
2578 int n
= strlen30(z
);
2579 if( n
>2 && strncmp(z
, "-argcount",n
)==0 ){
2581 Tcl_AppendResult(interp
, "option requires an argument: ", z
,(char*)0);
2584 if( Tcl_GetIntFromObj(interp
, objv
[i
+1], &nArg
) ) return TCL_ERROR
;
2586 Tcl_AppendResult(interp
, "number of arguments must be non-negative",
2592 if( n
>2 && strncmp(z
, "-deterministic",n
)==0 ){
2593 flags
|= SQLITE_DETERMINISTIC
;
2595 Tcl_AppendResult(interp
, "bad option \"", z
,
2596 "\": must be -argcount or -deterministic", (char*)0
2602 pScript
= objv
[objc
-1];
2603 zName
= Tcl_GetStringFromObj(objv
[2], 0);
2604 pFunc
= findSqlFunc(pDb
, zName
);
2605 if( pFunc
==0 ) return TCL_ERROR
;
2606 if( pFunc
->pScript
){
2607 Tcl_DecrRefCount(pFunc
->pScript
);
2609 pFunc
->pScript
= pScript
;
2610 Tcl_IncrRefCount(pScript
);
2611 pFunc
->useEvalObjv
= safeToUseEvalObjv(interp
, pScript
);
2612 rc
= sqlite3_create_function(pDb
->db
, zName
, nArg
, flags
,
2613 pFunc
, tclSqlFunc
, 0, 0);
2614 if( rc
!=SQLITE_OK
){
2616 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
2622 ** $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
2625 #ifdef SQLITE_OMIT_INCRBLOB
2626 Tcl_AppendResult(interp
, "incrblob not available in this build", (char*)0);
2630 const char *zDb
= "main";
2632 const char *zColumn
;
2635 /* Check for the -readonly option */
2636 if( objc
>3 && strcmp(Tcl_GetString(objv
[2]), "-readonly")==0 ){
2640 if( objc
!=(5+isReadonly
) && objc
!=(6+isReadonly
) ){
2641 Tcl_WrongNumArgs(interp
, 2, objv
, "?-readonly? ?DB? TABLE COLUMN ROWID");
2645 if( objc
==(6+isReadonly
) ){
2646 zDb
= Tcl_GetString(objv
[2]);
2648 zTable
= Tcl_GetString(objv
[objc
-3]);
2649 zColumn
= Tcl_GetString(objv
[objc
-2]);
2650 rc
= Tcl_GetWideIntFromObj(interp
, objv
[objc
-1], &iRow
);
2653 rc
= createIncrblobChannel(
2654 interp
, pDb
, zDb
, zTable
, zColumn
, (sqlite3_int64
)iRow
, isReadonly
2664 ** Interrupt the execution of the inner-most SQL interpreter. This
2665 ** causes the SQL statement to return an error of SQLITE_INTERRUPT.
2667 case DB_INTERRUPT
: {
2668 sqlite3_interrupt(pDb
->db
);
2673 ** $db nullvalue ?STRING?
2675 ** Change text used when a NULL comes back from the database. If ?STRING?
2676 ** is not present, then the current string used for NULL is returned.
2677 ** If STRING is present, then STRING is returned.
2680 case DB_NULLVALUE
: {
2681 if( objc
!=2 && objc
!=3 ){
2682 Tcl_WrongNumArgs(interp
, 2, objv
, "NULLVALUE");
2687 char *zNull
= Tcl_GetStringFromObj(objv
[2], &len
);
2689 Tcl_Free(pDb
->zNull
);
2691 if( zNull
&& len
>0 ){
2692 pDb
->zNull
= Tcl_Alloc( len
+ 1 );
2693 memcpy(pDb
->zNull
, zNull
, len
);
2694 pDb
->zNull
[len
] = '\0';
2699 Tcl_SetObjResult(interp
, Tcl_NewStringObj(pDb
->zNull
, -1));
2704 ** $db last_insert_rowid
2706 ** Return an integer which is the ROWID for the most recent insert.
2708 case DB_LAST_INSERT_ROWID
: {
2712 Tcl_WrongNumArgs(interp
, 2, objv
, "");
2715 rowid
= sqlite3_last_insert_rowid(pDb
->db
);
2716 pResult
= Tcl_GetObjResult(interp
);
2717 Tcl_SetWideIntObj(pResult
, rowid
);
2722 ** The DB_ONECOLUMN method is implemented together with DB_EXISTS.
2725 /* $db progress ?N CALLBACK?
2727 ** Invoke the given callback every N virtual machine opcodes while executing
2732 if( pDb
->zProgress
){
2733 Tcl_AppendResult(interp
, pDb
->zProgress
, (char*)0);
2735 }else if( objc
==4 ){
2739 if( TCL_OK
!=Tcl_GetIntFromObj(interp
, objv
[2], &N
) ){
2742 if( pDb
->zProgress
){
2743 Tcl_Free(pDb
->zProgress
);
2745 zProgress
= Tcl_GetStringFromObj(objv
[3], &len
);
2746 if( zProgress
&& len
>0 ){
2747 pDb
->zProgress
= Tcl_Alloc( len
+ 1 );
2748 memcpy(pDb
->zProgress
, zProgress
, len
+1);
2752 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
2753 if( pDb
->zProgress
){
2754 pDb
->interp
= interp
;
2755 sqlite3_progress_handler(pDb
->db
, N
, DbProgressHandler
, pDb
);
2757 sqlite3_progress_handler(pDb
->db
, 0, 0, 0);
2761 Tcl_WrongNumArgs(interp
, 2, objv
, "N CALLBACK");
2767 /* $db profile ?CALLBACK?
2769 ** Make arrangements to invoke the CALLBACK routine after each SQL statement
2770 ** that has run. The text of the SQL and the amount of elapse time are
2771 ** appended to CALLBACK before the script is run.
2775 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
2777 }else if( objc
==2 ){
2778 if( pDb
->zProfile
){
2779 Tcl_AppendResult(interp
, pDb
->zProfile
, (char*)0);
2784 if( pDb
->zProfile
){
2785 Tcl_Free(pDb
->zProfile
);
2787 zProfile
= Tcl_GetStringFromObj(objv
[2], &len
);
2788 if( zProfile
&& len
>0 ){
2789 pDb
->zProfile
= Tcl_Alloc( len
+ 1 );
2790 memcpy(pDb
->zProfile
, zProfile
, len
+1);
2794 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
2795 !defined(SQLITE_OMIT_DEPRECATED)
2796 if( pDb
->zProfile
){
2797 pDb
->interp
= interp
;
2798 sqlite3_profile(pDb
->db
, DbProfileHandler
, pDb
);
2800 sqlite3_profile(pDb
->db
, 0, 0);
2810 ** Change the encryption key on the currently open database.
2813 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
2818 Tcl_WrongNumArgs(interp
, 2, objv
, "KEY");
2821 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
2822 pKey
= Tcl_GetByteArrayFromObj(objv
[2], &nKey
);
2823 rc
= sqlite3_rekey(pDb
->db
, pKey
, nKey
);
2825 Tcl_AppendResult(interp
, sqlite3_errstr(rc
), (char*)0);
2832 /* $db restore ?DATABASE? FILENAME
2834 ** Open a database file named FILENAME. Transfer the content
2835 ** of FILENAME into the local database DATABASE (default: "main").
2838 const char *zSrcFile
;
2839 const char *zDestDb
;
2841 sqlite3_backup
*pBackup
;
2846 zSrcFile
= Tcl_GetString(objv
[2]);
2847 }else if( objc
==4 ){
2848 zDestDb
= Tcl_GetString(objv
[2]);
2849 zSrcFile
= Tcl_GetString(objv
[3]);
2851 Tcl_WrongNumArgs(interp
, 2, objv
, "?DATABASE? FILENAME");
2854 rc
= sqlite3_open_v2(zSrcFile
, &pSrc
,
2855 SQLITE_OPEN_READONLY
| pDb
->openFlags
, 0);
2856 if( rc
!=SQLITE_OK
){
2857 Tcl_AppendResult(interp
, "cannot open source database: ",
2858 sqlite3_errmsg(pSrc
), (char*)0);
2859 sqlite3_close(pSrc
);
2862 pBackup
= sqlite3_backup_init(pDb
->db
, zDestDb
, pSrc
, "main");
2864 Tcl_AppendResult(interp
, "restore failed: ",
2865 sqlite3_errmsg(pDb
->db
), (char*)0);
2866 sqlite3_close(pSrc
);
2869 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
2870 || rc
==SQLITE_BUSY
){
2871 if( rc
==SQLITE_BUSY
){
2872 if( nTimeout
++ >= 3 ) break;
2876 sqlite3_backup_finish(pBackup
);
2877 if( rc
==SQLITE_DONE
){
2879 }else if( rc
==SQLITE_BUSY
|| rc
==SQLITE_LOCKED
){
2880 Tcl_AppendResult(interp
, "restore failed: source database busy",
2884 Tcl_AppendResult(interp
, "restore failed: ",
2885 sqlite3_errmsg(pDb
->db
), (char*)0);
2888 sqlite3_close(pSrc
);
2893 ** $db status (step|sort|autoindex|vmstep)
2895 ** Display SQLITE_STMTSTATUS_FULLSCAN_STEP or
2896 ** SQLITE_STMTSTATUS_SORT for the most recent eval.
2902 Tcl_WrongNumArgs(interp
, 2, objv
, "(step|sort|autoindex)");
2905 zOp
= Tcl_GetString(objv
[2]);
2906 if( strcmp(zOp
, "step")==0 ){
2908 }else if( strcmp(zOp
, "sort")==0 ){
2910 }else if( strcmp(zOp
, "autoindex")==0 ){
2912 }else if( strcmp(zOp
, "vmstep")==0 ){
2915 Tcl_AppendResult(interp
,
2916 "bad argument: should be autoindex, step, sort or vmstep",
2920 Tcl_SetObjResult(interp
, Tcl_NewIntObj(v
));
2925 ** $db timeout MILLESECONDS
2927 ** Delay for the number of milliseconds specified when a file is locked.
2932 Tcl_WrongNumArgs(interp
, 2, objv
, "MILLISECONDS");
2935 if( Tcl_GetIntFromObj(interp
, objv
[2], &ms
) ) return TCL_ERROR
;
2936 sqlite3_busy_timeout(pDb
->db
, ms
);
2941 ** $db total_changes
2943 ** Return the number of rows that were modified, inserted, or deleted
2944 ** since the database handle was created.
2946 case DB_TOTAL_CHANGES
: {
2949 Tcl_WrongNumArgs(interp
, 2, objv
, "");
2952 pResult
= Tcl_GetObjResult(interp
);
2953 Tcl_SetIntObj(pResult
, sqlite3_total_changes(pDb
->db
));
2957 /* $db trace ?CALLBACK?
2959 ** Make arrangements to invoke the CALLBACK routine for each SQL statement
2960 ** that is executed. The text of the SQL is appended to CALLBACK before
2965 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
2967 }else if( objc
==2 ){
2969 Tcl_AppendResult(interp
, pDb
->zTrace
, (char*)0);
2975 Tcl_Free(pDb
->zTrace
);
2977 zTrace
= Tcl_GetStringFromObj(objv
[2], &len
);
2978 if( zTrace
&& len
>0 ){
2979 pDb
->zTrace
= Tcl_Alloc( len
+ 1 );
2980 memcpy(pDb
->zTrace
, zTrace
, len
+1);
2984 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
2985 !defined(SQLITE_OMIT_DEPRECATED)
2987 pDb
->interp
= interp
;
2988 sqlite3_trace(pDb
->db
, DbTraceHandler
, pDb
);
2990 sqlite3_trace(pDb
->db
, 0, 0);
2997 /* $db trace_v2 ?CALLBACK? ?MASK?
2999 ** Make arrangements to invoke the CALLBACK routine for each trace event
3000 ** matching the mask that is generated. The parameters are appended to
3001 ** CALLBACK before it is executed.
3005 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK? ?MASK?");
3007 }else if( objc
==2 ){
3008 if( pDb
->zTraceV2
){
3009 Tcl_AppendResult(interp
, pDb
->zTraceV2
, (char*)0);
3014 Tcl_WideInt wMask
= 0;
3016 static const char *TTYPE_strs
[] = {
3017 "statement", "profile", "row", "close", 0
3020 TTYPE_STMT
, TTYPE_PROFILE
, TTYPE_ROW
, TTYPE_CLOSE
3023 if( TCL_OK
!=Tcl_ListObjLength(interp
, objv
[3], &len
) ){
3026 for(i
=0; i
<len
; i
++){
3029 if( TCL_OK
!=Tcl_ListObjIndex(interp
, objv
[3], i
, &pObj
) ){
3032 if( Tcl_GetIndexFromObj(interp
, pObj
, TTYPE_strs
, "trace type",
3033 0, &ttype
)!=TCL_OK
){
3035 Tcl_Obj
*pError
= Tcl_DuplicateObj(Tcl_GetObjResult(interp
));
3036 Tcl_IncrRefCount(pError
);
3037 if( TCL_OK
==Tcl_GetWideIntFromObj(interp
, pObj
, &wType
) ){
3038 Tcl_DecrRefCount(pError
);
3041 Tcl_SetObjResult(interp
, pError
);
3042 Tcl_DecrRefCount(pError
);
3046 switch( (enum TTYPE_enum
)ttype
){
3047 case TTYPE_STMT
: wMask
|= SQLITE_TRACE_STMT
; break;
3048 case TTYPE_PROFILE
: wMask
|= SQLITE_TRACE_PROFILE
; break;
3049 case TTYPE_ROW
: wMask
|= SQLITE_TRACE_ROW
; break;
3050 case TTYPE_CLOSE
: wMask
|= SQLITE_TRACE_CLOSE
; break;
3055 wMask
= SQLITE_TRACE_STMT
; /* use the "legacy" default */
3057 if( pDb
->zTraceV2
){
3058 Tcl_Free(pDb
->zTraceV2
);
3060 zTraceV2
= Tcl_GetStringFromObj(objv
[2], &len
);
3061 if( zTraceV2
&& len
>0 ){
3062 pDb
->zTraceV2
= Tcl_Alloc( len
+ 1 );
3063 memcpy(pDb
->zTraceV2
, zTraceV2
, len
+1);
3067 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
3068 if( pDb
->zTraceV2
){
3069 pDb
->interp
= interp
;
3070 sqlite3_trace_v2(pDb
->db
, (unsigned)wMask
, DbTraceV2Handler
, pDb
);
3072 sqlite3_trace_v2(pDb
->db
, 0, 0, 0);
3079 /* $db transaction [-deferred|-immediate|-exclusive] SCRIPT
3081 ** Start a new transaction (if we are not already in the midst of a
3082 ** transaction) and execute the TCL script SCRIPT. After SCRIPT
3083 ** completes, either commit the transaction or roll it back if SCRIPT
3084 ** throws an exception. Or if no new transation was started, do nothing.
3085 ** pass the exception on up the stack.
3087 ** This command was inspired by Dave Thomas's talk on Ruby at the
3088 ** 2005 O'Reilly Open Source Convention (OSCON).
3090 case DB_TRANSACTION
: {
3092 const char *zBegin
= "SAVEPOINT _tcl_transaction";
3093 if( objc
!=3 && objc
!=4 ){
3094 Tcl_WrongNumArgs(interp
, 2, objv
, "[TYPE] SCRIPT");
3098 if( pDb
->nTransaction
==0 && objc
==4 ){
3099 static const char *TTYPE_strs
[] = {
3100 "deferred", "exclusive", "immediate", 0
3103 TTYPE_DEFERRED
, TTYPE_EXCLUSIVE
, TTYPE_IMMEDIATE
3106 if( Tcl_GetIndexFromObj(interp
, objv
[2], TTYPE_strs
, "transaction type",
3110 switch( (enum TTYPE_enum
)ttype
){
3111 case TTYPE_DEFERRED
: /* no-op */; break;
3112 case TTYPE_EXCLUSIVE
: zBegin
= "BEGIN EXCLUSIVE"; break;
3113 case TTYPE_IMMEDIATE
: zBegin
= "BEGIN IMMEDIATE"; break;
3116 pScript
= objv
[objc
-1];
3118 /* Run the SQLite BEGIN command to open a transaction or savepoint. */
3120 rc
= sqlite3_exec(pDb
->db
, zBegin
, 0, 0, 0);
3122 if( rc
!=SQLITE_OK
){
3123 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
3126 pDb
->nTransaction
++;
3128 /* If using NRE, schedule a callback to invoke the script pScript, then
3129 ** a second callback to commit (or rollback) the transaction or savepoint
3130 ** opened above. If not using NRE, evaluate the script directly, then
3131 ** call function DbTransPostCmd() to commit (or rollback) the transaction
3134 Tcl_NRAddCallback(interp
, DbTransPostCmd
, cd
, 0, 0, 0);
3135 (void)Tcl_NREvalObj(interp
, pScript
, 0);
3137 rc
= DbTransPostCmd(&cd
, interp
, Tcl_EvalObjEx(interp
, pScript
, 0));
3143 ** $db unlock_notify ?script?
3145 case DB_UNLOCK_NOTIFY
: {
3146 #ifndef SQLITE_ENABLE_UNLOCK_NOTIFY
3147 Tcl_AppendResult(interp
, "unlock_notify not available in this build",
3151 if( objc
!=2 && objc
!=3 ){
3152 Tcl_WrongNumArgs(interp
, 2, objv
, "?SCRIPT?");
3155 void (*xNotify
)(void **, int) = 0;
3156 void *pNotifyArg
= 0;
3158 if( pDb
->pUnlockNotify
){
3159 Tcl_DecrRefCount(pDb
->pUnlockNotify
);
3160 pDb
->pUnlockNotify
= 0;
3164 xNotify
= DbUnlockNotify
;
3165 pNotifyArg
= (void *)pDb
;
3166 pDb
->pUnlockNotify
= objv
[2];
3167 Tcl_IncrRefCount(pDb
->pUnlockNotify
);
3170 if( sqlite3_unlock_notify(pDb
->db
, xNotify
, pNotifyArg
) ){
3171 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
3180 ** $db preupdate_hook count
3181 ** $db preupdate_hook hook ?SCRIPT?
3182 ** $db preupdate_hook new INDEX
3183 ** $db preupdate_hook old INDEX
3185 case DB_PREUPDATE
: {
3186 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
3187 Tcl_AppendResult(interp
, "preupdate_hook was omitted at compile-time",
3191 static const char *azSub
[] = {"count", "depth", "hook", "new", "old", 0};
3192 enum DbPreupdateSubCmd
{
3193 PRE_COUNT
, PRE_DEPTH
, PRE_HOOK
, PRE_NEW
, PRE_OLD
3198 Tcl_WrongNumArgs(interp
, 2, objv
, "SUB-COMMAND ?ARGS?");
3200 if( Tcl_GetIndexFromObj(interp
, objv
[2], azSub
, "sub-command", 0, &iSub
) ){
3204 switch( (enum DbPreupdateSubCmd
)iSub
){
3206 int nCol
= sqlite3_preupdate_count(pDb
->db
);
3207 Tcl_SetObjResult(interp
, Tcl_NewIntObj(nCol
));
3213 Tcl_WrongNumArgs(interp
, 2, objv
, "hook ?SCRIPT?");
3216 DbHookCmd(interp
, pDb
, (objc
==4 ? objv
[3] : 0), &pDb
->pPreUpdateHook
);
3223 Tcl_WrongNumArgs(interp
, 3, objv
, "");
3226 pRet
= Tcl_NewIntObj(sqlite3_preupdate_depth(pDb
->db
));
3227 Tcl_SetObjResult(interp
, pRet
);
3234 sqlite3_value
*pValue
;
3236 Tcl_WrongNumArgs(interp
, 3, objv
, "INDEX");
3239 if( Tcl_GetIntFromObj(interp
, objv
[3], &iIdx
) ){
3243 if( iSub
==PRE_OLD
){
3244 rc
= sqlite3_preupdate_old(pDb
->db
, iIdx
, &pValue
);
3246 assert( iSub
==PRE_NEW
);
3247 rc
= sqlite3_preupdate_new(pDb
->db
, iIdx
, &pValue
);
3250 if( rc
==SQLITE_OK
){
3252 pObj
= Tcl_NewStringObj((char*)sqlite3_value_text(pValue
), -1);
3253 Tcl_SetObjResult(interp
, pObj
);
3255 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
3260 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
3265 ** $db wal_hook ?script?
3266 ** $db update_hook ?script?
3267 ** $db rollback_hook ?script?
3270 case DB_UPDATE_HOOK
:
3271 case DB_ROLLBACK_HOOK
: {
3272 /* set ppHook to point at pUpdateHook or pRollbackHook, depending on
3273 ** whether [$db update_hook] or [$db rollback_hook] was invoked.
3275 Tcl_Obj
**ppHook
= 0;
3276 if( choice
==DB_WAL_HOOK
) ppHook
= &pDb
->pWalHook
;
3277 if( choice
==DB_UPDATE_HOOK
) ppHook
= &pDb
->pUpdateHook
;
3278 if( choice
==DB_ROLLBACK_HOOK
) ppHook
= &pDb
->pRollbackHook
;
3280 Tcl_WrongNumArgs(interp
, 2, objv
, "?SCRIPT?");
3284 DbHookCmd(interp
, pDb
, (objc
==3 ? objv
[2] : 0), ppHook
);
3290 ** Return the version string for this database.
3294 for(i
=2; i
<objc
; i
++){
3295 const char *zArg
= Tcl_GetString(objv
[i
]);
3296 /* Optional arguments to $db version are used for testing purpose */
3298 /* $db version -use-legacy-prepare BOOLEAN
3300 ** Turn the use of legacy sqlite3_prepare() on or off.
3302 if( strcmp(zArg
, "-use-legacy-prepare")==0 && i
+1<objc
){
3304 if( Tcl_GetBooleanFromObj(interp
, objv
[i
], &pDb
->bLegacyPrepare
) ){
3309 /* $db version -last-stmt-ptr
3311 ** Return a string which is a hex encoding of the pointer to the
3312 ** most recent sqlite3_stmt in the statement cache.
3314 if( strcmp(zArg
, "-last-stmt-ptr")==0 ){
3316 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%p",
3317 pDb
->stmtList
? pDb
->stmtList
->pStmt
: 0);
3318 Tcl_SetResult(interp
, zBuf
, TCL_VOLATILE
);
3320 #endif /* SQLITE_TEST */
3322 Tcl_AppendResult(interp
, "unknown argument: ", zArg
, (char*)0);
3327 Tcl_SetResult(interp
, (char *)sqlite3_libversion(), TCL_STATIC
);
3333 } /* End of the SWITCH statement */
3339 ** Adaptor that provides an objCmd interface to the NRE-enabled
3340 ** interface implementation.
3342 static int SQLITE_TCLAPI
DbObjCmdAdaptor(
3348 return Tcl_NRCallObjProc(interp
, DbObjCmd
, cd
, objc
, objv
);
3350 #endif /* SQLITE_TCL_NRE */
3353 ** sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?
3354 ** ?-create BOOLEAN? ?-nomutex BOOLEAN?
3356 ** This is the main Tcl command. When the "sqlite" Tcl command is
3357 ** invoked, this routine runs to process that command.
3359 ** The first argument, DBNAME, is an arbitrary name for a new
3360 ** database connection. This command creates a new command named
3361 ** DBNAME that is used to control that connection. The database
3362 ** connection is deleted when the DBNAME command is deleted.
3364 ** The second argument is the name of the database file.
3367 static int SQLITE_TCLAPI
DbMain(
3378 const char *zVfs
= 0;
3380 Tcl_DString translatedFilename
;
3381 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3387 /* In normal use, each TCL interpreter runs in a single thread. So
3388 ** by default, we can turn of mutexing on SQLite database connections.
3389 ** However, for testing purposes it is useful to have mutexes turned
3390 ** on. So, by default, mutexes default off. But if compiled with
3391 ** SQLITE_TCL_DEFAULT_FULLMUTEX then mutexes default on.
3393 #ifdef SQLITE_TCL_DEFAULT_FULLMUTEX
3394 flags
= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
| SQLITE_OPEN_FULLMUTEX
;
3396 flags
= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
| SQLITE_OPEN_NOMUTEX
;
3400 zArg
= Tcl_GetStringFromObj(objv
[1], 0);
3401 if( strcmp(zArg
,"-version")==0 ){
3402 Tcl_AppendResult(interp
,sqlite3_libversion(), (char*)0);
3405 if( strcmp(zArg
,"-sourceid")==0 ){
3406 Tcl_AppendResult(interp
,sqlite3_sourceid(), (char*)0);
3409 if( strcmp(zArg
,"-has-codec")==0 ){
3410 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3411 Tcl_AppendResult(interp
,"1",(char*)0);
3413 Tcl_AppendResult(interp
,"0",(char*)0);
3418 for(i
=3; i
+1<objc
; i
+=2){
3419 zArg
= Tcl_GetString(objv
[i
]);
3420 if( strcmp(zArg
,"-key")==0 ){
3421 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3422 pKey
= Tcl_GetByteArrayFromObj(objv
[i
+1], &nKey
);
3424 }else if( strcmp(zArg
, "-vfs")==0 ){
3425 zVfs
= Tcl_GetString(objv
[i
+1]);
3426 }else if( strcmp(zArg
, "-readonly")==0 ){
3428 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3430 flags
&= ~(SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
);
3431 flags
|= SQLITE_OPEN_READONLY
;
3433 flags
&= ~SQLITE_OPEN_READONLY
;
3434 flags
|= SQLITE_OPEN_READWRITE
;
3436 }else if( strcmp(zArg
, "-create")==0 ){
3438 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3439 if( b
&& (flags
& SQLITE_OPEN_READONLY
)==0 ){
3440 flags
|= SQLITE_OPEN_CREATE
;
3442 flags
&= ~SQLITE_OPEN_CREATE
;
3444 }else if( strcmp(zArg
, "-nomutex")==0 ){
3446 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3448 flags
|= SQLITE_OPEN_NOMUTEX
;
3449 flags
&= ~SQLITE_OPEN_FULLMUTEX
;
3451 flags
&= ~SQLITE_OPEN_NOMUTEX
;
3453 }else if( strcmp(zArg
, "-fullmutex")==0 ){
3455 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3457 flags
|= SQLITE_OPEN_FULLMUTEX
;
3458 flags
&= ~SQLITE_OPEN_NOMUTEX
;
3460 flags
&= ~SQLITE_OPEN_FULLMUTEX
;
3462 }else if( strcmp(zArg
, "-uri")==0 ){
3464 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3466 flags
|= SQLITE_OPEN_URI
;
3468 flags
&= ~SQLITE_OPEN_URI
;
3471 Tcl_AppendResult(interp
, "unknown option: ", zArg
, (char*)0);
3475 if( objc
<3 || (objc
&1)!=1 ){
3476 Tcl_WrongNumArgs(interp
, 1, objv
,
3477 "HANDLE FILENAME ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"
3478 " ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN? ?-uri BOOLEAN?"
3479 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3486 p
= (SqliteDb
*)Tcl_Alloc( sizeof(*p
) );
3487 memset(p
, 0, sizeof(*p
));
3488 zFile
= Tcl_GetStringFromObj(objv
[2], 0);
3489 zFile
= Tcl_TranslateFileName(interp
, zFile
, &translatedFilename
);
3490 rc
= sqlite3_open_v2(zFile
, &p
->db
, flags
, zVfs
);
3491 Tcl_DStringFree(&translatedFilename
);
3493 if( SQLITE_OK
!=sqlite3_errcode(p
->db
) ){
3494 zErrMsg
= sqlite3_mprintf("%s", sqlite3_errmsg(p
->db
));
3495 sqlite3_close(p
->db
);
3499 zErrMsg
= sqlite3_mprintf("%s", sqlite3_errstr(rc
));
3501 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3503 sqlite3_key(p
->db
, pKey
, nKey
);
3507 Tcl_SetResult(interp
, zErrMsg
, TCL_VOLATILE
);
3509 sqlite3_free(zErrMsg
);
3512 p
->maxStmt
= NUM_PREPARED_STMTS
;
3513 p
->openFlags
= flags
& SQLITE_OPEN_URI
;
3515 zArg
= Tcl_GetStringFromObj(objv
[1], 0);
3517 Tcl_NRCreateCommand(interp
, zArg
, DbObjCmdAdaptor
, DbObjCmd
,
3518 (char*)p
, DbDeleteCmd
);
3520 Tcl_CreateObjCommand(interp
, zArg
, DbObjCmd
, (char*)p
, DbDeleteCmd
);
3526 ** Provide a dummy Tcl_InitStubs if we are using this as a static
3529 #ifndef USE_TCL_STUBS
3530 # undef Tcl_InitStubs
3531 # define Tcl_InitStubs(a,b,c) TCL_VERSION
3535 ** Make sure we have a PACKAGE_VERSION macro defined. This will be
3536 ** defined automatically by the TEA makefile. But other makefiles
3537 ** do not define it.
3539 #ifndef PACKAGE_VERSION
3540 # define PACKAGE_VERSION SQLITE_VERSION
3544 ** Initialize this module.
3546 ** This Tcl module contains only a single new Tcl command named "sqlite".
3547 ** (Hence there is no namespace. There is no point in using a namespace
3548 ** if the extension only supplies one new name!) The "sqlite" command is
3549 ** used to open a new SQLite database. See the DbMain() routine above
3550 ** for additional information.
3552 ** The EXTERN macros are required by TCL in order to work on windows.
3554 EXTERN
int Sqlite3_Init(Tcl_Interp
*interp
){
3555 int rc
= Tcl_InitStubs(interp
, "8.4", 0) ? TCL_OK
: TCL_ERROR
;
3557 Tcl_CreateObjCommand(interp
, "sqlite3", (Tcl_ObjCmdProc
*)DbMain
, 0, 0);
3558 #ifndef SQLITE_3_SUFFIX_ONLY
3559 /* The "sqlite" alias is undocumented. It is here only to support
3560 ** legacy scripts. All new scripts should use only the "sqlite3"
3562 Tcl_CreateObjCommand(interp
, "sqlite", (Tcl_ObjCmdProc
*)DbMain
, 0, 0);
3564 rc
= Tcl_PkgProvide(interp
, "sqlite3", PACKAGE_VERSION
);
3568 EXTERN
int Tclsqlite3_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
3569 EXTERN
int Sqlite3_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3570 EXTERN
int Tclsqlite3_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3572 /* Because it accesses the file-system and uses persistent state, SQLite
3573 ** is not considered appropriate for safe interpreters. Hence, we cause
3574 ** the _SafeInit() interfaces return TCL_ERROR.
3576 EXTERN
int Sqlite3_SafeInit(Tcl_Interp
*interp
){ return TCL_ERROR
; }
3577 EXTERN
int Sqlite3_SafeUnload(Tcl_Interp
*interp
, int flags
){return TCL_ERROR
;}
3581 #ifndef SQLITE_3_SUFFIX_ONLY
3582 int Sqlite_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
3583 int Tclsqlite_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
3584 int Sqlite_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3585 int Tclsqlite_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3589 ** If the TCLSH macro is defined, add code to make a stand-alone program.
3593 /* This is the main routine for an ordinary TCL shell. If there are
3594 ** are arguments, run the first argument as a script. Otherwise,
3595 ** read TCL commands from standard input
3597 static const char *tclsh_main_loop(void){
3598 static const char zMainloop
[] =
3599 "if {[llength $argv]>=1} {\n"
3600 "set argv0 [lindex $argv 0]\n"
3601 "set argv [lrange $argv 1 end]\n"
3605 "while {![eof stdin]} {\n"
3606 "if {$line!=\"\"} {\n"
3607 "puts -nonewline \"> \"\n"
3609 "puts -nonewline \"% \"\n"
3612 "append line [gets stdin]\n"
3613 "if {[info complete $line]} {\n"
3614 "if {[catch {uplevel #0 $line} result]} {\n"
3615 "puts stderr \"Error: $result\"\n"
3616 "} elseif {$result!=\"\"} {\n"
3629 #define TCLSH_MAIN main /* Needed to fake out mktclapp */
3630 int SQLITE_CDECL
TCLSH_MAIN(int argc
, char **argv
){
3633 const char *zScript
= 0;
3635 #if defined(TCLSH_INIT_PROC)
3636 extern const char *TCLSH_INIT_PROC(Tcl_Interp
*);
3639 #if !defined(_WIN32_WCE)
3640 if( getenv("BREAK") ){
3642 "attach debugger to process %d and press any key to continue.\n",
3648 /* Call sqlite3_shutdown() once before doing anything else. This is to
3649 ** test that sqlite3_shutdown() can be safely called by a process before
3650 ** sqlite3_initialize() is. */
3653 Tcl_FindExecutable(argv
[0]);
3654 Tcl_SetSystemEncoding(NULL
, "utf-8");
3655 interp
= Tcl_CreateInterp();
3656 Sqlite3_Init(interp
);
3658 sqlite3_snprintf(sizeof(zArgc
), zArgc
, "%d", argc
-1);
3659 Tcl_SetVar(interp
,"argc", zArgc
, TCL_GLOBAL_ONLY
);
3660 Tcl_SetVar(interp
,"argv0",argv
[0],TCL_GLOBAL_ONLY
);
3661 Tcl_SetVar(interp
,"argv", "", TCL_GLOBAL_ONLY
);
3662 for(i
=1; i
<argc
; i
++){
3663 Tcl_SetVar(interp
, "argv", argv
[i
],
3664 TCL_GLOBAL_ONLY
| TCL_LIST_ELEMENT
| TCL_APPEND_VALUE
);
3666 #if defined(TCLSH_INIT_PROC)
3667 zScript
= TCLSH_INIT_PROC(interp
);
3670 zScript
= tclsh_main_loop();
3672 if( Tcl_GlobalEval(interp
, zScript
)!=TCL_OK
){
3673 const char *zInfo
= Tcl_GetVar(interp
, "errorInfo", TCL_GLOBAL_ONLY
);
3674 if( zInfo
==0 ) zInfo
= Tcl_GetStringResult(interp
);
3675 fprintf(stderr
,"%s: %s\n", *argv
, zInfo
);