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=1 Add a "main()" routine that works as a tclsh.
19 ** -DSQLITE_TCLMD5 When used in conjuction with -DTCLSH=1, add
20 ** four new commands to the TCL interpreter for
21 ** generating MD5 checksums: md5, md5file,
22 ** md5-10x8, and md5file-10x8.
24 ** -DSQLITE_TEST When used in conjuction with -DTCLSH=1, add
25 ** hundreds of new commands used for testing
26 ** SQLite. This option implies -DSQLITE_TCLMD5.
30 ** If requested, include the SQLite compiler options file for MSVC.
32 #if defined(INCLUDE_MSVC_H)
36 #if defined(INCLUDE_SQLITE_TCL_H)
37 # include "sqlite_tcl.h"
40 # ifndef SQLITE_TCLAPI
41 # define SQLITE_TCLAPI
47 ** Some additional include files are needed if this file is not
48 ** appended to the amalgamation.
50 #ifndef SQLITE_AMALGAMATION
55 typedef unsigned char u8
;
59 /* Used to get the current process ID */
62 # define GETPID getpid
63 #elif !defined(_WIN32_WCE)
64 # ifndef SQLITE_AMALGAMATION
65 # define WIN32_LEAN_AND_MEAN
68 # define GETPID (int)GetCurrentProcessId
72 * Windows needs to know which symbols to export. Unix does not.
73 * BUILD_sqlite should be undefined for Unix.
76 #undef TCL_STORAGE_CLASS
77 #define TCL_STORAGE_CLASS DLLEXPORT
78 #endif /* BUILD_sqlite */
80 #define NUM_PREPARED_STMTS 10
81 #define MAX_PREPARED_STMTS 100
83 /* Forward declaration */
84 typedef struct SqliteDb SqliteDb
;
87 ** New SQL functions can be created as TCL scripts. Each such function
88 ** is described by an instance of the following structure.
90 typedef struct SqlFunc SqlFunc
;
92 Tcl_Interp
*interp
; /* The TCL interpret to execute the function */
93 Tcl_Obj
*pScript
; /* The Tcl_Obj representation of the script */
94 SqliteDb
*pDb
; /* Database connection that owns this function */
95 int useEvalObjv
; /* True if it is safe to use Tcl_EvalObjv */
96 char *zName
; /* Name of this function */
97 SqlFunc
*pNext
; /* Next function on the list of them all */
101 ** New collation sequences function can be created as TCL scripts. Each such
102 ** function is described by an instance of the following structure.
104 typedef struct SqlCollate SqlCollate
;
106 Tcl_Interp
*interp
; /* The TCL interpret to execute the function */
107 char *zScript
; /* The script to be run */
108 SqlCollate
*pNext
; /* Next function on the list of them all */
112 ** Prepared statements are cached for faster execution. Each prepared
113 ** statement is described by an instance of the following structure.
115 typedef struct SqlPreparedStmt SqlPreparedStmt
;
116 struct SqlPreparedStmt
{
117 SqlPreparedStmt
*pNext
; /* Next in linked list */
118 SqlPreparedStmt
*pPrev
; /* Previous on the list */
119 sqlite3_stmt
*pStmt
; /* The prepared statement */
120 int nSql
; /* chars in zSql[] */
121 const char *zSql
; /* Text of the SQL statement */
122 int nParm
; /* Size of apParm array */
123 Tcl_Obj
**apParm
; /* Array of referenced object pointers */
126 typedef struct IncrblobChannel IncrblobChannel
;
129 ** There is one instance of this structure for each SQLite database
130 ** that has been opened by the SQLite TCL interface.
132 ** If this module is built with SQLITE_TEST defined (to create the SQLite
133 ** testfixture executable), then it may be configured to use either
134 ** sqlite3_prepare_v2() or sqlite3_prepare() to prepare SQL statements.
135 ** If SqliteDb.bLegacyPrepare is true, sqlite3_prepare() is used.
138 sqlite3
*db
; /* The "real" database structure. MUST BE FIRST */
139 Tcl_Interp
*interp
; /* The interpreter used for this database */
140 char *zBusy
; /* The busy callback routine */
141 char *zCommit
; /* The commit hook callback routine */
142 char *zTrace
; /* The trace callback routine */
143 char *zTraceV2
; /* The trace_v2 callback routine */
144 char *zProfile
; /* The profile callback routine */
145 char *zProgress
; /* The progress callback routine */
146 char *zAuth
; /* The authorization callback routine */
147 int disableAuth
; /* Disable the authorizer if it exists */
148 char *zNull
; /* Text to substitute for an SQL NULL value */
149 SqlFunc
*pFunc
; /* List of SQL functions */
150 Tcl_Obj
*pUpdateHook
; /* Update hook script (if any) */
151 Tcl_Obj
*pPreUpdateHook
; /* Pre-update hook script (if any) */
152 Tcl_Obj
*pRollbackHook
; /* Rollback hook script (if any) */
153 Tcl_Obj
*pWalHook
; /* WAL hook script (if any) */
154 Tcl_Obj
*pUnlockNotify
; /* Unlock notify script (if any) */
155 SqlCollate
*pCollate
; /* List of SQL collation functions */
156 int rc
; /* Return code of most recent sqlite3_exec() */
157 Tcl_Obj
*pCollateNeeded
; /* Collation needed script */
158 SqlPreparedStmt
*stmtList
; /* List of prepared statements*/
159 SqlPreparedStmt
*stmtLast
; /* Last statement in the list */
160 int maxStmt
; /* The next maximum number of stmtList */
161 int nStmt
; /* Number of statements in stmtList */
162 IncrblobChannel
*pIncrblob
;/* Linked list of open incrblob channels */
163 int nStep
, nSort
, nIndex
; /* Statistics for most recent operation */
164 int nTransaction
; /* Number of nested [transaction] methods */
165 int openFlags
; /* Flags used to open. (SQLITE_OPEN_URI) */
167 int bLegacyPrepare
; /* True to use sqlite3_prepare() */
171 struct IncrblobChannel
{
172 sqlite3_blob
*pBlob
; /* sqlite3 blob handle */
173 SqliteDb
*pDb
; /* Associated database connection */
174 int iSeek
; /* Current seek offset */
175 Tcl_Channel channel
; /* Channel identifier */
176 IncrblobChannel
*pNext
; /* Linked list of all open incrblob channels */
177 IncrblobChannel
*pPrev
; /* Linked list of all open incrblob channels */
181 ** Compute a string length that is limited to what can be stored in
182 ** lower 30 bits of a 32-bit signed integer.
184 static int strlen30(const char *z
){
186 while( *z2
){ z2
++; }
187 return 0x3fffffff & (int)(z2
- z
);
191 #ifndef SQLITE_OMIT_INCRBLOB
193 ** Close all incrblob channels opened using database connection pDb.
194 ** This is called when shutting down the database connection.
196 static void closeIncrblobChannels(SqliteDb
*pDb
){
198 IncrblobChannel
*pNext
;
200 for(p
=pDb
->pIncrblob
; p
; p
=pNext
){
203 /* Note: Calling unregister here call Tcl_Close on the incrblob channel,
204 ** which deletes the IncrblobChannel structure at *p. So do not
205 ** call Tcl_Free() here.
207 Tcl_UnregisterChannel(pDb
->interp
, p
->channel
);
212 ** Close an incremental blob channel.
214 static int SQLITE_TCLAPI
incrblobClose(
215 ClientData instanceData
,
218 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
219 int rc
= sqlite3_blob_close(p
->pBlob
);
220 sqlite3
*db
= p
->pDb
->db
;
222 /* Remove the channel from the SqliteDb.pIncrblob list. */
224 p
->pNext
->pPrev
= p
->pPrev
;
227 p
->pPrev
->pNext
= p
->pNext
;
229 if( p
->pDb
->pIncrblob
==p
){
230 p
->pDb
->pIncrblob
= p
->pNext
;
233 /* Free the IncrblobChannel structure */
237 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(db
), TCL_VOLATILE
);
244 ** Read data from an incremental blob channel.
246 static int SQLITE_TCLAPI
incrblobInput(
247 ClientData instanceData
,
252 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
253 int nRead
= bufSize
; /* Number of bytes to read */
254 int nBlob
; /* Total size of the blob */
255 int rc
; /* sqlite error code */
257 nBlob
= sqlite3_blob_bytes(p
->pBlob
);
258 if( (p
->iSeek
+nRead
)>nBlob
){
259 nRead
= nBlob
-p
->iSeek
;
265 rc
= sqlite3_blob_read(p
->pBlob
, (void *)buf
, nRead
, p
->iSeek
);
276 ** Write data to an incremental blob channel.
278 static int SQLITE_TCLAPI
incrblobOutput(
279 ClientData instanceData
,
284 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
285 int nWrite
= toWrite
; /* Number of bytes to write */
286 int nBlob
; /* Total size of the blob */
287 int rc
; /* sqlite error code */
289 nBlob
= sqlite3_blob_bytes(p
->pBlob
);
290 if( (p
->iSeek
+nWrite
)>nBlob
){
291 *errorCodePtr
= EINVAL
;
298 rc
= sqlite3_blob_write(p
->pBlob
, (void *)buf
, nWrite
, p
->iSeek
);
309 ** Seek an incremental blob channel.
311 static int SQLITE_TCLAPI
incrblobSeek(
312 ClientData instanceData
,
317 IncrblobChannel
*p
= (IncrblobChannel
*)instanceData
;
327 p
->iSeek
= sqlite3_blob_bytes(p
->pBlob
) + offset
;
330 default: assert(!"Bad seekMode");
337 static void SQLITE_TCLAPI
incrblobWatch(
338 ClientData instanceData
,
343 static int SQLITE_TCLAPI
incrblobHandle(
344 ClientData instanceData
,
351 static Tcl_ChannelType IncrblobChannelType
= {
352 "incrblob", /* typeName */
353 TCL_CHANNEL_VERSION_2
, /* version */
354 incrblobClose
, /* closeProc */
355 incrblobInput
, /* inputProc */
356 incrblobOutput
, /* outputProc */
357 incrblobSeek
, /* seekProc */
358 0, /* setOptionProc */
359 0, /* getOptionProc */
360 incrblobWatch
, /* watchProc (this is a no-op) */
361 incrblobHandle
, /* getHandleProc (always returns error) */
363 0, /* blockModeProc */
366 0, /* wideSeekProc */
370 ** Create a new incrblob channel.
372 static int createIncrblobChannel(
382 sqlite3
*db
= pDb
->db
;
385 int flags
= TCL_READABLE
|(isReadonly
? 0 : TCL_WRITABLE
);
387 /* This variable is used to name the channels: "incrblob_[incr count]" */
388 static int count
= 0;
391 rc
= sqlite3_blob_open(db
, zDb
, zTable
, zColumn
, iRow
, !isReadonly
, &pBlob
);
393 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
397 p
= (IncrblobChannel
*)Tcl_Alloc(sizeof(IncrblobChannel
));
401 sqlite3_snprintf(sizeof(zChannel
), zChannel
, "incrblob_%d", ++count
);
402 p
->channel
= Tcl_CreateChannel(&IncrblobChannelType
, zChannel
, p
, flags
);
403 Tcl_RegisterChannel(interp
, p
->channel
);
405 /* Link the new channel into the SqliteDb.pIncrblob list. */
406 p
->pNext
= pDb
->pIncrblob
;
414 Tcl_SetResult(interp
, (char *)Tcl_GetChannelName(p
->channel
), TCL_VOLATILE
);
417 #else /* else clause for "#ifndef SQLITE_OMIT_INCRBLOB" */
418 #define closeIncrblobChannels(pDb)
422 ** Look at the script prefix in pCmd. We will be executing this script
423 ** after first appending one or more arguments. This routine analyzes
424 ** the script to see if it is safe to use Tcl_EvalObjv() on the script
425 ** rather than the more general Tcl_EvalEx(). Tcl_EvalObjv() is much
428 ** Scripts that are safe to use with Tcl_EvalObjv() consists of a
429 ** command name followed by zero or more arguments with no [...] or $
430 ** or {...} or ; to be seen anywhere. Most callback scripts consist
431 ** of just a single procedure name and they meet this requirement.
433 static int safeToUseEvalObjv(Tcl_Interp
*interp
, Tcl_Obj
*pCmd
){
434 /* We could try to do something with Tcl_Parse(). But we will instead
435 ** just do a search for forbidden characters. If any of the forbidden
436 ** characters appear in pCmd, we will report the string as unsafe.
440 z
= Tcl_GetStringFromObj(pCmd
, &n
);
443 if( c
=='$' || c
=='[' || c
==';' ) return 0;
449 ** Find an SqlFunc structure with the given name. Or create a new
450 ** one if an existing one cannot be found. Return a pointer to the
453 static SqlFunc
*findSqlFunc(SqliteDb
*pDb
, const char *zName
){
455 int nName
= strlen30(zName
);
456 pNew
= (SqlFunc
*)Tcl_Alloc( sizeof(*pNew
) + nName
+ 1 );
457 pNew
->zName
= (char*)&pNew
[1];
458 memcpy(pNew
->zName
, zName
, nName
+1);
459 for(p
=pDb
->pFunc
; p
; p
=p
->pNext
){
460 if( sqlite3_stricmp(p
->zName
, pNew
->zName
)==0 ){
461 Tcl_Free((char*)pNew
);
465 pNew
->interp
= pDb
->interp
;
468 pNew
->pNext
= pDb
->pFunc
;
474 ** Free a single SqlPreparedStmt object.
476 static void dbFreeStmt(SqlPreparedStmt
*pStmt
){
478 if( sqlite3_sql(pStmt
->pStmt
)==0 ){
479 Tcl_Free((char *)pStmt
->zSql
);
482 sqlite3_finalize(pStmt
->pStmt
);
483 Tcl_Free((char *)pStmt
);
487 ** Finalize and free a list of prepared statements
489 static void flushStmtCache(SqliteDb
*pDb
){
490 SqlPreparedStmt
*pPreStmt
;
491 SqlPreparedStmt
*pNext
;
493 for(pPreStmt
= pDb
->stmtList
; pPreStmt
; pPreStmt
=pNext
){
494 pNext
= pPreStmt
->pNext
;
495 dbFreeStmt(pPreStmt
);
503 ** TCL calls this procedure when an sqlite3 database command is
506 static void SQLITE_TCLAPI
DbDeleteCmd(void *db
){
507 SqliteDb
*pDb
= (SqliteDb
*)db
;
509 closeIncrblobChannels(pDb
);
510 sqlite3_close(pDb
->db
);
512 SqlFunc
*pFunc
= pDb
->pFunc
;
513 pDb
->pFunc
= pFunc
->pNext
;
514 assert( pFunc
->pDb
==pDb
);
515 Tcl_DecrRefCount(pFunc
->pScript
);
516 Tcl_Free((char*)pFunc
);
518 while( pDb
->pCollate
){
519 SqlCollate
*pCollate
= pDb
->pCollate
;
520 pDb
->pCollate
= pCollate
->pNext
;
521 Tcl_Free((char*)pCollate
);
524 Tcl_Free(pDb
->zBusy
);
527 Tcl_Free(pDb
->zTrace
);
530 Tcl_Free(pDb
->zTraceV2
);
533 Tcl_Free(pDb
->zProfile
);
536 Tcl_Free(pDb
->zAuth
);
539 Tcl_Free(pDb
->zNull
);
541 if( pDb
->pUpdateHook
){
542 Tcl_DecrRefCount(pDb
->pUpdateHook
);
544 if( pDb
->pPreUpdateHook
){
545 Tcl_DecrRefCount(pDb
->pPreUpdateHook
);
547 if( pDb
->pRollbackHook
){
548 Tcl_DecrRefCount(pDb
->pRollbackHook
);
551 Tcl_DecrRefCount(pDb
->pWalHook
);
553 if( pDb
->pCollateNeeded
){
554 Tcl_DecrRefCount(pDb
->pCollateNeeded
);
556 Tcl_Free((char*)pDb
);
560 ** This routine is called when a database file is locked while trying
563 static int DbBusyHandler(void *cd
, int nTries
){
564 SqliteDb
*pDb
= (SqliteDb
*)cd
;
568 sqlite3_snprintf(sizeof(zVal
), zVal
, "%d", nTries
);
569 rc
= Tcl_VarEval(pDb
->interp
, pDb
->zBusy
, " ", zVal
, (char*)0);
570 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
576 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
578 ** This routine is invoked as the 'progress callback' for the database.
580 static int DbProgressHandler(void *cd
){
581 SqliteDb
*pDb
= (SqliteDb
*)cd
;
584 assert( pDb
->zProgress
);
585 rc
= Tcl_Eval(pDb
->interp
, pDb
->zProgress
);
586 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
593 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
594 !defined(SQLITE_OMIT_DEPRECATED)
596 ** This routine is called by the SQLite trace handler whenever a new
597 ** block of SQL is executed. The TCL script in pDb->zTrace is executed.
599 static void DbTraceHandler(void *cd
, const char *zSql
){
600 SqliteDb
*pDb
= (SqliteDb
*)cd
;
603 Tcl_DStringInit(&str
);
604 Tcl_DStringAppend(&str
, pDb
->zTrace
, -1);
605 Tcl_DStringAppendElement(&str
, zSql
);
606 Tcl_Eval(pDb
->interp
, Tcl_DStringValue(&str
));
607 Tcl_DStringFree(&str
);
608 Tcl_ResetResult(pDb
->interp
);
612 #ifndef SQLITE_OMIT_TRACE
614 ** This routine is called by the SQLite trace_v2 handler whenever a new
615 ** supported event is generated. Unsupported event types are ignored.
616 ** The TCL script in pDb->zTraceV2 is executed, with the arguments for
617 ** the event appended to it (as list elements).
619 static int DbTraceV2Handler(
620 unsigned type
, /* One of the SQLITE_TRACE_* event types. */
621 void *cd
, /* The original context data pointer. */
622 void *pd
, /* Primary event data, depends on event type. */
623 void *xd
/* Extra event data, depends on event type. */
625 SqliteDb
*pDb
= (SqliteDb
*)cd
;
629 case SQLITE_TRACE_STMT
: {
630 sqlite3_stmt
*pStmt
= (sqlite3_stmt
*)pd
;
631 char *zSql
= (char *)xd
;
633 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
634 Tcl_IncrRefCount(pCmd
);
635 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
636 Tcl_NewWideIntObj((Tcl_WideInt
)pStmt
));
637 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
638 Tcl_NewStringObj(zSql
, -1));
639 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
640 Tcl_DecrRefCount(pCmd
);
641 Tcl_ResetResult(pDb
->interp
);
644 case SQLITE_TRACE_PROFILE
: {
645 sqlite3_stmt
*pStmt
= (sqlite3_stmt
*)pd
;
646 sqlite3_int64 ns
= (sqlite3_int64
)xd
;
648 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
649 Tcl_IncrRefCount(pCmd
);
650 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
651 Tcl_NewWideIntObj((Tcl_WideInt
)pStmt
));
652 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
653 Tcl_NewWideIntObj((Tcl_WideInt
)ns
));
654 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
655 Tcl_DecrRefCount(pCmd
);
656 Tcl_ResetResult(pDb
->interp
);
659 case SQLITE_TRACE_ROW
: {
660 sqlite3_stmt
*pStmt
= (sqlite3_stmt
*)pd
;
662 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
663 Tcl_IncrRefCount(pCmd
);
664 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
665 Tcl_NewWideIntObj((Tcl_WideInt
)pStmt
));
666 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
667 Tcl_DecrRefCount(pCmd
);
668 Tcl_ResetResult(pDb
->interp
);
671 case SQLITE_TRACE_CLOSE
: {
672 sqlite3
*db
= (sqlite3
*)pd
;
674 pCmd
= Tcl_NewStringObj(pDb
->zTraceV2
, -1);
675 Tcl_IncrRefCount(pCmd
);
676 Tcl_ListObjAppendElement(pDb
->interp
, pCmd
,
677 Tcl_NewWideIntObj((Tcl_WideInt
)db
));
678 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
679 Tcl_DecrRefCount(pCmd
);
680 Tcl_ResetResult(pDb
->interp
);
688 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
689 !defined(SQLITE_OMIT_DEPRECATED)
691 ** This routine is called by the SQLite profile handler after a statement
692 ** SQL has executed. The TCL script in pDb->zProfile is evaluated.
694 static void DbProfileHandler(void *cd
, const char *zSql
, sqlite_uint64 tm
){
695 SqliteDb
*pDb
= (SqliteDb
*)cd
;
699 sqlite3_snprintf(sizeof(zTm
)-1, zTm
, "%lld", tm
);
700 Tcl_DStringInit(&str
);
701 Tcl_DStringAppend(&str
, pDb
->zProfile
, -1);
702 Tcl_DStringAppendElement(&str
, zSql
);
703 Tcl_DStringAppendElement(&str
, zTm
);
704 Tcl_Eval(pDb
->interp
, Tcl_DStringValue(&str
));
705 Tcl_DStringFree(&str
);
706 Tcl_ResetResult(pDb
->interp
);
711 ** This routine is called when a transaction is committed. The
712 ** TCL script in pDb->zCommit is executed. If it returns non-zero or
713 ** if it throws an exception, the transaction is rolled back instead
714 ** of being committed.
716 static int DbCommitHandler(void *cd
){
717 SqliteDb
*pDb
= (SqliteDb
*)cd
;
720 rc
= Tcl_Eval(pDb
->interp
, pDb
->zCommit
);
721 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
727 static void DbRollbackHandler(void *clientData
){
728 SqliteDb
*pDb
= (SqliteDb
*)clientData
;
729 assert(pDb
->pRollbackHook
);
730 if( TCL_OK
!=Tcl_EvalObjEx(pDb
->interp
, pDb
->pRollbackHook
, 0) ){
731 Tcl_BackgroundError(pDb
->interp
);
736 ** This procedure handles wal_hook callbacks.
738 static int DbWalHandler(
746 SqliteDb
*pDb
= (SqliteDb
*)clientData
;
747 Tcl_Interp
*interp
= pDb
->interp
;
748 assert(pDb
->pWalHook
);
750 assert( db
==pDb
->db
);
751 p
= Tcl_DuplicateObj(pDb
->pWalHook
);
753 Tcl_ListObjAppendElement(interp
, p
, Tcl_NewStringObj(zDb
, -1));
754 Tcl_ListObjAppendElement(interp
, p
, Tcl_NewIntObj(nEntry
));
755 if( TCL_OK
!=Tcl_EvalObjEx(interp
, p
, 0)
756 || TCL_OK
!=Tcl_GetIntFromObj(interp
, Tcl_GetObjResult(interp
), &ret
)
758 Tcl_BackgroundError(interp
);
765 #if defined(SQLITE_TEST) && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
766 static void setTestUnlockNotifyVars(Tcl_Interp
*interp
, int iArg
, int nArg
){
768 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%d", iArg
);
769 Tcl_SetVar(interp
, "sqlite_unlock_notify_arg", zBuf
, TCL_GLOBAL_ONLY
);
770 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%d", nArg
);
771 Tcl_SetVar(interp
, "sqlite_unlock_notify_argcount", zBuf
, TCL_GLOBAL_ONLY
);
774 # define setTestUnlockNotifyVars(x,y,z)
777 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
778 static void DbUnlockNotify(void **apArg
, int nArg
){
780 for(i
=0; i
<nArg
; i
++){
781 const int flags
= (TCL_EVAL_GLOBAL
|TCL_EVAL_DIRECT
);
782 SqliteDb
*pDb
= (SqliteDb
*)apArg
[i
];
783 setTestUnlockNotifyVars(pDb
->interp
, i
, nArg
);
784 assert( pDb
->pUnlockNotify
);
785 Tcl_EvalObjEx(pDb
->interp
, pDb
->pUnlockNotify
, flags
);
786 Tcl_DecrRefCount(pDb
->pUnlockNotify
);
787 pDb
->pUnlockNotify
= 0;
792 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
794 ** Pre-update hook callback.
796 static void DbPreUpdateHandler(
805 SqliteDb
*pDb
= (SqliteDb
*)p
;
807 static const char *azStr
[] = {"DELETE", "INSERT", "UPDATE"};
809 assert( (SQLITE_DELETE
-1)/9 == 0 );
810 assert( (SQLITE_INSERT
-1)/9 == 1 );
811 assert( (SQLITE_UPDATE
-1)/9 == 2 );
812 assert( pDb
->pPreUpdateHook
);
813 assert( db
==pDb
->db
);
814 assert( op
==SQLITE_INSERT
|| op
==SQLITE_UPDATE
|| op
==SQLITE_DELETE
);
816 pCmd
= Tcl_DuplicateObj(pDb
->pPreUpdateHook
);
817 Tcl_IncrRefCount(pCmd
);
818 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(azStr
[(op
-1)/9], -1));
819 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zDb
, -1));
820 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zTbl
, -1));
821 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewWideIntObj(iKey1
));
822 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewWideIntObj(iKey2
));
823 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
824 Tcl_DecrRefCount(pCmd
);
826 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
828 static void DbUpdateHandler(
835 SqliteDb
*pDb
= (SqliteDb
*)p
;
837 static const char *azStr
[] = {"DELETE", "INSERT", "UPDATE"};
839 assert( (SQLITE_DELETE
-1)/9 == 0 );
840 assert( (SQLITE_INSERT
-1)/9 == 1 );
841 assert( (SQLITE_UPDATE
-1)/9 == 2 );
843 assert( pDb
->pUpdateHook
);
844 assert( op
==SQLITE_INSERT
|| op
==SQLITE_UPDATE
|| op
==SQLITE_DELETE
);
846 pCmd
= Tcl_DuplicateObj(pDb
->pUpdateHook
);
847 Tcl_IncrRefCount(pCmd
);
848 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(azStr
[(op
-1)/9], -1));
849 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zDb
, -1));
850 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewStringObj(zTbl
, -1));
851 Tcl_ListObjAppendElement(0, pCmd
, Tcl_NewWideIntObj(rowid
));
852 Tcl_EvalObjEx(pDb
->interp
, pCmd
, TCL_EVAL_DIRECT
);
853 Tcl_DecrRefCount(pCmd
);
856 static void tclCollateNeeded(
862 SqliteDb
*pDb
= (SqliteDb
*)pCtx
;
863 Tcl_Obj
*pScript
= Tcl_DuplicateObj(pDb
->pCollateNeeded
);
864 Tcl_IncrRefCount(pScript
);
865 Tcl_ListObjAppendElement(0, pScript
, Tcl_NewStringObj(zName
, -1));
866 Tcl_EvalObjEx(pDb
->interp
, pScript
, 0);
867 Tcl_DecrRefCount(pScript
);
871 ** This routine is called to evaluate an SQL collation function implemented
874 static int tclSqlCollate(
881 SqlCollate
*p
= (SqlCollate
*)pCtx
;
884 pCmd
= Tcl_NewStringObj(p
->zScript
, -1);
885 Tcl_IncrRefCount(pCmd
);
886 Tcl_ListObjAppendElement(p
->interp
, pCmd
, Tcl_NewStringObj(zA
, nA
));
887 Tcl_ListObjAppendElement(p
->interp
, pCmd
, Tcl_NewStringObj(zB
, nB
));
888 Tcl_EvalObjEx(p
->interp
, pCmd
, TCL_EVAL_DIRECT
);
889 Tcl_DecrRefCount(pCmd
);
890 return (atoi(Tcl_GetStringResult(p
->interp
)));
894 ** This routine is called to evaluate an SQL function implemented
897 static void tclSqlFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
898 SqlFunc
*p
= sqlite3_user_data(context
);
904 /* If there are no arguments to the function, call Tcl_EvalObjEx on the
905 ** script object directly. This allows the TCL compiler to generate
906 ** bytecode for the command on the first invocation and thus make
907 ** subsequent invocations much faster. */
909 Tcl_IncrRefCount(pCmd
);
910 rc
= Tcl_EvalObjEx(p
->interp
, pCmd
, 0);
911 Tcl_DecrRefCount(pCmd
);
913 /* If there are arguments to the function, make a shallow copy of the
914 ** script object, lappend the arguments, then evaluate the copy.
916 ** By "shallow" copy, we mean only the outer list Tcl_Obj is duplicated.
917 ** The new Tcl_Obj contains pointers to the original list elements.
918 ** That way, when Tcl_EvalObjv() is run and shimmers the first element
919 ** of the list to tclCmdNameType, that alternate representation will
920 ** be preserved and reused on the next invocation.
924 if( Tcl_ListObjGetElements(p
->interp
, p
->pScript
, &nArg
, &aArg
) ){
925 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
928 pCmd
= Tcl_NewListObj(nArg
, aArg
);
929 Tcl_IncrRefCount(pCmd
);
930 for(i
=0; i
<argc
; i
++){
931 sqlite3_value
*pIn
= argv
[i
];
934 /* Set pVal to contain the i'th column of this row. */
935 switch( sqlite3_value_type(pIn
) ){
937 int bytes
= sqlite3_value_bytes(pIn
);
938 pVal
= Tcl_NewByteArrayObj(sqlite3_value_blob(pIn
), bytes
);
941 case SQLITE_INTEGER
: {
942 sqlite_int64 v
= sqlite3_value_int64(pIn
);
943 if( v
>=-2147483647 && v
<=2147483647 ){
944 pVal
= Tcl_NewIntObj((int)v
);
946 pVal
= Tcl_NewWideIntObj(v
);
951 double r
= sqlite3_value_double(pIn
);
952 pVal
= Tcl_NewDoubleObj(r
);
956 pVal
= Tcl_NewStringObj(p
->pDb
->zNull
, -1);
960 int bytes
= sqlite3_value_bytes(pIn
);
961 pVal
= Tcl_NewStringObj((char *)sqlite3_value_text(pIn
), bytes
);
965 rc
= Tcl_ListObjAppendElement(p
->interp
, pCmd
, pVal
);
967 Tcl_DecrRefCount(pCmd
);
968 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
972 if( !p
->useEvalObjv
){
973 /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd
974 ** is a list without a string representation. To prevent this from
975 ** happening, make sure pCmd has a valid string representation */
978 rc
= Tcl_EvalObjEx(p
->interp
, pCmd
, TCL_EVAL_DIRECT
);
979 Tcl_DecrRefCount(pCmd
);
982 if( rc
&& rc
!=TCL_RETURN
){
983 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
985 Tcl_Obj
*pVar
= Tcl_GetObjResult(p
->interp
);
988 const char *zType
= (pVar
->typePtr
? pVar
->typePtr
->name
: "");
990 if( c
=='b' && strcmp(zType
,"bytearray")==0 && pVar
->bytes
==0 ){
991 /* Only return a BLOB type if the Tcl variable is a bytearray and
992 ** has no string representation. */
993 data
= Tcl_GetByteArrayFromObj(pVar
, &n
);
994 sqlite3_result_blob(context
, data
, n
, SQLITE_TRANSIENT
);
995 }else if( c
=='b' && strcmp(zType
,"boolean")==0 ){
996 Tcl_GetIntFromObj(0, pVar
, &n
);
997 sqlite3_result_int(context
, n
);
998 }else if( c
=='d' && strcmp(zType
,"double")==0 ){
1000 Tcl_GetDoubleFromObj(0, pVar
, &r
);
1001 sqlite3_result_double(context
, r
);
1002 }else if( (c
=='w' && strcmp(zType
,"wideInt")==0) ||
1003 (c
=='i' && strcmp(zType
,"int")==0) ){
1005 Tcl_GetWideIntFromObj(0, pVar
, &v
);
1006 sqlite3_result_int64(context
, v
);
1008 data
= (unsigned char *)Tcl_GetStringFromObj(pVar
, &n
);
1009 sqlite3_result_text(context
, (char *)data
, n
, SQLITE_TRANSIENT
);
1014 #ifndef SQLITE_OMIT_AUTHORIZATION
1016 ** This is the authentication function. It appends the authentication
1017 ** type code and the two arguments to zCmd[] then invokes the result
1018 ** on the interpreter. The reply is examined to determine if the
1019 ** authentication fails or succeeds.
1021 static int auth_callback(
1028 #ifdef SQLITE_USER_AUTHENTICATION
1036 SqliteDb
*pDb
= (SqliteDb
*)pArg
;
1037 if( pDb
->disableAuth
) return SQLITE_OK
;
1040 case SQLITE_COPY
: zCode
="SQLITE_COPY"; break;
1041 case SQLITE_CREATE_INDEX
: zCode
="SQLITE_CREATE_INDEX"; break;
1042 case SQLITE_CREATE_TABLE
: zCode
="SQLITE_CREATE_TABLE"; break;
1043 case SQLITE_CREATE_TEMP_INDEX
: zCode
="SQLITE_CREATE_TEMP_INDEX"; break;
1044 case SQLITE_CREATE_TEMP_TABLE
: zCode
="SQLITE_CREATE_TEMP_TABLE"; break;
1045 case SQLITE_CREATE_TEMP_TRIGGER
: zCode
="SQLITE_CREATE_TEMP_TRIGGER"; break;
1046 case SQLITE_CREATE_TEMP_VIEW
: zCode
="SQLITE_CREATE_TEMP_VIEW"; break;
1047 case SQLITE_CREATE_TRIGGER
: zCode
="SQLITE_CREATE_TRIGGER"; break;
1048 case SQLITE_CREATE_VIEW
: zCode
="SQLITE_CREATE_VIEW"; break;
1049 case SQLITE_DELETE
: zCode
="SQLITE_DELETE"; break;
1050 case SQLITE_DROP_INDEX
: zCode
="SQLITE_DROP_INDEX"; break;
1051 case SQLITE_DROP_TABLE
: zCode
="SQLITE_DROP_TABLE"; break;
1052 case SQLITE_DROP_TEMP_INDEX
: zCode
="SQLITE_DROP_TEMP_INDEX"; break;
1053 case SQLITE_DROP_TEMP_TABLE
: zCode
="SQLITE_DROP_TEMP_TABLE"; break;
1054 case SQLITE_DROP_TEMP_TRIGGER
: zCode
="SQLITE_DROP_TEMP_TRIGGER"; break;
1055 case SQLITE_DROP_TEMP_VIEW
: zCode
="SQLITE_DROP_TEMP_VIEW"; break;
1056 case SQLITE_DROP_TRIGGER
: zCode
="SQLITE_DROP_TRIGGER"; break;
1057 case SQLITE_DROP_VIEW
: zCode
="SQLITE_DROP_VIEW"; break;
1058 case SQLITE_INSERT
: zCode
="SQLITE_INSERT"; break;
1059 case SQLITE_PRAGMA
: zCode
="SQLITE_PRAGMA"; break;
1060 case SQLITE_READ
: zCode
="SQLITE_READ"; break;
1061 case SQLITE_SELECT
: zCode
="SQLITE_SELECT"; break;
1062 case SQLITE_TRANSACTION
: zCode
="SQLITE_TRANSACTION"; break;
1063 case SQLITE_UPDATE
: zCode
="SQLITE_UPDATE"; break;
1064 case SQLITE_ATTACH
: zCode
="SQLITE_ATTACH"; break;
1065 case SQLITE_DETACH
: zCode
="SQLITE_DETACH"; break;
1066 case SQLITE_ALTER_TABLE
: zCode
="SQLITE_ALTER_TABLE"; break;
1067 case SQLITE_REINDEX
: zCode
="SQLITE_REINDEX"; break;
1068 case SQLITE_ANALYZE
: zCode
="SQLITE_ANALYZE"; break;
1069 case SQLITE_CREATE_VTABLE
: zCode
="SQLITE_CREATE_VTABLE"; break;
1070 case SQLITE_DROP_VTABLE
: zCode
="SQLITE_DROP_VTABLE"; break;
1071 case SQLITE_FUNCTION
: zCode
="SQLITE_FUNCTION"; break;
1072 case SQLITE_SAVEPOINT
: zCode
="SQLITE_SAVEPOINT"; break;
1073 case SQLITE_RECURSIVE
: zCode
="SQLITE_RECURSIVE"; break;
1074 default : zCode
="????"; break;
1076 Tcl_DStringInit(&str
);
1077 Tcl_DStringAppend(&str
, pDb
->zAuth
, -1);
1078 Tcl_DStringAppendElement(&str
, zCode
);
1079 Tcl_DStringAppendElement(&str
, zArg1
? zArg1
: "");
1080 Tcl_DStringAppendElement(&str
, zArg2
? zArg2
: "");
1081 Tcl_DStringAppendElement(&str
, zArg3
? zArg3
: "");
1082 Tcl_DStringAppendElement(&str
, zArg4
? zArg4
: "");
1083 #ifdef SQLITE_USER_AUTHENTICATION
1084 Tcl_DStringAppendElement(&str
, zArg5
? zArg5
: "");
1086 rc
= Tcl_GlobalEval(pDb
->interp
, Tcl_DStringValue(&str
));
1087 Tcl_DStringFree(&str
);
1088 zReply
= rc
==TCL_OK
? Tcl_GetStringResult(pDb
->interp
) : "SQLITE_DENY";
1089 if( strcmp(zReply
,"SQLITE_OK")==0 ){
1091 }else if( strcmp(zReply
,"SQLITE_DENY")==0 ){
1093 }else if( strcmp(zReply
,"SQLITE_IGNORE")==0 ){
1100 #endif /* SQLITE_OMIT_AUTHORIZATION */
1103 ** This routine reads a line of text from FILE in, stores
1104 ** the text in memory obtained from malloc() and returns a pointer
1105 ** to the text. NULL is returned at end of file, or if malloc()
1108 ** The interface is like "readline" but no command-line editing
1111 ** copied from shell.c from '.import' command
1113 static char *local_getline(char *zPrompt
, FILE *in
){
1119 zLine
= malloc( nLine
);
1120 if( zLine
==0 ) return 0;
1124 nLine
= nLine
*2 + 100;
1125 zLine
= realloc(zLine
, nLine
);
1126 if( zLine
==0 ) return 0;
1128 if( fgets(&zLine
[n
], nLine
- n
, in
)==0 ){
1136 while( zLine
[n
] ){ n
++; }
1137 if( n
>0 && zLine
[n
-1]=='\n' ){
1143 zLine
= realloc( zLine
, n
+1 );
1149 ** This function is part of the implementation of the command:
1151 ** $db transaction [-deferred|-immediate|-exclusive] SCRIPT
1153 ** It is invoked after evaluating the script SCRIPT to commit or rollback
1154 ** the transaction or savepoint opened by the [transaction] command.
1156 static int SQLITE_TCLAPI
DbTransPostCmd(
1157 ClientData data
[], /* data[0] is the Sqlite3Db* for $db */
1158 Tcl_Interp
*interp
, /* Tcl interpreter */
1159 int result
/* Result of evaluating SCRIPT */
1161 static const char *const azEnd
[] = {
1162 "RELEASE _tcl_transaction", /* rc==TCL_ERROR, nTransaction!=0 */
1163 "COMMIT", /* rc!=TCL_ERROR, nTransaction==0 */
1164 "ROLLBACK TO _tcl_transaction ; RELEASE _tcl_transaction",
1165 "ROLLBACK" /* rc==TCL_ERROR, nTransaction==0 */
1167 SqliteDb
*pDb
= (SqliteDb
*)data
[0];
1171 pDb
->nTransaction
--;
1172 zEnd
= azEnd
[(rc
==TCL_ERROR
)*2 + (pDb
->nTransaction
==0)];
1175 if( sqlite3_exec(pDb
->db
, zEnd
, 0, 0, 0) ){
1176 /* This is a tricky scenario to handle. The most likely cause of an
1177 ** error is that the exec() above was an attempt to commit the
1178 ** top-level transaction that returned SQLITE_BUSY. Or, less likely,
1179 ** that an IO-error has occurred. In either case, throw a Tcl exception
1180 ** and try to rollback the transaction.
1182 ** But it could also be that the user executed one or more BEGIN,
1183 ** COMMIT, SAVEPOINT, RELEASE or ROLLBACK commands that are confusing
1184 ** this method's logic. Not clear how this would be best handled.
1186 if( rc
!=TCL_ERROR
){
1187 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
1190 sqlite3_exec(pDb
->db
, "ROLLBACK", 0, 0, 0);
1198 ** Unless SQLITE_TEST is defined, this function is a simple wrapper around
1199 ** sqlite3_prepare_v2(). If SQLITE_TEST is defined, then it uses either
1200 ** sqlite3_prepare_v2() or legacy interface sqlite3_prepare(), depending
1201 ** on whether or not the [db_use_legacy_prepare] command has been used to
1202 ** configure the connection.
1204 static int dbPrepare(
1205 SqliteDb
*pDb
, /* Database object */
1206 const char *zSql
, /* SQL to compile */
1207 sqlite3_stmt
**ppStmt
, /* OUT: Prepared statement */
1208 const char **pzOut
/* OUT: Pointer to next SQL statement */
1211 if( pDb
->bLegacyPrepare
){
1212 return sqlite3_prepare(pDb
->db
, zSql
, -1, ppStmt
, pzOut
);
1215 return sqlite3_prepare_v2(pDb
->db
, zSql
, -1, ppStmt
, pzOut
);
1219 ** Search the cache for a prepared-statement object that implements the
1220 ** first SQL statement in the buffer pointed to by parameter zIn. If
1221 ** no such prepared-statement can be found, allocate and prepare a new
1222 ** one. In either case, bind the current values of the relevant Tcl
1223 ** variables to any $var, :var or @var variables in the statement. Before
1224 ** returning, set *ppPreStmt to point to the prepared-statement object.
1226 ** Output parameter *pzOut is set to point to the next SQL statement in
1227 ** buffer zIn, or to the '\0' byte at the end of zIn if there is no
1230 ** If successful, TCL_OK is returned. Otherwise, TCL_ERROR is returned
1231 ** and an error message loaded into interpreter pDb->interp.
1233 static int dbPrepareAndBind(
1234 SqliteDb
*pDb
, /* Database object */
1235 char const *zIn
, /* SQL to compile */
1236 char const **pzOut
, /* OUT: Pointer to next SQL statement */
1237 SqlPreparedStmt
**ppPreStmt
/* OUT: Object used to cache statement */
1239 const char *zSql
= zIn
; /* Pointer to first SQL statement in zIn */
1240 sqlite3_stmt
*pStmt
= 0; /* Prepared statement object */
1241 SqlPreparedStmt
*pPreStmt
; /* Pointer to cached statement */
1242 int nSql
; /* Length of zSql in bytes */
1243 int nVar
= 0; /* Number of variables in statement */
1244 int iParm
= 0; /* Next free entry in apParm */
1247 Tcl_Interp
*interp
= pDb
->interp
;
1251 /* Trim spaces from the start of zSql and calculate the remaining length. */
1252 while( (c
= zSql
[0])==' ' || c
=='\t' || c
=='\r' || c
=='\n' ){ zSql
++; }
1253 nSql
= strlen30(zSql
);
1255 for(pPreStmt
= pDb
->stmtList
; pPreStmt
; pPreStmt
=pPreStmt
->pNext
){
1256 int n
= pPreStmt
->nSql
;
1258 && memcmp(pPreStmt
->zSql
, zSql
, n
)==0
1259 && (zSql
[n
]==0 || zSql
[n
-1]==';')
1261 pStmt
= pPreStmt
->pStmt
;
1262 *pzOut
= &zSql
[pPreStmt
->nSql
];
1264 /* When a prepared statement is found, unlink it from the
1265 ** cache list. It will later be added back to the beginning
1266 ** of the cache list in order to implement LRU replacement.
1268 if( pPreStmt
->pPrev
){
1269 pPreStmt
->pPrev
->pNext
= pPreStmt
->pNext
;
1271 pDb
->stmtList
= pPreStmt
->pNext
;
1273 if( pPreStmt
->pNext
){
1274 pPreStmt
->pNext
->pPrev
= pPreStmt
->pPrev
;
1276 pDb
->stmtLast
= pPreStmt
->pPrev
;
1279 nVar
= sqlite3_bind_parameter_count(pStmt
);
1284 /* If no prepared statement was found. Compile the SQL text. Also allocate
1285 ** a new SqlPreparedStmt structure. */
1289 if( SQLITE_OK
!=dbPrepare(pDb
, zSql
, &pStmt
, pzOut
) ){
1290 Tcl_SetObjResult(interp
, Tcl_NewStringObj(sqlite3_errmsg(pDb
->db
), -1));
1294 if( SQLITE_OK
!=sqlite3_errcode(pDb
->db
) ){
1295 /* A compile-time error in the statement. */
1296 Tcl_SetObjResult(interp
, Tcl_NewStringObj(sqlite3_errmsg(pDb
->db
), -1));
1299 /* The statement was a no-op. Continue to the next statement
1300 ** in the SQL string.
1306 assert( pPreStmt
==0 );
1307 nVar
= sqlite3_bind_parameter_count(pStmt
);
1308 nByte
= sizeof(SqlPreparedStmt
) + nVar
*sizeof(Tcl_Obj
*);
1309 pPreStmt
= (SqlPreparedStmt
*)Tcl_Alloc(nByte
);
1310 memset(pPreStmt
, 0, nByte
);
1312 pPreStmt
->pStmt
= pStmt
;
1313 pPreStmt
->nSql
= (int)(*pzOut
- zSql
);
1314 pPreStmt
->zSql
= sqlite3_sql(pStmt
);
1315 pPreStmt
->apParm
= (Tcl_Obj
**)&pPreStmt
[1];
1317 if( pPreStmt
->zSql
==0 ){
1318 char *zCopy
= Tcl_Alloc(pPreStmt
->nSql
+ 1);
1319 memcpy(zCopy
, zSql
, pPreStmt
->nSql
);
1320 zCopy
[pPreStmt
->nSql
] = '\0';
1321 pPreStmt
->zSql
= zCopy
;
1326 assert( strlen30(pPreStmt
->zSql
)==pPreStmt
->nSql
);
1327 assert( 0==memcmp(pPreStmt
->zSql
, zSql
, pPreStmt
->nSql
) );
1329 /* Bind values to parameters that begin with $ or : */
1330 for(i
=1; i
<=nVar
; i
++){
1331 const char *zVar
= sqlite3_bind_parameter_name(pStmt
, i
);
1332 if( zVar
!=0 && (zVar
[0]=='$' || zVar
[0]==':' || zVar
[0]=='@') ){
1333 Tcl_Obj
*pVar
= Tcl_GetVar2Ex(interp
, &zVar
[1], 0, 0);
1337 const char *zType
= (pVar
->typePtr
? pVar
->typePtr
->name
: "");
1340 (c
=='b' && strcmp(zType
,"bytearray")==0 && pVar
->bytes
==0) ){
1341 /* Load a BLOB type if the Tcl variable is a bytearray and
1342 ** it has no string representation or the host
1343 ** parameter name begins with "@". */
1344 data
= Tcl_GetByteArrayFromObj(pVar
, &n
);
1345 sqlite3_bind_blob(pStmt
, i
, data
, n
, SQLITE_STATIC
);
1346 Tcl_IncrRefCount(pVar
);
1347 pPreStmt
->apParm
[iParm
++] = pVar
;
1348 }else if( c
=='b' && strcmp(zType
,"boolean")==0 ){
1349 Tcl_GetIntFromObj(interp
, pVar
, &n
);
1350 sqlite3_bind_int(pStmt
, i
, n
);
1351 }else if( c
=='d' && strcmp(zType
,"double")==0 ){
1353 Tcl_GetDoubleFromObj(interp
, pVar
, &r
);
1354 sqlite3_bind_double(pStmt
, i
, r
);
1355 }else if( (c
=='w' && strcmp(zType
,"wideInt")==0) ||
1356 (c
=='i' && strcmp(zType
,"int")==0) ){
1358 Tcl_GetWideIntFromObj(interp
, pVar
, &v
);
1359 sqlite3_bind_int64(pStmt
, i
, v
);
1361 data
= (unsigned char *)Tcl_GetStringFromObj(pVar
, &n
);
1362 sqlite3_bind_text(pStmt
, i
, (char *)data
, n
, SQLITE_STATIC
);
1363 Tcl_IncrRefCount(pVar
);
1364 pPreStmt
->apParm
[iParm
++] = pVar
;
1367 sqlite3_bind_null(pStmt
, i
);
1371 pPreStmt
->nParm
= iParm
;
1372 *ppPreStmt
= pPreStmt
;
1378 ** Release a statement reference obtained by calling dbPrepareAndBind().
1379 ** There should be exactly one call to this function for each call to
1380 ** dbPrepareAndBind().
1382 ** If the discard parameter is non-zero, then the statement is deleted
1383 ** immediately. Otherwise it is added to the LRU list and may be returned
1384 ** by a subsequent call to dbPrepareAndBind().
1386 static void dbReleaseStmt(
1387 SqliteDb
*pDb
, /* Database handle */
1388 SqlPreparedStmt
*pPreStmt
, /* Prepared statement handle to release */
1389 int discard
/* True to delete (not cache) the pPreStmt */
1393 /* Free the bound string and blob parameters */
1394 for(i
=0; i
<pPreStmt
->nParm
; i
++){
1395 Tcl_DecrRefCount(pPreStmt
->apParm
[i
]);
1397 pPreStmt
->nParm
= 0;
1399 if( pDb
->maxStmt
<=0 || discard
){
1400 /* If the cache is turned off, deallocated the statement */
1401 dbFreeStmt(pPreStmt
);
1403 /* Add the prepared statement to the beginning of the cache list. */
1404 pPreStmt
->pNext
= pDb
->stmtList
;
1405 pPreStmt
->pPrev
= 0;
1406 if( pDb
->stmtList
){
1407 pDb
->stmtList
->pPrev
= pPreStmt
;
1409 pDb
->stmtList
= pPreStmt
;
1410 if( pDb
->stmtLast
==0 ){
1411 assert( pDb
->nStmt
==0 );
1412 pDb
->stmtLast
= pPreStmt
;
1414 assert( pDb
->nStmt
>0 );
1418 /* If we have too many statement in cache, remove the surplus from
1419 ** the end of the cache list. */
1420 while( pDb
->nStmt
>pDb
->maxStmt
){
1421 SqlPreparedStmt
*pLast
= pDb
->stmtLast
;
1422 pDb
->stmtLast
= pLast
->pPrev
;
1423 pDb
->stmtLast
->pNext
= 0;
1431 ** Structure used with dbEvalXXX() functions:
1437 ** dbEvalColumnValue()
1439 typedef struct DbEvalContext DbEvalContext
;
1440 struct DbEvalContext
{
1441 SqliteDb
*pDb
; /* Database handle */
1442 Tcl_Obj
*pSql
; /* Object holding string zSql */
1443 const char *zSql
; /* Remaining SQL to execute */
1444 SqlPreparedStmt
*pPreStmt
; /* Current statement */
1445 int nCol
; /* Number of columns returned by pStmt */
1446 Tcl_Obj
*pArray
; /* Name of array variable */
1447 Tcl_Obj
**apColName
; /* Array of column names */
1451 ** Release any cache of column names currently held as part of
1452 ** the DbEvalContext structure passed as the first argument.
1454 static void dbReleaseColumnNames(DbEvalContext
*p
){
1457 for(i
=0; i
<p
->nCol
; i
++){
1458 Tcl_DecrRefCount(p
->apColName
[i
]);
1460 Tcl_Free((char *)p
->apColName
);
1467 ** Initialize a DbEvalContext structure.
1469 ** If pArray is not NULL, then it contains the name of a Tcl array
1470 ** variable. The "*" member of this array is set to a list containing
1471 ** the names of the columns returned by the statement as part of each
1472 ** call to dbEvalStep(), in order from left to right. e.g. if the names
1473 ** of the returned columns are a, b and c, it does the equivalent of the
1476 ** set ${pArray}(*) {a b c}
1478 static void dbEvalInit(
1479 DbEvalContext
*p
, /* Pointer to structure to initialize */
1480 SqliteDb
*pDb
, /* Database handle */
1481 Tcl_Obj
*pSql
, /* Object containing SQL script */
1482 Tcl_Obj
*pArray
/* Name of Tcl array to set (*) element of */
1484 memset(p
, 0, sizeof(DbEvalContext
));
1486 p
->zSql
= Tcl_GetString(pSql
);
1488 Tcl_IncrRefCount(pSql
);
1491 Tcl_IncrRefCount(pArray
);
1496 ** Obtain information about the row that the DbEvalContext passed as the
1497 ** first argument currently points to.
1499 static void dbEvalRowInfo(
1500 DbEvalContext
*p
, /* Evaluation context */
1501 int *pnCol
, /* OUT: Number of column names */
1502 Tcl_Obj
***papColName
/* OUT: Array of column names */
1504 /* Compute column names */
1505 if( 0==p
->apColName
){
1506 sqlite3_stmt
*pStmt
= p
->pPreStmt
->pStmt
;
1507 int i
; /* Iterator variable */
1508 int nCol
; /* Number of columns returned by pStmt */
1509 Tcl_Obj
**apColName
= 0; /* Array of column names */
1511 p
->nCol
= nCol
= sqlite3_column_count(pStmt
);
1512 if( nCol
>0 && (papColName
|| p
->pArray
) ){
1513 apColName
= (Tcl_Obj
**)Tcl_Alloc( sizeof(Tcl_Obj
*)*nCol
);
1514 for(i
=0; i
<nCol
; i
++){
1515 apColName
[i
] = Tcl_NewStringObj(sqlite3_column_name(pStmt
,i
), -1);
1516 Tcl_IncrRefCount(apColName
[i
]);
1518 p
->apColName
= apColName
;
1521 /* If results are being stored in an array variable, then create
1522 ** the array(*) entry for that array
1525 Tcl_Interp
*interp
= p
->pDb
->interp
;
1526 Tcl_Obj
*pColList
= Tcl_NewObj();
1527 Tcl_Obj
*pStar
= Tcl_NewStringObj("*", -1);
1529 for(i
=0; i
<nCol
; i
++){
1530 Tcl_ListObjAppendElement(interp
, pColList
, apColName
[i
]);
1532 Tcl_IncrRefCount(pStar
);
1533 Tcl_ObjSetVar2(interp
, p
->pArray
, pStar
, pColList
, 0);
1534 Tcl_DecrRefCount(pStar
);
1539 *papColName
= p
->apColName
;
1547 ** Return one of TCL_OK, TCL_BREAK or TCL_ERROR. If TCL_ERROR is
1548 ** returned, then an error message is stored in the interpreter before
1551 ** A return value of TCL_OK means there is a row of data available. The
1552 ** data may be accessed using dbEvalRowInfo() and dbEvalColumnValue(). This
1553 ** is analogous to a return of SQLITE_ROW from sqlite3_step(). If TCL_BREAK
1554 ** is returned, then the SQL script has finished executing and there are
1555 ** no further rows available. This is similar to SQLITE_DONE.
1557 static int dbEvalStep(DbEvalContext
*p
){
1558 const char *zPrevSql
= 0; /* Previous value of p->zSql */
1560 while( p
->zSql
[0] || p
->pPreStmt
){
1562 if( p
->pPreStmt
==0 ){
1563 zPrevSql
= (p
->zSql
==zPrevSql
? 0 : p
->zSql
);
1564 rc
= dbPrepareAndBind(p
->pDb
, p
->zSql
, &p
->zSql
, &p
->pPreStmt
);
1565 if( rc
!=TCL_OK
) return rc
;
1568 SqliteDb
*pDb
= p
->pDb
;
1569 SqlPreparedStmt
*pPreStmt
= p
->pPreStmt
;
1570 sqlite3_stmt
*pStmt
= pPreStmt
->pStmt
;
1572 rcs
= sqlite3_step(pStmt
);
1573 if( rcs
==SQLITE_ROW
){
1577 dbEvalRowInfo(p
, 0, 0);
1579 rcs
= sqlite3_reset(pStmt
);
1581 pDb
->nStep
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_FULLSCAN_STEP
,1);
1582 pDb
->nSort
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_SORT
,1);
1583 pDb
->nIndex
= sqlite3_stmt_status(pStmt
,SQLITE_STMTSTATUS_AUTOINDEX
,1);
1584 dbReleaseColumnNames(p
);
1587 if( rcs
!=SQLITE_OK
){
1588 /* If a run-time error occurs, report the error and stop reading
1590 dbReleaseStmt(pDb
, pPreStmt
, 1);
1592 if( p
->pDb
->bLegacyPrepare
&& rcs
==SQLITE_SCHEMA
&& zPrevSql
){
1593 /* If the runtime error was an SQLITE_SCHEMA, and the database
1594 ** handle is configured to use the legacy sqlite3_prepare()
1595 ** interface, retry prepare()/step() on the same SQL statement.
1596 ** This only happens once. If there is a second SQLITE_SCHEMA
1597 ** error, the error will be returned to the caller. */
1602 Tcl_SetObjResult(pDb
->interp
,
1603 Tcl_NewStringObj(sqlite3_errmsg(pDb
->db
), -1));
1606 dbReleaseStmt(pDb
, pPreStmt
, 0);
1616 ** Free all resources currently held by the DbEvalContext structure passed
1617 ** as the first argument. There should be exactly one call to this function
1618 ** for each call to dbEvalInit().
1620 static void dbEvalFinalize(DbEvalContext
*p
){
1622 sqlite3_reset(p
->pPreStmt
->pStmt
);
1623 dbReleaseStmt(p
->pDb
, p
->pPreStmt
, 0);
1627 Tcl_DecrRefCount(p
->pArray
);
1630 Tcl_DecrRefCount(p
->pSql
);
1631 dbReleaseColumnNames(p
);
1635 ** Return a pointer to a Tcl_Obj structure with ref-count 0 that contains
1636 ** the value for the iCol'th column of the row currently pointed to by
1637 ** the DbEvalContext structure passed as the first argument.
1639 static Tcl_Obj
*dbEvalColumnValue(DbEvalContext
*p
, int iCol
){
1640 sqlite3_stmt
*pStmt
= p
->pPreStmt
->pStmt
;
1641 switch( sqlite3_column_type(pStmt
, iCol
) ){
1643 int bytes
= sqlite3_column_bytes(pStmt
, iCol
);
1644 const char *zBlob
= sqlite3_column_blob(pStmt
, iCol
);
1645 if( !zBlob
) bytes
= 0;
1646 return Tcl_NewByteArrayObj((u8
*)zBlob
, bytes
);
1648 case SQLITE_INTEGER
: {
1649 sqlite_int64 v
= sqlite3_column_int64(pStmt
, iCol
);
1650 if( v
>=-2147483647 && v
<=2147483647 ){
1651 return Tcl_NewIntObj((int)v
);
1653 return Tcl_NewWideIntObj(v
);
1656 case SQLITE_FLOAT
: {
1657 return Tcl_NewDoubleObj(sqlite3_column_double(pStmt
, iCol
));
1660 return Tcl_NewStringObj(p
->pDb
->zNull
, -1);
1664 return Tcl_NewStringObj((char*)sqlite3_column_text(pStmt
, iCol
), -1);
1668 ** If using Tcl version 8.6 or greater, use the NR functions to avoid
1669 ** recursive evalution of scripts by the [db eval] and [db trans]
1670 ** commands. Even if the headers used while compiling the extension
1671 ** are 8.6 or newer, the code still tests the Tcl version at runtime.
1672 ** This allows stubs-enabled builds to be used with older Tcl libraries.
1674 #if TCL_MAJOR_VERSION>8 || (TCL_MAJOR_VERSION==8 && TCL_MINOR_VERSION>=6)
1675 # define SQLITE_TCL_NRE 1
1676 static int DbUseNre(void){
1678 Tcl_GetVersion(&major
, &minor
, 0, 0);
1679 return( (major
==8 && minor
>=6) || major
>8 );
1683 ** Compiling using headers earlier than 8.6. In this case NR cannot be
1684 ** used, so DbUseNre() to always return zero. Add #defines for the other
1685 ** Tcl_NRxxx() functions to prevent them from causing compilation errors,
1686 ** even though the only invocations of them are within conditional blocks
1689 ** if( DbUseNre() ) { ... }
1691 # define SQLITE_TCL_NRE 0
1692 # define DbUseNre() 0
1693 # define Tcl_NRAddCallback(a,b,c,d,e,f) (void)0
1694 # define Tcl_NREvalObj(a,b,c) 0
1695 # define Tcl_NRCreateCommand(a,b,c,d,e,f) (void)0
1699 ** This function is part of the implementation of the command:
1701 ** $db eval SQL ?ARRAYNAME? SCRIPT
1703 static int SQLITE_TCLAPI
DbEvalNextCmd(
1704 ClientData data
[], /* data[0] is the (DbEvalContext*) */
1705 Tcl_Interp
*interp
, /* Tcl interpreter */
1706 int result
/* Result so far */
1708 int rc
= result
; /* Return code */
1710 /* The first element of the data[] array is a pointer to a DbEvalContext
1711 ** structure allocated using Tcl_Alloc(). The second element of data[]
1712 ** is a pointer to a Tcl_Obj containing the script to run for each row
1713 ** returned by the queries encapsulated in data[0]. */
1714 DbEvalContext
*p
= (DbEvalContext
*)data
[0];
1715 Tcl_Obj
*pScript
= (Tcl_Obj
*)data
[1];
1716 Tcl_Obj
*pArray
= p
->pArray
;
1718 while( (rc
==TCL_OK
|| rc
==TCL_CONTINUE
) && TCL_OK
==(rc
= dbEvalStep(p
)) ){
1721 Tcl_Obj
**apColName
;
1722 dbEvalRowInfo(p
, &nCol
, &apColName
);
1723 for(i
=0; i
<nCol
; i
++){
1724 Tcl_Obj
*pVal
= dbEvalColumnValue(p
, i
);
1726 Tcl_ObjSetVar2(interp
, apColName
[i
], 0, pVal
, 0);
1728 Tcl_ObjSetVar2(interp
, pArray
, apColName
[i
], pVal
, 0);
1732 /* The required interpreter variables are now populated with the data
1733 ** from the current row. If using NRE, schedule callbacks to evaluate
1734 ** script pScript, then to invoke this function again to fetch the next
1735 ** row (or clean up if there is no next row or the script throws an
1736 ** exception). After scheduling the callbacks, return control to the
1739 ** If not using NRE, evaluate pScript directly and continue with the
1740 ** next iteration of this while(...) loop. */
1742 Tcl_NRAddCallback(interp
, DbEvalNextCmd
, (void*)p
, (void*)pScript
, 0, 0);
1743 return Tcl_NREvalObj(interp
, pScript
, 0);
1745 rc
= Tcl_EvalObjEx(interp
, pScript
, 0);
1749 Tcl_DecrRefCount(pScript
);
1751 Tcl_Free((char *)p
);
1753 if( rc
==TCL_OK
|| rc
==TCL_BREAK
){
1754 Tcl_ResetResult(interp
);
1761 ** This function is used by the implementations of the following database
1762 ** handle sub-commands:
1764 ** $db update_hook ?SCRIPT?
1765 ** $db wal_hook ?SCRIPT?
1766 ** $db commit_hook ?SCRIPT?
1767 ** $db preupdate hook ?SCRIPT?
1769 static void DbHookCmd(
1770 Tcl_Interp
*interp
, /* Tcl interpreter */
1771 SqliteDb
*pDb
, /* Database handle */
1772 Tcl_Obj
*pArg
, /* SCRIPT argument (or NULL) */
1773 Tcl_Obj
**ppHook
/* Pointer to member of SqliteDb */
1775 sqlite3
*db
= pDb
->db
;
1778 Tcl_SetObjResult(interp
, *ppHook
);
1780 Tcl_DecrRefCount(*ppHook
);
1785 assert( !(*ppHook
) );
1786 if( Tcl_GetCharLength(pArg
)>0 ){
1788 Tcl_IncrRefCount(*ppHook
);
1792 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1793 sqlite3_preupdate_hook(db
, (pDb
->pPreUpdateHook
?DbPreUpdateHandler
:0), pDb
);
1795 sqlite3_update_hook(db
, (pDb
->pUpdateHook
?DbUpdateHandler
:0), pDb
);
1796 sqlite3_rollback_hook(db
, (pDb
->pRollbackHook
?DbRollbackHandler
:0), pDb
);
1797 sqlite3_wal_hook(db
, (pDb
->pWalHook
?DbWalHandler
:0), pDb
);
1801 ** The "sqlite" command below creates a new Tcl command for each
1802 ** connection it opens to an SQLite database. This routine is invoked
1803 ** whenever one of those connection-specific commands is executed
1804 ** in Tcl. For example, if you run Tcl code like this:
1806 ** sqlite3 db1 "my_database"
1809 ** The first command opens a connection to the "my_database" database
1810 ** and calls that connection "db1". The second command causes this
1811 ** subroutine to be invoked.
1813 static int SQLITE_TCLAPI
DbObjCmd(
1819 SqliteDb
*pDb
= (SqliteDb
*)cd
;
1822 static const char *DB_strs
[] = {
1823 "authorizer", "backup", "busy",
1824 "cache", "changes", "close",
1825 "collate", "collation_needed", "commit_hook",
1826 "complete", "copy", "enable_load_extension",
1827 "errorcode", "eval", "exists",
1828 "function", "incrblob", "interrupt",
1829 "last_insert_rowid", "nullvalue", "onecolumn",
1830 "preupdate", "profile", "progress",
1831 "rekey", "restore", "rollback_hook",
1832 "status", "timeout", "total_changes",
1833 "trace", "trace_v2", "transaction",
1834 "unlock_notify", "update_hook", "version",
1839 DB_AUTHORIZER
, DB_BACKUP
, DB_BUSY
,
1840 DB_CACHE
, DB_CHANGES
, DB_CLOSE
,
1841 DB_COLLATE
, DB_COLLATION_NEEDED
, DB_COMMIT_HOOK
,
1842 DB_COMPLETE
, DB_COPY
, DB_ENABLE_LOAD_EXTENSION
,
1843 DB_ERRORCODE
, DB_EVAL
, DB_EXISTS
,
1844 DB_FUNCTION
, DB_INCRBLOB
, DB_INTERRUPT
,
1845 DB_LAST_INSERT_ROWID
, DB_NULLVALUE
, DB_ONECOLUMN
,
1846 DB_PREUPDATE
, DB_PROFILE
, DB_PROGRESS
,
1847 DB_REKEY
, DB_RESTORE
, DB_ROLLBACK_HOOK
,
1848 DB_STATUS
, DB_TIMEOUT
, DB_TOTAL_CHANGES
,
1849 DB_TRACE
, DB_TRACE_V2
, DB_TRANSACTION
,
1850 DB_UNLOCK_NOTIFY
, DB_UPDATE_HOOK
, DB_VERSION
,
1853 /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
1856 Tcl_WrongNumArgs(interp
, 1, objv
, "SUBCOMMAND ...");
1859 if( Tcl_GetIndexFromObj(interp
, objv
[1], DB_strs
, "option", 0, &choice
) ){
1863 switch( (enum DB_enum
)choice
){
1865 /* $db authorizer ?CALLBACK?
1867 ** Invoke the given callback to authorize each SQL operation as it is
1868 ** compiled. 5 arguments are appended to the callback before it is
1871 ** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
1872 ** (2) First descriptive name (depends on authorization type)
1873 ** (3) Second descriptive name
1874 ** (4) Name of the database (ex: "main", "temp")
1875 ** (5) Name of trigger that is doing the access
1877 ** The callback should return on of the following strings: SQLITE_OK,
1878 ** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error.
1880 ** If this method is invoked with no arguments, the current authorization
1881 ** callback string is returned.
1883 case DB_AUTHORIZER
: {
1884 #ifdef SQLITE_OMIT_AUTHORIZATION
1885 Tcl_AppendResult(interp
, "authorization not available in this build",
1890 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
1892 }else if( objc
==2 ){
1894 Tcl_AppendResult(interp
, pDb
->zAuth
, (char*)0);
1900 Tcl_Free(pDb
->zAuth
);
1902 zAuth
= Tcl_GetStringFromObj(objv
[2], &len
);
1903 if( zAuth
&& len
>0 ){
1904 pDb
->zAuth
= Tcl_Alloc( len
+ 1 );
1905 memcpy(pDb
->zAuth
, zAuth
, len
+1);
1910 typedef int (*sqlite3_auth_cb
)(
1911 void*,int,const char*,const char*,
1912 const char*,const char*);
1913 pDb
->interp
= interp
;
1914 sqlite3_set_authorizer(pDb
->db
,(sqlite3_auth_cb
)auth_callback
,pDb
);
1916 sqlite3_set_authorizer(pDb
->db
, 0, 0);
1923 /* $db backup ?DATABASE? FILENAME
1925 ** Open or create a database file named FILENAME. Transfer the
1926 ** content of local database DATABASE (default: "main") into the
1927 ** FILENAME database.
1930 const char *zDestFile
;
1933 sqlite3_backup
*pBackup
;
1937 zDestFile
= Tcl_GetString(objv
[2]);
1938 }else if( objc
==4 ){
1939 zSrcDb
= Tcl_GetString(objv
[2]);
1940 zDestFile
= Tcl_GetString(objv
[3]);
1942 Tcl_WrongNumArgs(interp
, 2, objv
, "?DATABASE? FILENAME");
1945 rc
= sqlite3_open_v2(zDestFile
, &pDest
,
1946 SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
| pDb
->openFlags
, 0);
1947 if( rc
!=SQLITE_OK
){
1948 Tcl_AppendResult(interp
, "cannot open target database: ",
1949 sqlite3_errmsg(pDest
), (char*)0);
1950 sqlite3_close(pDest
);
1953 pBackup
= sqlite3_backup_init(pDest
, "main", pDb
->db
, zSrcDb
);
1955 Tcl_AppendResult(interp
, "backup failed: ",
1956 sqlite3_errmsg(pDest
), (char*)0);
1957 sqlite3_close(pDest
);
1960 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
){}
1961 sqlite3_backup_finish(pBackup
);
1962 if( rc
==SQLITE_DONE
){
1965 Tcl_AppendResult(interp
, "backup failed: ",
1966 sqlite3_errmsg(pDest
), (char*)0);
1969 sqlite3_close(pDest
);
1973 /* $db busy ?CALLBACK?
1975 ** Invoke the given callback if an SQL statement attempts to open
1976 ** a locked database file.
1980 Tcl_WrongNumArgs(interp
, 2, objv
, "CALLBACK");
1982 }else if( objc
==2 ){
1984 Tcl_AppendResult(interp
, pDb
->zBusy
, (char*)0);
1990 Tcl_Free(pDb
->zBusy
);
1992 zBusy
= Tcl_GetStringFromObj(objv
[2], &len
);
1993 if( zBusy
&& len
>0 ){
1994 pDb
->zBusy
= Tcl_Alloc( len
+ 1 );
1995 memcpy(pDb
->zBusy
, zBusy
, len
+1);
2000 pDb
->interp
= interp
;
2001 sqlite3_busy_handler(pDb
->db
, DbBusyHandler
, pDb
);
2003 sqlite3_busy_handler(pDb
->db
, 0, 0);
2012 ** Flush the prepared statement cache, or set the maximum number of
2013 ** cached statements.
2020 Tcl_WrongNumArgs(interp
, 1, objv
, "cache option ?arg?");
2023 subCmd
= Tcl_GetStringFromObj( objv
[2], 0 );
2024 if( *subCmd
=='f' && strcmp(subCmd
,"flush")==0 ){
2026 Tcl_WrongNumArgs(interp
, 2, objv
, "flush");
2029 flushStmtCache( pDb
);
2031 }else if( *subCmd
=='s' && strcmp(subCmd
,"size")==0 ){
2033 Tcl_WrongNumArgs(interp
, 2, objv
, "size n");
2036 if( TCL_ERROR
==Tcl_GetIntFromObj(interp
, objv
[3], &n
) ){
2037 Tcl_AppendResult( interp
, "cannot convert \"",
2038 Tcl_GetStringFromObj(objv
[3],0), "\" to integer", (char*)0);
2042 flushStmtCache( pDb
);
2044 }else if( n
>MAX_PREPARED_STMTS
){
2045 n
= MAX_PREPARED_STMTS
;
2051 Tcl_AppendResult( interp
, "bad option \"",
2052 Tcl_GetStringFromObj(objv
[2],0), "\": must be flush or size",
2061 ** Return the number of rows that were modified, inserted, or deleted by
2062 ** the most recent INSERT, UPDATE or DELETE statement, not including
2063 ** any changes made by trigger programs.
2068 Tcl_WrongNumArgs(interp
, 2, objv
, "");
2071 pResult
= Tcl_GetObjResult(interp
);
2072 Tcl_SetIntObj(pResult
, sqlite3_changes(pDb
->db
));
2078 ** Shutdown the database
2081 Tcl_DeleteCommand(interp
, Tcl_GetStringFromObj(objv
[0], 0));
2086 ** $db collate NAME SCRIPT
2088 ** Create a new SQL collation function called NAME. Whenever
2089 ** that function is called, invoke SCRIPT to evaluate the function.
2092 SqlCollate
*pCollate
;
2097 Tcl_WrongNumArgs(interp
, 2, objv
, "NAME SCRIPT");
2100 zName
= Tcl_GetStringFromObj(objv
[2], 0);
2101 zScript
= Tcl_GetStringFromObj(objv
[3], &nScript
);
2102 pCollate
= (SqlCollate
*)Tcl_Alloc( sizeof(*pCollate
) + nScript
+ 1 );
2103 if( pCollate
==0 ) return TCL_ERROR
;
2104 pCollate
->interp
= interp
;
2105 pCollate
->pNext
= pDb
->pCollate
;
2106 pCollate
->zScript
= (char*)&pCollate
[1];
2107 pDb
->pCollate
= pCollate
;
2108 memcpy(pCollate
->zScript
, zScript
, nScript
+1);
2109 if( sqlite3_create_collation(pDb
->db
, zName
, SQLITE_UTF8
,
2110 pCollate
, tclSqlCollate
) ){
2111 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
2118 ** $db collation_needed SCRIPT
2120 ** Create a new SQL collation function called NAME. Whenever
2121 ** that function is called, invoke SCRIPT to evaluate the function.
2123 case DB_COLLATION_NEEDED
: {
2125 Tcl_WrongNumArgs(interp
, 2, objv
, "SCRIPT");
2128 if( pDb
->pCollateNeeded
){
2129 Tcl_DecrRefCount(pDb
->pCollateNeeded
);
2131 pDb
->pCollateNeeded
= Tcl_DuplicateObj(objv
[2]);
2132 Tcl_IncrRefCount(pDb
->pCollateNeeded
);
2133 sqlite3_collation_needed(pDb
->db
, pDb
, tclCollateNeeded
);
2137 /* $db commit_hook ?CALLBACK?
2139 ** Invoke the given callback just before committing every SQL transaction.
2140 ** If the callback throws an exception or returns non-zero, then the
2141 ** transaction is aborted. If CALLBACK is an empty string, the callback
2144 case DB_COMMIT_HOOK
: {
2146 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
2148 }else if( objc
==2 ){
2150 Tcl_AppendResult(interp
, pDb
->zCommit
, (char*)0);
2153 const char *zCommit
;
2156 Tcl_Free(pDb
->zCommit
);
2158 zCommit
= Tcl_GetStringFromObj(objv
[2], &len
);
2159 if( zCommit
&& len
>0 ){
2160 pDb
->zCommit
= Tcl_Alloc( len
+ 1 );
2161 memcpy(pDb
->zCommit
, zCommit
, len
+1);
2166 pDb
->interp
= interp
;
2167 sqlite3_commit_hook(pDb
->db
, DbCommitHandler
, pDb
);
2169 sqlite3_commit_hook(pDb
->db
, 0, 0);
2177 ** Return TRUE if SQL is a complete SQL statement. Return FALSE if
2178 ** additional lines of input are needed. This is similar to the
2179 ** built-in "info complete" command of Tcl.
2182 #ifndef SQLITE_OMIT_COMPLETE
2186 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL");
2189 isComplete
= sqlite3_complete( Tcl_GetStringFromObj(objv
[2], 0) );
2190 pResult
= Tcl_GetObjResult(interp
);
2191 Tcl_SetBooleanObj(pResult
, isComplete
);
2196 /* $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
2198 ** Copy data into table from filename, optionally using SEPARATOR
2199 ** as column separators. If a column contains a null string, or the
2200 ** value of NULLINDICATOR, a NULL is inserted for the column.
2201 ** conflict-algorithm is one of the sqlite conflict algorithms:
2202 ** rollback, abort, fail, ignore, replace
2203 ** On success, return the number of lines processed, not necessarily same
2204 ** as 'db changes' due to conflict-algorithm selected.
2206 ** This code is basically an implementation/enhancement of
2207 ** the sqlite3 shell.c ".import" command.
2209 ** This command usage is equivalent to the sqlite2.x COPY statement,
2210 ** which imports file data into a table using the PostgreSQL COPY file format:
2211 ** $db copy $conflit_algo $table_name $filename \t \\N
2214 char *zTable
; /* Insert data into this table */
2215 char *zFile
; /* The file from which to extract data */
2216 char *zConflict
; /* The conflict algorithm to use */
2217 sqlite3_stmt
*pStmt
; /* A statement */
2218 int nCol
; /* Number of columns in the table */
2219 int nByte
; /* Number of bytes in an SQL string */
2220 int i
, j
; /* Loop counters */
2221 int nSep
; /* Number of bytes in zSep[] */
2222 int nNull
; /* Number of bytes in zNull[] */
2223 char *zSql
; /* An SQL statement */
2224 char *zLine
; /* A single line of input from the file */
2225 char **azCol
; /* zLine[] broken up into columns */
2226 const char *zCommit
; /* How to commit changes */
2227 FILE *in
; /* The input file */
2228 int lineno
= 0; /* Line number of input file */
2229 char zLineNum
[80]; /* Line number print buffer */
2230 Tcl_Obj
*pResult
; /* interp result */
2234 if( objc
<5 || objc
>7 ){
2235 Tcl_WrongNumArgs(interp
, 2, objv
,
2236 "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");
2240 zSep
= Tcl_GetStringFromObj(objv
[5], 0);
2245 zNull
= Tcl_GetStringFromObj(objv
[6], 0);
2249 zConflict
= Tcl_GetStringFromObj(objv
[2], 0);
2250 zTable
= Tcl_GetStringFromObj(objv
[3], 0);
2251 zFile
= Tcl_GetStringFromObj(objv
[4], 0);
2252 nSep
= strlen30(zSep
);
2253 nNull
= strlen30(zNull
);
2255 Tcl_AppendResult(interp
,"Error: non-null separator required for copy",
2259 if(strcmp(zConflict
, "rollback") != 0 &&
2260 strcmp(zConflict
, "abort" ) != 0 &&
2261 strcmp(zConflict
, "fail" ) != 0 &&
2262 strcmp(zConflict
, "ignore" ) != 0 &&
2263 strcmp(zConflict
, "replace" ) != 0 ) {
2264 Tcl_AppendResult(interp
, "Error: \"", zConflict
,
2265 "\", conflict-algorithm must be one of: rollback, "
2266 "abort, fail, ignore, or replace", (char*)0);
2269 zSql
= sqlite3_mprintf("SELECT * FROM '%q'", zTable
);
2271 Tcl_AppendResult(interp
, "Error: no such table: ", zTable
, (char*)0);
2274 nByte
= strlen30(zSql
);
2275 rc
= sqlite3_prepare(pDb
->db
, zSql
, -1, &pStmt
, 0);
2278 Tcl_AppendResult(interp
, "Error: ", sqlite3_errmsg(pDb
->db
), (char*)0);
2281 nCol
= sqlite3_column_count(pStmt
);
2283 sqlite3_finalize(pStmt
);
2287 zSql
= malloc( nByte
+ 50 + nCol
*2 );
2289 Tcl_AppendResult(interp
, "Error: can't malloc()", (char*)0);
2292 sqlite3_snprintf(nByte
+50, zSql
, "INSERT OR %q INTO '%q' VALUES(?",
2295 for(i
=1; i
<nCol
; i
++){
2301 rc
= sqlite3_prepare(pDb
->db
, zSql
, -1, &pStmt
, 0);
2304 Tcl_AppendResult(interp
, "Error: ", sqlite3_errmsg(pDb
->db
), (char*)0);
2305 sqlite3_finalize(pStmt
);
2308 in
= fopen(zFile
, "rb");
2310 Tcl_AppendResult(interp
, "Error: cannot open file: ", zFile
, (char*)0);
2311 sqlite3_finalize(pStmt
);
2314 azCol
= malloc( sizeof(azCol
[0])*(nCol
+1) );
2316 Tcl_AppendResult(interp
, "Error: can't malloc()", (char*)0);
2320 (void)sqlite3_exec(pDb
->db
, "BEGIN", 0, 0, 0);
2322 while( (zLine
= local_getline(0, in
))!=0 ){
2326 for(i
=0, z
=zLine
; *z
; z
++){
2327 if( *z
==zSep
[0] && strncmp(z
, zSep
, nSep
)==0 ){
2331 azCol
[i
] = &z
[nSep
];
2338 int nErr
= strlen30(zFile
) + 200;
2339 zErr
= malloc(nErr
);
2341 sqlite3_snprintf(nErr
, zErr
,
2342 "Error: %s line %d: expected %d columns of data but found %d",
2343 zFile
, lineno
, nCol
, i
+1);
2344 Tcl_AppendResult(interp
, zErr
, (char*)0);
2347 zCommit
= "ROLLBACK";
2350 for(i
=0; i
<nCol
; i
++){
2351 /* check for null data, if so, bind as null */
2352 if( (nNull
>0 && strcmp(azCol
[i
], zNull
)==0)
2353 || strlen30(azCol
[i
])==0
2355 sqlite3_bind_null(pStmt
, i
+1);
2357 sqlite3_bind_text(pStmt
, i
+1, azCol
[i
], -1, SQLITE_STATIC
);
2360 sqlite3_step(pStmt
);
2361 rc
= sqlite3_reset(pStmt
);
2363 if( rc
!=SQLITE_OK
){
2364 Tcl_AppendResult(interp
,"Error: ", sqlite3_errmsg(pDb
->db
), (char*)0);
2365 zCommit
= "ROLLBACK";
2371 sqlite3_finalize(pStmt
);
2372 (void)sqlite3_exec(pDb
->db
, zCommit
, 0, 0, 0);
2374 if( zCommit
[0] == 'C' ){
2375 /* success, set result as number of lines processed */
2376 pResult
= Tcl_GetObjResult(interp
);
2377 Tcl_SetIntObj(pResult
, lineno
);
2380 /* failure, append lineno where failed */
2381 sqlite3_snprintf(sizeof(zLineNum
), zLineNum
,"%d",lineno
);
2382 Tcl_AppendResult(interp
,", failed while processing line: ",zLineNum
,
2390 ** $db enable_load_extension BOOLEAN
2392 ** Turn the extension loading feature on or off. It if off by
2395 case DB_ENABLE_LOAD_EXTENSION
: {
2396 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2399 Tcl_WrongNumArgs(interp
, 2, objv
, "BOOLEAN");
2402 if( Tcl_GetBooleanFromObj(interp
, objv
[2], &onoff
) ){
2405 sqlite3_enable_load_extension(pDb
->db
, onoff
);
2408 Tcl_AppendResult(interp
, "extension loading is turned off at compile-time",
2417 ** Return the numeric error code that was returned by the most recent
2418 ** call to sqlite3_exec().
2420 case DB_ERRORCODE
: {
2421 Tcl_SetObjResult(interp
, Tcl_NewIntObj(sqlite3_errcode(pDb
->db
)));
2427 ** $db onecolumn $sql
2429 ** The onecolumn method is the equivalent of:
2430 ** lindex [$db eval $sql] 0
2433 case DB_ONECOLUMN
: {
2434 Tcl_Obj
*pResult
= 0;
2435 DbEvalContext sEval
;
2437 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL");
2441 dbEvalInit(&sEval
, pDb
, objv
[2], 0);
2442 rc
= dbEvalStep(&sEval
);
2443 if( choice
==DB_ONECOLUMN
){
2445 pResult
= dbEvalColumnValue(&sEval
, 0);
2446 }else if( rc
==TCL_BREAK
){
2447 Tcl_ResetResult(interp
);
2449 }else if( rc
==TCL_BREAK
|| rc
==TCL_OK
){
2450 pResult
= Tcl_NewBooleanObj(rc
==TCL_OK
);
2452 dbEvalFinalize(&sEval
);
2453 if( pResult
) Tcl_SetObjResult(interp
, pResult
);
2455 if( rc
==TCL_BREAK
){
2462 ** $db eval $sql ?array? ?{ ...code... }?
2464 ** The SQL statement in $sql is evaluated. For each row, the values are
2465 ** placed in elements of the array named "array" and ...code... is executed.
2466 ** If "array" and "code" are omitted, then no callback is every invoked.
2467 ** If "array" is an empty string, then the values are placed in variables
2468 ** that have the same name as the fields extracted by the query.
2471 if( objc
<3 || objc
>5 ){
2472 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL ?ARRAY-NAME? ?SCRIPT?");
2477 DbEvalContext sEval
;
2478 Tcl_Obj
*pRet
= Tcl_NewObj();
2479 Tcl_IncrRefCount(pRet
);
2480 dbEvalInit(&sEval
, pDb
, objv
[2], 0);
2481 while( TCL_OK
==(rc
= dbEvalStep(&sEval
)) ){
2484 dbEvalRowInfo(&sEval
, &nCol
, 0);
2485 for(i
=0; i
<nCol
; i
++){
2486 Tcl_ListObjAppendElement(interp
, pRet
, dbEvalColumnValue(&sEval
, i
));
2489 dbEvalFinalize(&sEval
);
2490 if( rc
==TCL_BREAK
){
2491 Tcl_SetObjResult(interp
, pRet
);
2494 Tcl_DecrRefCount(pRet
);
2498 Tcl_Obj
*pArray
= 0;
2501 if( objc
==5 && *(char *)Tcl_GetString(objv
[3]) ){
2504 pScript
= objv
[objc
-1];
2505 Tcl_IncrRefCount(pScript
);
2507 p
= (DbEvalContext
*)Tcl_Alloc(sizeof(DbEvalContext
));
2508 dbEvalInit(p
, pDb
, objv
[2], pArray
);
2511 cd2
[1] = (void *)pScript
;
2512 rc
= DbEvalNextCmd(cd2
, interp
, TCL_OK
);
2518 ** $db function NAME [-argcount N] [-deterministic] SCRIPT
2520 ** Create a new SQL function called NAME. Whenever that function is
2521 ** called, invoke SCRIPT to evaluate the function.
2524 int flags
= SQLITE_UTF8
;
2531 Tcl_WrongNumArgs(interp
, 2, objv
, "NAME ?SWITCHES? SCRIPT");
2534 for(i
=3; i
<(objc
-1); i
++){
2535 const char *z
= Tcl_GetString(objv
[i
]);
2536 int n
= strlen30(z
);
2537 if( n
>2 && strncmp(z
, "-argcount",n
)==0 ){
2539 Tcl_AppendResult(interp
, "option requires an argument: ", z
,(char*)0);
2542 if( Tcl_GetIntFromObj(interp
, objv
[i
+1], &nArg
) ) return TCL_ERROR
;
2544 Tcl_AppendResult(interp
, "number of arguments must be non-negative",
2550 if( n
>2 && strncmp(z
, "-deterministic",n
)==0 ){
2551 flags
|= SQLITE_DETERMINISTIC
;
2553 Tcl_AppendResult(interp
, "bad option \"", z
,
2554 "\": must be -argcount or -deterministic", (char*)0
2560 pScript
= objv
[objc
-1];
2561 zName
= Tcl_GetStringFromObj(objv
[2], 0);
2562 pFunc
= findSqlFunc(pDb
, zName
);
2563 if( pFunc
==0 ) return TCL_ERROR
;
2564 if( pFunc
->pScript
){
2565 Tcl_DecrRefCount(pFunc
->pScript
);
2567 pFunc
->pScript
= pScript
;
2568 Tcl_IncrRefCount(pScript
);
2569 pFunc
->useEvalObjv
= safeToUseEvalObjv(interp
, pScript
);
2570 rc
= sqlite3_create_function(pDb
->db
, zName
, nArg
, flags
,
2571 pFunc
, tclSqlFunc
, 0, 0);
2572 if( rc
!=SQLITE_OK
){
2574 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
2580 ** $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
2583 #ifdef SQLITE_OMIT_INCRBLOB
2584 Tcl_AppendResult(interp
, "incrblob not available in this build", (char*)0);
2588 const char *zDb
= "main";
2590 const char *zColumn
;
2593 /* Check for the -readonly option */
2594 if( objc
>3 && strcmp(Tcl_GetString(objv
[2]), "-readonly")==0 ){
2598 if( objc
!=(5+isReadonly
) && objc
!=(6+isReadonly
) ){
2599 Tcl_WrongNumArgs(interp
, 2, objv
, "?-readonly? ?DB? TABLE COLUMN ROWID");
2603 if( objc
==(6+isReadonly
) ){
2604 zDb
= Tcl_GetString(objv
[2]);
2606 zTable
= Tcl_GetString(objv
[objc
-3]);
2607 zColumn
= Tcl_GetString(objv
[objc
-2]);
2608 rc
= Tcl_GetWideIntFromObj(interp
, objv
[objc
-1], &iRow
);
2611 rc
= createIncrblobChannel(
2612 interp
, pDb
, zDb
, zTable
, zColumn
, (sqlite3_int64
)iRow
, isReadonly
2622 ** Interrupt the execution of the inner-most SQL interpreter. This
2623 ** causes the SQL statement to return an error of SQLITE_INTERRUPT.
2625 case DB_INTERRUPT
: {
2626 sqlite3_interrupt(pDb
->db
);
2631 ** $db nullvalue ?STRING?
2633 ** Change text used when a NULL comes back from the database. If ?STRING?
2634 ** is not present, then the current string used for NULL is returned.
2635 ** If STRING is present, then STRING is returned.
2638 case DB_NULLVALUE
: {
2639 if( objc
!=2 && objc
!=3 ){
2640 Tcl_WrongNumArgs(interp
, 2, objv
, "NULLVALUE");
2645 char *zNull
= Tcl_GetStringFromObj(objv
[2], &len
);
2647 Tcl_Free(pDb
->zNull
);
2649 if( zNull
&& len
>0 ){
2650 pDb
->zNull
= Tcl_Alloc( len
+ 1 );
2651 memcpy(pDb
->zNull
, zNull
, len
);
2652 pDb
->zNull
[len
] = '\0';
2657 Tcl_SetObjResult(interp
, Tcl_NewStringObj(pDb
->zNull
, -1));
2662 ** $db last_insert_rowid
2664 ** Return an integer which is the ROWID for the most recent insert.
2666 case DB_LAST_INSERT_ROWID
: {
2670 Tcl_WrongNumArgs(interp
, 2, objv
, "");
2673 rowid
= sqlite3_last_insert_rowid(pDb
->db
);
2674 pResult
= Tcl_GetObjResult(interp
);
2675 Tcl_SetWideIntObj(pResult
, rowid
);
2680 ** The DB_ONECOLUMN method is implemented together with DB_EXISTS.
2683 /* $db progress ?N CALLBACK?
2685 ** Invoke the given callback every N virtual machine opcodes while executing
2690 if( pDb
->zProgress
){
2691 Tcl_AppendResult(interp
, pDb
->zProgress
, (char*)0);
2693 }else if( objc
==4 ){
2697 if( TCL_OK
!=Tcl_GetIntFromObj(interp
, objv
[2], &N
) ){
2700 if( pDb
->zProgress
){
2701 Tcl_Free(pDb
->zProgress
);
2703 zProgress
= Tcl_GetStringFromObj(objv
[3], &len
);
2704 if( zProgress
&& len
>0 ){
2705 pDb
->zProgress
= Tcl_Alloc( len
+ 1 );
2706 memcpy(pDb
->zProgress
, zProgress
, len
+1);
2710 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
2711 if( pDb
->zProgress
){
2712 pDb
->interp
= interp
;
2713 sqlite3_progress_handler(pDb
->db
, N
, DbProgressHandler
, pDb
);
2715 sqlite3_progress_handler(pDb
->db
, 0, 0, 0);
2719 Tcl_WrongNumArgs(interp
, 2, objv
, "N CALLBACK");
2725 /* $db profile ?CALLBACK?
2727 ** Make arrangements to invoke the CALLBACK routine after each SQL statement
2728 ** that has run. The text of the SQL and the amount of elapse time are
2729 ** appended to CALLBACK before the script is run.
2733 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
2735 }else if( objc
==2 ){
2736 if( pDb
->zProfile
){
2737 Tcl_AppendResult(interp
, pDb
->zProfile
, (char*)0);
2742 if( pDb
->zProfile
){
2743 Tcl_Free(pDb
->zProfile
);
2745 zProfile
= Tcl_GetStringFromObj(objv
[2], &len
);
2746 if( zProfile
&& len
>0 ){
2747 pDb
->zProfile
= Tcl_Alloc( len
+ 1 );
2748 memcpy(pDb
->zProfile
, zProfile
, len
+1);
2752 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
2753 !defined(SQLITE_OMIT_DEPRECATED)
2754 if( pDb
->zProfile
){
2755 pDb
->interp
= interp
;
2756 sqlite3_profile(pDb
->db
, DbProfileHandler
, pDb
);
2758 sqlite3_profile(pDb
->db
, 0, 0);
2768 ** Change the encryption key on the currently open database.
2771 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
2776 Tcl_WrongNumArgs(interp
, 2, objv
, "KEY");
2779 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
2780 pKey
= Tcl_GetByteArrayFromObj(objv
[2], &nKey
);
2781 rc
= sqlite3_rekey(pDb
->db
, pKey
, nKey
);
2783 Tcl_AppendResult(interp
, sqlite3_errstr(rc
), (char*)0);
2790 /* $db restore ?DATABASE? FILENAME
2792 ** Open a database file named FILENAME. Transfer the content
2793 ** of FILENAME into the local database DATABASE (default: "main").
2796 const char *zSrcFile
;
2797 const char *zDestDb
;
2799 sqlite3_backup
*pBackup
;
2804 zSrcFile
= Tcl_GetString(objv
[2]);
2805 }else if( objc
==4 ){
2806 zDestDb
= Tcl_GetString(objv
[2]);
2807 zSrcFile
= Tcl_GetString(objv
[3]);
2809 Tcl_WrongNumArgs(interp
, 2, objv
, "?DATABASE? FILENAME");
2812 rc
= sqlite3_open_v2(zSrcFile
, &pSrc
,
2813 SQLITE_OPEN_READONLY
| pDb
->openFlags
, 0);
2814 if( rc
!=SQLITE_OK
){
2815 Tcl_AppendResult(interp
, "cannot open source database: ",
2816 sqlite3_errmsg(pSrc
), (char*)0);
2817 sqlite3_close(pSrc
);
2820 pBackup
= sqlite3_backup_init(pDb
->db
, zDestDb
, pSrc
, "main");
2822 Tcl_AppendResult(interp
, "restore failed: ",
2823 sqlite3_errmsg(pDb
->db
), (char*)0);
2824 sqlite3_close(pSrc
);
2827 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
2828 || rc
==SQLITE_BUSY
){
2829 if( rc
==SQLITE_BUSY
){
2830 if( nTimeout
++ >= 3 ) break;
2834 sqlite3_backup_finish(pBackup
);
2835 if( rc
==SQLITE_DONE
){
2837 }else if( rc
==SQLITE_BUSY
|| rc
==SQLITE_LOCKED
){
2838 Tcl_AppendResult(interp
, "restore failed: source database busy",
2842 Tcl_AppendResult(interp
, "restore failed: ",
2843 sqlite3_errmsg(pDb
->db
), (char*)0);
2846 sqlite3_close(pSrc
);
2851 ** $db status (step|sort|autoindex)
2853 ** Display SQLITE_STMTSTATUS_FULLSCAN_STEP or
2854 ** SQLITE_STMTSTATUS_SORT for the most recent eval.
2860 Tcl_WrongNumArgs(interp
, 2, objv
, "(step|sort|autoindex)");
2863 zOp
= Tcl_GetString(objv
[2]);
2864 if( strcmp(zOp
, "step")==0 ){
2866 }else if( strcmp(zOp
, "sort")==0 ){
2868 }else if( strcmp(zOp
, "autoindex")==0 ){
2871 Tcl_AppendResult(interp
,
2872 "bad argument: should be autoindex, step, or sort",
2876 Tcl_SetObjResult(interp
, Tcl_NewIntObj(v
));
2881 ** $db timeout MILLESECONDS
2883 ** Delay for the number of milliseconds specified when a file is locked.
2888 Tcl_WrongNumArgs(interp
, 2, objv
, "MILLISECONDS");
2891 if( Tcl_GetIntFromObj(interp
, objv
[2], &ms
) ) return TCL_ERROR
;
2892 sqlite3_busy_timeout(pDb
->db
, ms
);
2897 ** $db total_changes
2899 ** Return the number of rows that were modified, inserted, or deleted
2900 ** since the database handle was created.
2902 case DB_TOTAL_CHANGES
: {
2905 Tcl_WrongNumArgs(interp
, 2, objv
, "");
2908 pResult
= Tcl_GetObjResult(interp
);
2909 Tcl_SetIntObj(pResult
, sqlite3_total_changes(pDb
->db
));
2913 /* $db trace ?CALLBACK?
2915 ** Make arrangements to invoke the CALLBACK routine for each SQL statement
2916 ** that is executed. The text of the SQL is appended to CALLBACK before
2921 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
2923 }else if( objc
==2 ){
2925 Tcl_AppendResult(interp
, pDb
->zTrace
, (char*)0);
2931 Tcl_Free(pDb
->zTrace
);
2933 zTrace
= Tcl_GetStringFromObj(objv
[2], &len
);
2934 if( zTrace
&& len
>0 ){
2935 pDb
->zTrace
= Tcl_Alloc( len
+ 1 );
2936 memcpy(pDb
->zTrace
, zTrace
, len
+1);
2940 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) && \
2941 !defined(SQLITE_OMIT_DEPRECATED)
2943 pDb
->interp
= interp
;
2944 sqlite3_trace(pDb
->db
, DbTraceHandler
, pDb
);
2946 sqlite3_trace(pDb
->db
, 0, 0);
2953 /* $db trace_v2 ?CALLBACK? ?MASK?
2955 ** Make arrangements to invoke the CALLBACK routine for each trace event
2956 ** matching the mask that is generated. The parameters are appended to
2957 ** CALLBACK before it is executed.
2961 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK? ?MASK?");
2963 }else if( objc
==2 ){
2964 if( pDb
->zTraceV2
){
2965 Tcl_AppendResult(interp
, pDb
->zTraceV2
, (char*)0);
2970 Tcl_WideInt wMask
= 0;
2972 static const char *TTYPE_strs
[] = {
2973 "statement", "profile", "row", "close", 0
2976 TTYPE_STMT
, TTYPE_PROFILE
, TTYPE_ROW
, TTYPE_CLOSE
2979 if( TCL_OK
!=Tcl_ListObjLength(interp
, objv
[3], &len
) ){
2982 for(i
=0; i
<len
; i
++){
2985 if( TCL_OK
!=Tcl_ListObjIndex(interp
, objv
[3], i
, &pObj
) ){
2988 if( Tcl_GetIndexFromObj(interp
, pObj
, TTYPE_strs
, "trace type",
2989 0, &ttype
)!=TCL_OK
){
2991 Tcl_Obj
*pError
= Tcl_DuplicateObj(Tcl_GetObjResult(interp
));
2992 Tcl_IncrRefCount(pError
);
2993 if( TCL_OK
==Tcl_GetWideIntFromObj(interp
, pObj
, &wType
) ){
2994 Tcl_DecrRefCount(pError
);
2997 Tcl_SetObjResult(interp
, pError
);
2998 Tcl_DecrRefCount(pError
);
3002 switch( (enum TTYPE_enum
)ttype
){
3003 case TTYPE_STMT
: wMask
|= SQLITE_TRACE_STMT
; break;
3004 case TTYPE_PROFILE
: wMask
|= SQLITE_TRACE_PROFILE
; break;
3005 case TTYPE_ROW
: wMask
|= SQLITE_TRACE_ROW
; break;
3006 case TTYPE_CLOSE
: wMask
|= SQLITE_TRACE_CLOSE
; break;
3011 wMask
= SQLITE_TRACE_STMT
; /* use the "legacy" default */
3013 if( pDb
->zTraceV2
){
3014 Tcl_Free(pDb
->zTraceV2
);
3016 zTraceV2
= Tcl_GetStringFromObj(objv
[2], &len
);
3017 if( zTraceV2
&& len
>0 ){
3018 pDb
->zTraceV2
= Tcl_Alloc( len
+ 1 );
3019 memcpy(pDb
->zTraceV2
, zTraceV2
, len
+1);
3023 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
3024 if( pDb
->zTraceV2
){
3025 pDb
->interp
= interp
;
3026 sqlite3_trace_v2(pDb
->db
, (unsigned)wMask
, DbTraceV2Handler
, pDb
);
3028 sqlite3_trace_v2(pDb
->db
, 0, 0, 0);
3035 /* $db transaction [-deferred|-immediate|-exclusive] SCRIPT
3037 ** Start a new transaction (if we are not already in the midst of a
3038 ** transaction) and execute the TCL script SCRIPT. After SCRIPT
3039 ** completes, either commit the transaction or roll it back if SCRIPT
3040 ** throws an exception. Or if no new transation was started, do nothing.
3041 ** pass the exception on up the stack.
3043 ** This command was inspired by Dave Thomas's talk on Ruby at the
3044 ** 2005 O'Reilly Open Source Convention (OSCON).
3046 case DB_TRANSACTION
: {
3048 const char *zBegin
= "SAVEPOINT _tcl_transaction";
3049 if( objc
!=3 && objc
!=4 ){
3050 Tcl_WrongNumArgs(interp
, 2, objv
, "[TYPE] SCRIPT");
3054 if( pDb
->nTransaction
==0 && objc
==4 ){
3055 static const char *TTYPE_strs
[] = {
3056 "deferred", "exclusive", "immediate", 0
3059 TTYPE_DEFERRED
, TTYPE_EXCLUSIVE
, TTYPE_IMMEDIATE
3062 if( Tcl_GetIndexFromObj(interp
, objv
[2], TTYPE_strs
, "transaction type",
3066 switch( (enum TTYPE_enum
)ttype
){
3067 case TTYPE_DEFERRED
: /* no-op */; break;
3068 case TTYPE_EXCLUSIVE
: zBegin
= "BEGIN EXCLUSIVE"; break;
3069 case TTYPE_IMMEDIATE
: zBegin
= "BEGIN IMMEDIATE"; break;
3072 pScript
= objv
[objc
-1];
3074 /* Run the SQLite BEGIN command to open a transaction or savepoint. */
3076 rc
= sqlite3_exec(pDb
->db
, zBegin
, 0, 0, 0);
3078 if( rc
!=SQLITE_OK
){
3079 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
3082 pDb
->nTransaction
++;
3084 /* If using NRE, schedule a callback to invoke the script pScript, then
3085 ** a second callback to commit (or rollback) the transaction or savepoint
3086 ** opened above. If not using NRE, evaluate the script directly, then
3087 ** call function DbTransPostCmd() to commit (or rollback) the transaction
3090 Tcl_NRAddCallback(interp
, DbTransPostCmd
, cd
, 0, 0, 0);
3091 (void)Tcl_NREvalObj(interp
, pScript
, 0);
3093 rc
= DbTransPostCmd(&cd
, interp
, Tcl_EvalObjEx(interp
, pScript
, 0));
3099 ** $db unlock_notify ?script?
3101 case DB_UNLOCK_NOTIFY
: {
3102 #ifndef SQLITE_ENABLE_UNLOCK_NOTIFY
3103 Tcl_AppendResult(interp
, "unlock_notify not available in this build",
3107 if( objc
!=2 && objc
!=3 ){
3108 Tcl_WrongNumArgs(interp
, 2, objv
, "?SCRIPT?");
3111 void (*xNotify
)(void **, int) = 0;
3112 void *pNotifyArg
= 0;
3114 if( pDb
->pUnlockNotify
){
3115 Tcl_DecrRefCount(pDb
->pUnlockNotify
);
3116 pDb
->pUnlockNotify
= 0;
3120 xNotify
= DbUnlockNotify
;
3121 pNotifyArg
= (void *)pDb
;
3122 pDb
->pUnlockNotify
= objv
[2];
3123 Tcl_IncrRefCount(pDb
->pUnlockNotify
);
3126 if( sqlite3_unlock_notify(pDb
->db
, xNotify
, pNotifyArg
) ){
3127 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
3136 ** $db preupdate_hook count
3137 ** $db preupdate_hook hook ?SCRIPT?
3138 ** $db preupdate_hook new INDEX
3139 ** $db preupdate_hook old INDEX
3141 case DB_PREUPDATE
: {
3142 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
3143 Tcl_AppendResult(interp
, "preupdate_hook was omitted at compile-time",
3147 static const char *azSub
[] = {"count", "depth", "hook", "new", "old", 0};
3148 enum DbPreupdateSubCmd
{
3149 PRE_COUNT
, PRE_DEPTH
, PRE_HOOK
, PRE_NEW
, PRE_OLD
3154 Tcl_WrongNumArgs(interp
, 2, objv
, "SUB-COMMAND ?ARGS?");
3156 if( Tcl_GetIndexFromObj(interp
, objv
[2], azSub
, "sub-command", 0, &iSub
) ){
3160 switch( (enum DbPreupdateSubCmd
)iSub
){
3162 int nCol
= sqlite3_preupdate_count(pDb
->db
);
3163 Tcl_SetObjResult(interp
, Tcl_NewIntObj(nCol
));
3169 Tcl_WrongNumArgs(interp
, 2, objv
, "hook ?SCRIPT?");
3172 DbHookCmd(interp
, pDb
, (objc
==4 ? objv
[3] : 0), &pDb
->pPreUpdateHook
);
3179 Tcl_WrongNumArgs(interp
, 3, objv
, "");
3182 pRet
= Tcl_NewIntObj(sqlite3_preupdate_depth(pDb
->db
));
3183 Tcl_SetObjResult(interp
, pRet
);
3190 sqlite3_value
*pValue
;
3192 Tcl_WrongNumArgs(interp
, 3, objv
, "INDEX");
3195 if( Tcl_GetIntFromObj(interp
, objv
[3], &iIdx
) ){
3199 if( iSub
==PRE_OLD
){
3200 rc
= sqlite3_preupdate_old(pDb
->db
, iIdx
, &pValue
);
3202 assert( iSub
==PRE_NEW
);
3203 rc
= sqlite3_preupdate_new(pDb
->db
, iIdx
, &pValue
);
3206 if( rc
==SQLITE_OK
){
3208 pObj
= Tcl_NewStringObj((char*)sqlite3_value_text(pValue
), -1);
3209 Tcl_SetObjResult(interp
, pObj
);
3211 Tcl_AppendResult(interp
, sqlite3_errmsg(pDb
->db
), (char*)0);
3216 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
3221 ** $db wal_hook ?script?
3222 ** $db update_hook ?script?
3223 ** $db rollback_hook ?script?
3226 case DB_UPDATE_HOOK
:
3227 case DB_ROLLBACK_HOOK
: {
3228 /* set ppHook to point at pUpdateHook or pRollbackHook, depending on
3229 ** whether [$db update_hook] or [$db rollback_hook] was invoked.
3231 Tcl_Obj
**ppHook
= 0;
3232 if( choice
==DB_WAL_HOOK
) ppHook
= &pDb
->pWalHook
;
3233 if( choice
==DB_UPDATE_HOOK
) ppHook
= &pDb
->pUpdateHook
;
3234 if( choice
==DB_ROLLBACK_HOOK
) ppHook
= &pDb
->pRollbackHook
;
3236 Tcl_WrongNumArgs(interp
, 2, objv
, "?SCRIPT?");
3240 DbHookCmd(interp
, pDb
, (objc
==3 ? objv
[2] : 0), ppHook
);
3246 ** Return the version string for this database.
3249 Tcl_SetResult(interp
, (char *)sqlite3_libversion(), TCL_STATIC
);
3254 } /* End of the SWITCH statement */
3260 ** Adaptor that provides an objCmd interface to the NRE-enabled
3261 ** interface implementation.
3263 static int SQLITE_TCLAPI
DbObjCmdAdaptor(
3269 return Tcl_NRCallObjProc(interp
, DbObjCmd
, cd
, objc
, objv
);
3271 #endif /* SQLITE_TCL_NRE */
3274 ** sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?
3275 ** ?-create BOOLEAN? ?-nomutex BOOLEAN?
3277 ** This is the main Tcl command. When the "sqlite" Tcl command is
3278 ** invoked, this routine runs to process that command.
3280 ** The first argument, DBNAME, is an arbitrary name for a new
3281 ** database connection. This command creates a new command named
3282 ** DBNAME that is used to control that connection. The database
3283 ** connection is deleted when the DBNAME command is deleted.
3285 ** The second argument is the name of the database file.
3288 static int SQLITE_TCLAPI
DbMain(
3299 const char *zVfs
= 0;
3301 Tcl_DString translatedFilename
;
3302 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3308 /* In normal use, each TCL interpreter runs in a single thread. So
3309 ** by default, we can turn of mutexing on SQLite database connections.
3310 ** However, for testing purposes it is useful to have mutexes turned
3311 ** on. So, by default, mutexes default off. But if compiled with
3312 ** SQLITE_TCL_DEFAULT_FULLMUTEX then mutexes default on.
3314 #ifdef SQLITE_TCL_DEFAULT_FULLMUTEX
3315 flags
= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
| SQLITE_OPEN_FULLMUTEX
;
3317 flags
= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
| SQLITE_OPEN_NOMUTEX
;
3321 zArg
= Tcl_GetStringFromObj(objv
[1], 0);
3322 if( strcmp(zArg
,"-version")==0 ){
3323 Tcl_AppendResult(interp
,sqlite3_libversion(), (char*)0);
3326 if( strcmp(zArg
,"-sourceid")==0 ){
3327 Tcl_AppendResult(interp
,sqlite3_sourceid(), (char*)0);
3330 if( strcmp(zArg
,"-has-codec")==0 ){
3331 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3332 Tcl_AppendResult(interp
,"1",(char*)0);
3334 Tcl_AppendResult(interp
,"0",(char*)0);
3339 for(i
=3; i
+1<objc
; i
+=2){
3340 zArg
= Tcl_GetString(objv
[i
]);
3341 if( strcmp(zArg
,"-key")==0 ){
3342 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3343 pKey
= Tcl_GetByteArrayFromObj(objv
[i
+1], &nKey
);
3345 }else if( strcmp(zArg
, "-vfs")==0 ){
3346 zVfs
= Tcl_GetString(objv
[i
+1]);
3347 }else if( strcmp(zArg
, "-readonly")==0 ){
3349 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3351 flags
&= ~(SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
);
3352 flags
|= SQLITE_OPEN_READONLY
;
3354 flags
&= ~SQLITE_OPEN_READONLY
;
3355 flags
|= SQLITE_OPEN_READWRITE
;
3357 }else if( strcmp(zArg
, "-create")==0 ){
3359 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3360 if( b
&& (flags
& SQLITE_OPEN_READONLY
)==0 ){
3361 flags
|= SQLITE_OPEN_CREATE
;
3363 flags
&= ~SQLITE_OPEN_CREATE
;
3365 }else if( strcmp(zArg
, "-nomutex")==0 ){
3367 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3369 flags
|= SQLITE_OPEN_NOMUTEX
;
3370 flags
&= ~SQLITE_OPEN_FULLMUTEX
;
3372 flags
&= ~SQLITE_OPEN_NOMUTEX
;
3374 }else if( strcmp(zArg
, "-fullmutex")==0 ){
3376 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3378 flags
|= SQLITE_OPEN_FULLMUTEX
;
3379 flags
&= ~SQLITE_OPEN_NOMUTEX
;
3381 flags
&= ~SQLITE_OPEN_FULLMUTEX
;
3383 }else if( strcmp(zArg
, "-uri")==0 ){
3385 if( Tcl_GetBooleanFromObj(interp
, objv
[i
+1], &b
) ) return TCL_ERROR
;
3387 flags
|= SQLITE_OPEN_URI
;
3389 flags
&= ~SQLITE_OPEN_URI
;
3392 Tcl_AppendResult(interp
, "unknown option: ", zArg
, (char*)0);
3396 if( objc
<3 || (objc
&1)!=1 ){
3397 Tcl_WrongNumArgs(interp
, 1, objv
,
3398 "HANDLE FILENAME ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"
3399 " ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN? ?-uri BOOLEAN?"
3400 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3407 p
= (SqliteDb
*)Tcl_Alloc( sizeof(*p
) );
3408 memset(p
, 0, sizeof(*p
));
3409 zFile
= Tcl_GetStringFromObj(objv
[2], 0);
3410 zFile
= Tcl_TranslateFileName(interp
, zFile
, &translatedFilename
);
3411 rc
= sqlite3_open_v2(zFile
, &p
->db
, flags
, zVfs
);
3412 Tcl_DStringFree(&translatedFilename
);
3414 if( SQLITE_OK
!=sqlite3_errcode(p
->db
) ){
3415 zErrMsg
= sqlite3_mprintf("%s", sqlite3_errmsg(p
->db
));
3416 sqlite3_close(p
->db
);
3420 zErrMsg
= sqlite3_mprintf("%s", sqlite3_errstr(rc
));
3422 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
3424 sqlite3_key(p
->db
, pKey
, nKey
);
3428 Tcl_SetResult(interp
, zErrMsg
, TCL_VOLATILE
);
3430 sqlite3_free(zErrMsg
);
3433 p
->maxStmt
= NUM_PREPARED_STMTS
;
3434 p
->openFlags
= flags
& SQLITE_OPEN_URI
;
3436 zArg
= Tcl_GetStringFromObj(objv
[1], 0);
3438 Tcl_NRCreateCommand(interp
, zArg
, DbObjCmdAdaptor
, DbObjCmd
,
3439 (char*)p
, DbDeleteCmd
);
3441 Tcl_CreateObjCommand(interp
, zArg
, DbObjCmd
, (char*)p
, DbDeleteCmd
);
3447 ** Provide a dummy Tcl_InitStubs if we are using this as a static
3450 #ifndef USE_TCL_STUBS
3451 # undef Tcl_InitStubs
3452 # define Tcl_InitStubs(a,b,c) TCL_VERSION
3456 ** Make sure we have a PACKAGE_VERSION macro defined. This will be
3457 ** defined automatically by the TEA makefile. But other makefiles
3458 ** do not define it.
3460 #ifndef PACKAGE_VERSION
3461 # define PACKAGE_VERSION SQLITE_VERSION
3465 ** Initialize this module.
3467 ** This Tcl module contains only a single new Tcl command named "sqlite".
3468 ** (Hence there is no namespace. There is no point in using a namespace
3469 ** if the extension only supplies one new name!) The "sqlite" command is
3470 ** used to open a new SQLite database. See the DbMain() routine above
3471 ** for additional information.
3473 ** The EXTERN macros are required by TCL in order to work on windows.
3475 EXTERN
int Sqlite3_Init(Tcl_Interp
*interp
){
3476 int rc
= Tcl_InitStubs(interp
, "8.4", 0) ? TCL_OK
: TCL_ERROR
;
3478 Tcl_CreateObjCommand(interp
, "sqlite3", (Tcl_ObjCmdProc
*)DbMain
, 0, 0);
3479 #ifndef SQLITE_3_SUFFIX_ONLY
3480 /* The "sqlite" alias is undocumented. It is here only to support
3481 ** legacy scripts. All new scripts should use only the "sqlite3"
3483 Tcl_CreateObjCommand(interp
, "sqlite", (Tcl_ObjCmdProc
*)DbMain
, 0, 0);
3485 rc
= Tcl_PkgProvide(interp
, "sqlite3", PACKAGE_VERSION
);
3489 EXTERN
int Tclsqlite3_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
3490 EXTERN
int Sqlite3_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3491 EXTERN
int Tclsqlite3_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3493 /* Because it accesses the file-system and uses persistent state, SQLite
3494 ** is not considered appropriate for safe interpreters. Hence, we cause
3495 ** the _SafeInit() interfaces return TCL_ERROR.
3497 EXTERN
int Sqlite3_SafeInit(Tcl_Interp
*interp
){ return TCL_ERROR
; }
3498 EXTERN
int Sqlite3_SafeUnload(Tcl_Interp
*interp
, int flags
){return TCL_ERROR
;}
3502 #ifndef SQLITE_3_SUFFIX_ONLY
3503 int Sqlite_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
3504 int Tclsqlite_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
3505 int Sqlite_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3506 int Tclsqlite_Unload(Tcl_Interp
*interp
, int flags
){ return TCL_OK
; }
3510 /*****************************************************************************
3511 ** All of the code that follows is used to build standalone TCL interpreters
3512 ** that are statically linked with SQLite. Enable these by compiling
3513 ** with -DTCLSH=n where n can be 1 or 2. An n of 1 generates a standard
3514 ** tclsh but with SQLite built in. An n of 2 generates the SQLite space
3515 ** analysis program.
3518 #if defined(SQLITE_TEST) || defined(SQLITE_TCLMD5)
3520 * This code implements the MD5 message-digest algorithm.
3521 * The algorithm is due to Ron Rivest. This code was
3522 * written by Colin Plumb in 1993, no copyright is claimed.
3523 * This code is in the public domain; do with it what you wish.
3525 * Equivalent code is available from RSA Data Security, Inc.
3526 * This code has been tested against that, and is equivalent,
3527 * except that you don't need to include two pages of legalese
3530 * To compute the message digest of a chunk of bytes, declare an
3531 * MD5Context structure, pass it to MD5Init, call MD5Update as
3532 * needed on buffers full of bytes, and then call MD5Final, which
3533 * will fill a supplied 16-byte array with the digest.
3537 * If compiled on a machine that doesn't have a 32-bit integer,
3538 * you just set "uint32" to the appropriate datatype for an
3539 * unsigned 32-bit integer. For example:
3541 * cc -Duint32='unsigned long' md5.c
3545 # define uint32 unsigned int
3552 unsigned char in
[64];
3554 typedef struct MD5Context MD5Context
;
3557 * Note: this code is harmless on little-endian machines.
3559 static void byteReverse (unsigned char *buf
, unsigned longs
){
3562 t
= (uint32
)((unsigned)buf
[3]<<8 | buf
[2]) << 16 |
3563 ((unsigned)buf
[1]<<8 | buf
[0]);
3568 /* The four core functions - F1 is optimized somewhat */
3570 /* #define F1(x, y, z) (x & y | ~x & z) */
3571 #define F1(x, y, z) (z ^ (x & (y ^ z)))
3572 #define F2(x, y, z) F1(z, x, y)
3573 #define F3(x, y, z) (x ^ y ^ z)
3574 #define F4(x, y, z) (y ^ (x | ~z))
3576 /* This is the central step in the MD5 algorithm. */
3577 #define MD5STEP(f, w, x, y, z, data, s) \
3578 ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
3581 * The core of the MD5 algorithm, this alters an existing MD5 hash to
3582 * reflect the addition of 16 longwords of new data. MD5Update blocks
3583 * the data and converts bytes into longwords for this routine.
3585 static void MD5Transform(uint32 buf
[4], const uint32 in
[16]){
3586 register uint32 a
, b
, c
, d
;
3593 MD5STEP(F1
, a
, b
, c
, d
, in
[ 0]+0xd76aa478, 7);
3594 MD5STEP(F1
, d
, a
, b
, c
, in
[ 1]+0xe8c7b756, 12);
3595 MD5STEP(F1
, c
, d
, a
, b
, in
[ 2]+0x242070db, 17);
3596 MD5STEP(F1
, b
, c
, d
, a
, in
[ 3]+0xc1bdceee, 22);
3597 MD5STEP(F1
, a
, b
, c
, d
, in
[ 4]+0xf57c0faf, 7);
3598 MD5STEP(F1
, d
, a
, b
, c
, in
[ 5]+0x4787c62a, 12);
3599 MD5STEP(F1
, c
, d
, a
, b
, in
[ 6]+0xa8304613, 17);
3600 MD5STEP(F1
, b
, c
, d
, a
, in
[ 7]+0xfd469501, 22);
3601 MD5STEP(F1
, a
, b
, c
, d
, in
[ 8]+0x698098d8, 7);
3602 MD5STEP(F1
, d
, a
, b
, c
, in
[ 9]+0x8b44f7af, 12);
3603 MD5STEP(F1
, c
, d
, a
, b
, in
[10]+0xffff5bb1, 17);
3604 MD5STEP(F1
, b
, c
, d
, a
, in
[11]+0x895cd7be, 22);
3605 MD5STEP(F1
, a
, b
, c
, d
, in
[12]+0x6b901122, 7);
3606 MD5STEP(F1
, d
, a
, b
, c
, in
[13]+0xfd987193, 12);
3607 MD5STEP(F1
, c
, d
, a
, b
, in
[14]+0xa679438e, 17);
3608 MD5STEP(F1
, b
, c
, d
, a
, in
[15]+0x49b40821, 22);
3610 MD5STEP(F2
, a
, b
, c
, d
, in
[ 1]+0xf61e2562, 5);
3611 MD5STEP(F2
, d
, a
, b
, c
, in
[ 6]+0xc040b340, 9);
3612 MD5STEP(F2
, c
, d
, a
, b
, in
[11]+0x265e5a51, 14);
3613 MD5STEP(F2
, b
, c
, d
, a
, in
[ 0]+0xe9b6c7aa, 20);
3614 MD5STEP(F2
, a
, b
, c
, d
, in
[ 5]+0xd62f105d, 5);
3615 MD5STEP(F2
, d
, a
, b
, c
, in
[10]+0x02441453, 9);
3616 MD5STEP(F2
, c
, d
, a
, b
, in
[15]+0xd8a1e681, 14);
3617 MD5STEP(F2
, b
, c
, d
, a
, in
[ 4]+0xe7d3fbc8, 20);
3618 MD5STEP(F2
, a
, b
, c
, d
, in
[ 9]+0x21e1cde6, 5);
3619 MD5STEP(F2
, d
, a
, b
, c
, in
[14]+0xc33707d6, 9);
3620 MD5STEP(F2
, c
, d
, a
, b
, in
[ 3]+0xf4d50d87, 14);
3621 MD5STEP(F2
, b
, c
, d
, a
, in
[ 8]+0x455a14ed, 20);
3622 MD5STEP(F2
, a
, b
, c
, d
, in
[13]+0xa9e3e905, 5);
3623 MD5STEP(F2
, d
, a
, b
, c
, in
[ 2]+0xfcefa3f8, 9);
3624 MD5STEP(F2
, c
, d
, a
, b
, in
[ 7]+0x676f02d9, 14);
3625 MD5STEP(F2
, b
, c
, d
, a
, in
[12]+0x8d2a4c8a, 20);
3627 MD5STEP(F3
, a
, b
, c
, d
, in
[ 5]+0xfffa3942, 4);
3628 MD5STEP(F3
, d
, a
, b
, c
, in
[ 8]+0x8771f681, 11);
3629 MD5STEP(F3
, c
, d
, a
, b
, in
[11]+0x6d9d6122, 16);
3630 MD5STEP(F3
, b
, c
, d
, a
, in
[14]+0xfde5380c, 23);
3631 MD5STEP(F3
, a
, b
, c
, d
, in
[ 1]+0xa4beea44, 4);
3632 MD5STEP(F3
, d
, a
, b
, c
, in
[ 4]+0x4bdecfa9, 11);
3633 MD5STEP(F3
, c
, d
, a
, b
, in
[ 7]+0xf6bb4b60, 16);
3634 MD5STEP(F3
, b
, c
, d
, a
, in
[10]+0xbebfbc70, 23);
3635 MD5STEP(F3
, a
, b
, c
, d
, in
[13]+0x289b7ec6, 4);
3636 MD5STEP(F3
, d
, a
, b
, c
, in
[ 0]+0xeaa127fa, 11);
3637 MD5STEP(F3
, c
, d
, a
, b
, in
[ 3]+0xd4ef3085, 16);
3638 MD5STEP(F3
, b
, c
, d
, a
, in
[ 6]+0x04881d05, 23);
3639 MD5STEP(F3
, a
, b
, c
, d
, in
[ 9]+0xd9d4d039, 4);
3640 MD5STEP(F3
, d
, a
, b
, c
, in
[12]+0xe6db99e5, 11);
3641 MD5STEP(F3
, c
, d
, a
, b
, in
[15]+0x1fa27cf8, 16);
3642 MD5STEP(F3
, b
, c
, d
, a
, in
[ 2]+0xc4ac5665, 23);
3644 MD5STEP(F4
, a
, b
, c
, d
, in
[ 0]+0xf4292244, 6);
3645 MD5STEP(F4
, d
, a
, b
, c
, in
[ 7]+0x432aff97, 10);
3646 MD5STEP(F4
, c
, d
, a
, b
, in
[14]+0xab9423a7, 15);
3647 MD5STEP(F4
, b
, c
, d
, a
, in
[ 5]+0xfc93a039, 21);
3648 MD5STEP(F4
, a
, b
, c
, d
, in
[12]+0x655b59c3, 6);
3649 MD5STEP(F4
, d
, a
, b
, c
, in
[ 3]+0x8f0ccc92, 10);
3650 MD5STEP(F4
, c
, d
, a
, b
, in
[10]+0xffeff47d, 15);
3651 MD5STEP(F4
, b
, c
, d
, a
, in
[ 1]+0x85845dd1, 21);
3652 MD5STEP(F4
, a
, b
, c
, d
, in
[ 8]+0x6fa87e4f, 6);
3653 MD5STEP(F4
, d
, a
, b
, c
, in
[15]+0xfe2ce6e0, 10);
3654 MD5STEP(F4
, c
, d
, a
, b
, in
[ 6]+0xa3014314, 15);
3655 MD5STEP(F4
, b
, c
, d
, a
, in
[13]+0x4e0811a1, 21);
3656 MD5STEP(F4
, a
, b
, c
, d
, in
[ 4]+0xf7537e82, 6);
3657 MD5STEP(F4
, d
, a
, b
, c
, in
[11]+0xbd3af235, 10);
3658 MD5STEP(F4
, c
, d
, a
, b
, in
[ 2]+0x2ad7d2bb, 15);
3659 MD5STEP(F4
, b
, c
, d
, a
, in
[ 9]+0xeb86d391, 21);
3668 * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
3669 * initialization constants.
3671 static void MD5Init(MD5Context
*ctx
){
3673 ctx
->buf
[0] = 0x67452301;
3674 ctx
->buf
[1] = 0xefcdab89;
3675 ctx
->buf
[2] = 0x98badcfe;
3676 ctx
->buf
[3] = 0x10325476;
3682 * Update context to reflect the concatenation of another buffer full
3686 void MD5Update(MD5Context
*ctx
, const unsigned char *buf
, unsigned int len
){
3689 /* Update bitcount */
3692 if ((ctx
->bits
[0] = t
+ ((uint32
)len
<< 3)) < t
)
3693 ctx
->bits
[1]++; /* Carry from low to high */
3694 ctx
->bits
[1] += len
>> 29;
3696 t
= (t
>> 3) & 0x3f; /* Bytes already in shsInfo->data */
3698 /* Handle any leading odd-sized chunks */
3701 unsigned char *p
= (unsigned char *)ctx
->in
+ t
;
3705 memcpy(p
, buf
, len
);
3709 byteReverse(ctx
->in
, 16);
3710 MD5Transform(ctx
->buf
, (uint32
*)ctx
->in
);
3715 /* Process data in 64-byte chunks */
3718 memcpy(ctx
->in
, buf
, 64);
3719 byteReverse(ctx
->in
, 16);
3720 MD5Transform(ctx
->buf
, (uint32
*)ctx
->in
);
3725 /* Handle any remaining bytes of data. */
3727 memcpy(ctx
->in
, buf
, len
);
3731 * Final wrapup - pad to 64-byte boundary with the bit pattern
3732 * 1 0* (64-bit count of bits processed, MSB-first)
3734 static void MD5Final(unsigned char digest
[16], MD5Context
*ctx
){
3738 /* Compute number of bytes mod 64 */
3739 count
= (ctx
->bits
[0] >> 3) & 0x3F;
3741 /* Set the first char of padding to 0x80. This is safe since there is
3742 always at least one byte free */
3743 p
= ctx
->in
+ count
;
3746 /* Bytes of padding needed to make 64 bytes */
3747 count
= 64 - 1 - count
;
3749 /* Pad out to 56 mod 64 */
3751 /* Two lots of padding: Pad the first block to 64 bytes */
3752 memset(p
, 0, count
);
3753 byteReverse(ctx
->in
, 16);
3754 MD5Transform(ctx
->buf
, (uint32
*)ctx
->in
);
3756 /* Now fill the next block with 56 bytes */
3757 memset(ctx
->in
, 0, 56);
3759 /* Pad block to 56 bytes */
3760 memset(p
, 0, count
-8);
3762 byteReverse(ctx
->in
, 14);
3764 /* Append length in bits and transform */
3765 memcpy(ctx
->in
+ 14*4, ctx
->bits
, 8);
3767 MD5Transform(ctx
->buf
, (uint32
*)ctx
->in
);
3768 byteReverse((unsigned char *)ctx
->buf
, 4);
3769 memcpy(digest
, ctx
->buf
, 16);
3773 ** Convert a 128-bit MD5 digest into a 32-digit base-16 number.
3775 static void MD5DigestToBase16(unsigned char *digest
, char *zBuf
){
3776 static char const zEncode
[] = "0123456789abcdef";
3779 for(j
=i
=0; i
<16; i
++){
3781 zBuf
[j
++] = zEncode
[(a
>>4)&0xf];
3782 zBuf
[j
++] = zEncode
[a
& 0xf];
3789 ** Convert a 128-bit MD5 digest into sequency of eight 5-digit integers
3790 ** each representing 16 bits of the digest and separated from each
3791 ** other by a "-" character.
3793 static void MD5DigestToBase10x8(unsigned char digest
[16], char zDigest
[50]){
3796 for(i
=j
=0; i
<16; i
+=2){
3797 x
= digest
[i
]*256 + digest
[i
+1];
3798 if( i
>0 ) zDigest
[j
++] = '-';
3799 sqlite3_snprintf(50-j
, &zDigest
[j
], "%05u", x
);
3806 ** A TCL command for md5. The argument is the text to be hashed. The
3807 ** Result is the hash in base64.
3809 static int SQLITE_TCLAPI
md5_cmd(
3816 unsigned char digest
[16];
3818 void (*converter
)(unsigned char*, char*);
3821 Tcl_AppendResult(interp
,"wrong # args: should be \"", argv
[0],
3822 " TEXT\"", (char*)0);
3826 MD5Update(&ctx
, (unsigned char*)argv
[1], (unsigned)strlen(argv
[1]));
3827 MD5Final(digest
, &ctx
);
3828 converter
= (void(*)(unsigned char*,char*))cd
;
3829 converter(digest
, zBuf
);
3830 Tcl_AppendResult(interp
, zBuf
, (char*)0);
3835 ** A TCL command to take the md5 hash of a file. The argument is the
3836 ** name of the file.
3838 static int SQLITE_TCLAPI
md5file_cmd(
3846 void (*converter
)(unsigned char*, char*);
3847 unsigned char digest
[16];
3851 Tcl_AppendResult(interp
,"wrong # args: should be \"", argv
[0],
3852 " FILENAME\"", (char*)0);
3855 in
= fopen(argv
[1],"rb");
3857 Tcl_AppendResult(interp
,"unable to open file \"", argv
[1],
3858 "\" for reading", (char*)0);
3864 n
= (int)fread(zBuf
, 1, sizeof(zBuf
), in
);
3866 MD5Update(&ctx
, (unsigned char*)zBuf
, (unsigned)n
);
3869 MD5Final(digest
, &ctx
);
3870 converter
= (void(*)(unsigned char*,char*))cd
;
3871 converter(digest
, zBuf
);
3872 Tcl_AppendResult(interp
, zBuf
, (char*)0);
3877 ** Register the four new TCL commands for generating MD5 checksums
3878 ** with the TCL interpreter.
3880 int Md5_Init(Tcl_Interp
*interp
){
3881 Tcl_CreateCommand(interp
, "md5", (Tcl_CmdProc
*)md5_cmd
,
3882 MD5DigestToBase16
, 0);
3883 Tcl_CreateCommand(interp
, "md5-10x8", (Tcl_CmdProc
*)md5_cmd
,
3884 MD5DigestToBase10x8
, 0);
3885 Tcl_CreateCommand(interp
, "md5file", (Tcl_CmdProc
*)md5file_cmd
,
3886 MD5DigestToBase16
, 0);
3887 Tcl_CreateCommand(interp
, "md5file-10x8", (Tcl_CmdProc
*)md5file_cmd
,
3888 MD5DigestToBase10x8
, 0);
3891 #endif /* defined(SQLITE_TEST) || defined(SQLITE_TCLMD5) */
3893 #if defined(SQLITE_TEST)
3895 ** During testing, the special md5sum() aggregate function is available.
3896 ** inside SQLite. The following routines implement that function.
3898 static void md5step(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
3901 if( argc
<1 ) return;
3902 p
= sqlite3_aggregate_context(context
, sizeof(*p
));
3907 for(i
=0; i
<argc
; i
++){
3908 const char *zData
= (char*)sqlite3_value_text(argv
[i
]);
3910 MD5Update(p
, (unsigned char*)zData
, (int)strlen(zData
));
3914 static void md5finalize(sqlite3_context
*context
){
3916 unsigned char digest
[16];
3918 p
= sqlite3_aggregate_context(context
, sizeof(*p
));
3920 MD5DigestToBase16(digest
, zBuf
);
3921 sqlite3_result_text(context
, zBuf
, -1, SQLITE_TRANSIENT
);
3926 const sqlite3_api_routines
*pThunk
3928 int rc
= sqlite3_create_function(db
, "md5sum", -1, SQLITE_UTF8
, 0, 0,
3929 md5step
, md5finalize
);
3930 sqlite3_overload_function(db
, "md5sum", -1); /* To exercise this API */
3933 #endif /* defined(SQLITE_TEST) */
3937 ** If the macro TCLSH is one, then put in code this for the
3938 ** "main" routine that will initialize Tcl and take input from
3939 ** standard input, or if a file is named on the command line
3940 ** the TCL interpreter reads and evaluates that file.
3943 static const char *tclsh_main_loop(void){
3944 static const char zMainloop
[] =
3946 "while {![eof stdin]} {\n"
3947 "if {$line!=\"\"} {\n"
3948 "puts -nonewline \"> \"\n"
3950 "puts -nonewline \"% \"\n"
3953 "append line [gets stdin]\n"
3954 "if {[info complete $line]} {\n"
3955 "if {[catch {uplevel #0 $line} result]} {\n"
3956 "puts stderr \"Error: $result\"\n"
3957 "} elseif {$result!=\"\"} {\n"
3970 static const char *tclsh_main_loop(void);
3974 static void init_all(Tcl_Interp
*);
3975 static int SQLITE_TCLAPI
init_all_cmd(
3979 Tcl_Obj
*CONST objv
[]
3984 Tcl_WrongNumArgs(interp
, 1, objv
, "SLAVE");
3988 slave
= Tcl_GetSlave(interp
, Tcl_GetString(objv
[1]));
3998 ** Tclcmd: db_use_legacy_prepare DB BOOLEAN
4000 ** The first argument to this command must be a database command created by
4001 ** [sqlite3]. If the second argument is true, then the handle is configured
4002 ** to use the sqlite3_prepare_v2() function to prepare statements. If it
4003 ** is false, sqlite3_prepare().
4005 static int SQLITE_TCLAPI
db_use_legacy_prepare_cmd(
4009 Tcl_Obj
*CONST objv
[]
4011 Tcl_CmdInfo cmdInfo
;
4016 Tcl_WrongNumArgs(interp
, 1, objv
, "DB BOOLEAN");
4020 if( !Tcl_GetCommandInfo(interp
, Tcl_GetString(objv
[1]), &cmdInfo
) ){
4021 Tcl_AppendResult(interp
, "no such db: ", Tcl_GetString(objv
[1]), (char*)0);
4024 pDb
= (SqliteDb
*)cmdInfo
.objClientData
;
4025 if( Tcl_GetBooleanFromObj(interp
, objv
[2], &bPrepare
) ){
4029 pDb
->bLegacyPrepare
= bPrepare
;
4031 Tcl_ResetResult(interp
);
4036 ** Tclcmd: db_last_stmt_ptr DB
4038 ** If the statement cache associated with database DB is not empty,
4039 ** return the text representation of the most recently used statement
4042 static int SQLITE_TCLAPI
db_last_stmt_ptr(
4046 Tcl_Obj
*CONST objv
[]
4048 extern int sqlite3TestMakePointerStr(Tcl_Interp
*, char*, void*);
4049 Tcl_CmdInfo cmdInfo
;
4051 sqlite3_stmt
*pStmt
= 0;
4055 Tcl_WrongNumArgs(interp
, 1, objv
, "DB");
4059 if( !Tcl_GetCommandInfo(interp
, Tcl_GetString(objv
[1]), &cmdInfo
) ){
4060 Tcl_AppendResult(interp
, "no such db: ", Tcl_GetString(objv
[1]), (char*)0);
4063 pDb
= (SqliteDb
*)cmdInfo
.objClientData
;
4065 if( pDb
->stmtList
) pStmt
= pDb
->stmtList
->pStmt
;
4066 if( sqlite3TestMakePointerStr(interp
, zBuf
, pStmt
) ){
4069 Tcl_SetResult(interp
, zBuf
, TCL_VOLATILE
);
4073 #endif /* SQLITE_TEST */
4076 ** Configure the interpreter passed as the first argument to have access
4077 ** to the commands and linked variables that make up:
4079 ** * the [sqlite3] extension itself,
4081 ** * If SQLITE_TCLMD5 or SQLITE_TEST is defined, the Md5 commands, and
4083 ** * If SQLITE_TEST is set, the various test interfaces used by the Tcl
4086 static void init_all(Tcl_Interp
*interp
){
4087 Sqlite3_Init(interp
);
4089 #if defined(SQLITE_TEST) || defined(SQLITE_TCLMD5)
4095 extern int Sqliteconfig_Init(Tcl_Interp
*);
4096 extern int Sqlitetest1_Init(Tcl_Interp
*);
4097 extern int Sqlitetest2_Init(Tcl_Interp
*);
4098 extern int Sqlitetest3_Init(Tcl_Interp
*);
4099 extern int Sqlitetest4_Init(Tcl_Interp
*);
4100 extern int Sqlitetest5_Init(Tcl_Interp
*);
4101 extern int Sqlitetest6_Init(Tcl_Interp
*);
4102 extern int Sqlitetest7_Init(Tcl_Interp
*);
4103 extern int Sqlitetest8_Init(Tcl_Interp
*);
4104 extern int Sqlitetest9_Init(Tcl_Interp
*);
4105 extern int Sqlitetestasync_Init(Tcl_Interp
*);
4106 extern int Sqlitetest_autoext_Init(Tcl_Interp
*);
4107 extern int Sqlitetest_blob_Init(Tcl_Interp
*);
4108 extern int Sqlitetest_demovfs_Init(Tcl_Interp
*);
4109 extern int Sqlitetest_func_Init(Tcl_Interp
*);
4110 extern int Sqlitetest_hexio_Init(Tcl_Interp
*);
4111 extern int Sqlitetest_init_Init(Tcl_Interp
*);
4112 extern int Sqlitetest_malloc_Init(Tcl_Interp
*);
4113 extern int Sqlitetest_mutex_Init(Tcl_Interp
*);
4114 extern int Sqlitetestschema_Init(Tcl_Interp
*);
4115 extern int Sqlitetestsse_Init(Tcl_Interp
*);
4116 extern int Sqlitetesttclvar_Init(Tcl_Interp
*);
4117 extern int Sqlitetestfs_Init(Tcl_Interp
*);
4118 extern int SqlitetestThread_Init(Tcl_Interp
*);
4119 extern int SqlitetestOnefile_Init();
4120 extern int SqlitetestOsinst_Init(Tcl_Interp
*);
4121 extern int Sqlitetestbackup_Init(Tcl_Interp
*);
4122 extern int Sqlitetestintarray_Init(Tcl_Interp
*);
4123 extern int Sqlitetestvfs_Init(Tcl_Interp
*);
4124 extern int Sqlitetestrtree_Init(Tcl_Interp
*);
4125 extern int Sqlitequota_Init(Tcl_Interp
*);
4126 extern int Sqlitemultiplex_Init(Tcl_Interp
*);
4127 extern int SqliteSuperlock_Init(Tcl_Interp
*);
4128 extern int SqlitetestSyscall_Init(Tcl_Interp
*);
4129 #if defined(SQLITE_ENABLE_SESSION) && defined(SQLITE_ENABLE_PREUPDATE_HOOK)
4130 extern int TestSession_Init(Tcl_Interp
*);
4132 extern int Fts5tcl_Init(Tcl_Interp
*);
4133 extern int SqliteRbu_Init(Tcl_Interp
*);
4134 extern int Sqlitetesttcl_Init(Tcl_Interp
*);
4135 #if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
4136 extern int Sqlitetestfts3_Init(Tcl_Interp
*interp
);
4139 #ifdef SQLITE_ENABLE_ZIPVFS
4140 extern int Zipvfs_Init(Tcl_Interp
*);
4141 Zipvfs_Init(interp
);
4144 Sqliteconfig_Init(interp
);
4145 Sqlitetest1_Init(interp
);
4146 Sqlitetest2_Init(interp
);
4147 Sqlitetest3_Init(interp
);
4148 Sqlitetest4_Init(interp
);
4149 Sqlitetest5_Init(interp
);
4150 Sqlitetest6_Init(interp
);
4151 Sqlitetest7_Init(interp
);
4152 Sqlitetest8_Init(interp
);
4153 Sqlitetest9_Init(interp
);
4154 Sqlitetestasync_Init(interp
);
4155 Sqlitetest_autoext_Init(interp
);
4156 Sqlitetest_blob_Init(interp
);
4157 Sqlitetest_demovfs_Init(interp
);
4158 Sqlitetest_func_Init(interp
);
4159 Sqlitetest_hexio_Init(interp
);
4160 Sqlitetest_init_Init(interp
);
4161 Sqlitetest_malloc_Init(interp
);
4162 Sqlitetest_mutex_Init(interp
);
4163 Sqlitetestschema_Init(interp
);
4164 Sqlitetesttclvar_Init(interp
);
4165 Sqlitetestfs_Init(interp
);
4166 SqlitetestThread_Init(interp
);
4167 SqlitetestOnefile_Init();
4168 SqlitetestOsinst_Init(interp
);
4169 Sqlitetestbackup_Init(interp
);
4170 Sqlitetestintarray_Init(interp
);
4171 Sqlitetestvfs_Init(interp
);
4172 Sqlitetestrtree_Init(interp
);
4173 Sqlitequota_Init(interp
);
4174 Sqlitemultiplex_Init(interp
);
4175 SqliteSuperlock_Init(interp
);
4176 SqlitetestSyscall_Init(interp
);
4177 #if defined(SQLITE_ENABLE_SESSION) && defined(SQLITE_ENABLE_PREUPDATE_HOOK)
4178 TestSession_Init(interp
);
4180 Fts5tcl_Init(interp
);
4181 SqliteRbu_Init(interp
);
4182 Sqlitetesttcl_Init(interp
);
4184 #if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
4185 Sqlitetestfts3_Init(interp
);
4188 Tcl_CreateObjCommand(
4189 interp
, "load_testfixture_extensions", init_all_cmd
, 0, 0
4191 Tcl_CreateObjCommand(
4192 interp
, "db_use_legacy_prepare", db_use_legacy_prepare_cmd
, 0, 0
4194 Tcl_CreateObjCommand(
4195 interp
, "db_last_stmt_ptr", db_last_stmt_ptr
, 0, 0
4199 Sqlitetestsse_Init(interp
);
4205 /* Needed for the setrlimit() system call on unix */
4207 #include <sys/resource.h>
4210 #define TCLSH_MAIN main /* Needed to fake out mktclapp */
4211 int SQLITE_CDECL
TCLSH_MAIN(int argc
, char **argv
){
4214 #if !defined(_WIN32_WCE)
4215 if( getenv("BREAK") ){
4217 "attach debugger to process %d and press any key to continue.\n",
4223 /* Since the primary use case for this binary is testing of SQLite,
4224 ** be sure to generate core files if we crash */
4225 #if defined(SQLITE_TEST) && defined(unix)
4227 getrlimit(RLIMIT_CORE
, &x
);
4228 x
.rlim_cur
= x
.rlim_max
;
4229 setrlimit(RLIMIT_CORE
, &x
);
4231 #endif /* SQLITE_TEST && unix */
4234 /* Call sqlite3_shutdown() once before doing anything else. This is to
4235 ** test that sqlite3_shutdown() can be safely called by a process before
4236 ** sqlite3_initialize() is. */
4239 Tcl_FindExecutable(argv
[0]);
4240 Tcl_SetSystemEncoding(NULL
, "utf-8");
4241 interp
= Tcl_CreateInterp();
4244 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD
);
4251 sqlite3_snprintf(sizeof(zArgc
), zArgc
, "%d", argc
-(3-TCLSH
));
4252 Tcl_SetVar(interp
,"argc", zArgc
, TCL_GLOBAL_ONLY
);
4253 Tcl_SetVar(interp
,"argv0",argv
[1],TCL_GLOBAL_ONLY
);
4254 Tcl_SetVar(interp
,"argv", "", TCL_GLOBAL_ONLY
);
4255 for(i
=3-TCLSH
; i
<argc
; i
++){
4256 Tcl_SetVar(interp
, "argv", argv
[i
],
4257 TCL_GLOBAL_ONLY
| TCL_LIST_ELEMENT
| TCL_APPEND_VALUE
);
4259 if( TCLSH
==1 && Tcl_EvalFile(interp
, argv
[1])!=TCL_OK
){
4260 const char *zInfo
= Tcl_GetVar(interp
, "errorInfo", TCL_GLOBAL_ONLY
);
4261 if( zInfo
==0 ) zInfo
= Tcl_GetStringResult(interp
);
4262 fprintf(stderr
,"%s: %s\n", *argv
, zInfo
);
4266 if( TCLSH
==2 || argc
<=1 ){
4267 Tcl_GlobalEval(interp
, tclsh_main_loop());