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
16 #ifndef NO_TCL /* Omit this whole file if TCL is unavailable */
18 #include "sqliteInt.h"
25 #define NUM_PREPARED_STMTS 10
26 #define MAX_PREPARED_STMTS 100
29 ** If TCL uses UTF-8 and SQLite is configured to use iso8859, then we
30 ** have to do a translation when going between the two. Set the
31 ** UTF_TRANSLATION_NEEDED macro to indicate that we need to do
34 #if defined(TCL_UTF_MAX) && !defined(SQLITE_UTF8)
35 # define UTF_TRANSLATION_NEEDED 1
39 ** New SQL functions can be created as TCL scripts. Each such function
40 ** is described by an instance of the following structure.
42 typedef struct SqlFunc SqlFunc
;
44 Tcl_Interp
*interp
; /* The TCL interpret to execute the function */
45 char *zScript
; /* The script to be run */
46 SqlFunc
*pNext
; /* Next function on the list of them all */
50 ** New collation sequences function can be created as TCL scripts. Each such
51 ** function is described by an instance of the following structure.
53 typedef struct SqlCollate SqlCollate
;
55 Tcl_Interp
*interp
; /* The TCL interpret to execute the function */
56 char *zScript
; /* The script to be run */
57 SqlCollate
*pNext
; /* Next function on the list of them all */
61 ** Prepared statements are cached for faster execution. Each prepared
62 ** statement is described by an instance of the following structure.
64 typedef struct SqlPreparedStmt SqlPreparedStmt
;
65 struct SqlPreparedStmt
{
66 SqlPreparedStmt
*pNext
; /* Next in linked list */
67 SqlPreparedStmt
*pPrev
; /* Previous on the list */
68 sqlite3_stmt
*pStmt
; /* The prepared statement */
69 int nSql
; /* chars in zSql[] */
70 char zSql
[1]; /* Text of the SQL statement */
74 ** There is one instance of this structure for each SQLite database
75 ** that has been opened by the SQLite TCL interface.
77 typedef struct SqliteDb SqliteDb
;
79 sqlite3
*db
; /* The "real" database structure */
80 Tcl_Interp
*interp
; /* The interpreter used for this database */
81 char *zBusy
; /* The busy callback routine */
82 char *zCommit
; /* The commit hook callback routine */
83 char *zTrace
; /* The trace callback routine */
84 char *zProgress
; /* The progress callback routine */
85 char *zAuth
; /* The authorization callback routine */
86 char *zNull
; /* Text to substitute for an SQL NULL value */
87 SqlFunc
*pFunc
; /* List of SQL functions */
88 SqlCollate
*pCollate
; /* List of SQL collation functions */
89 int rc
; /* Return code of most recent sqlite3_exec() */
90 Tcl_Obj
*pCollateNeeded
; /* Collation needed script */
91 SqlPreparedStmt
*stmtList
; /* List of prepared statements*/
92 SqlPreparedStmt
*stmtLast
; /* Last statement in the list */
93 int maxStmt
; /* The next maximum number of stmtList */
94 int nStmt
; /* Number of statements in stmtList */
98 ** Finalize and free a list of prepared statements
100 static void flushStmtCache( SqliteDb
*pDb
){
101 SqlPreparedStmt
*pPreStmt
;
103 while( pDb
->stmtList
){
104 sqlite3_finalize( pDb
->stmtList
->pStmt
);
105 pPreStmt
= pDb
->stmtList
;
106 pDb
->stmtList
= pDb
->stmtList
->pNext
;
107 Tcl_Free( (char*)pPreStmt
);
114 ** TCL calls this procedure when an sqlite3 database command is
117 static void DbDeleteCmd(void *db
){
118 SqliteDb
*pDb
= (SqliteDb
*)db
;
120 sqlite3_close(pDb
->db
);
122 SqlFunc
*pFunc
= pDb
->pFunc
;
123 pDb
->pFunc
= pFunc
->pNext
;
124 Tcl_Free((char*)pFunc
);
126 while( pDb
->pCollate
){
127 SqlCollate
*pCollate
= pDb
->pCollate
;
128 pDb
->pCollate
= pCollate
->pNext
;
129 Tcl_Free((char*)pCollate
);
132 Tcl_Free(pDb
->zBusy
);
135 Tcl_Free(pDb
->zTrace
);
138 Tcl_Free(pDb
->zAuth
);
141 Tcl_Free(pDb
->zNull
);
143 Tcl_Free((char*)pDb
);
147 ** This routine is called when a database file is locked while trying
150 static int DbBusyHandler(void *cd
, int nTries
){
151 SqliteDb
*pDb
= (SqliteDb
*)cd
;
157 Tcl_DStringInit(&cmd
);
158 Tcl_DStringAppend(&cmd
, pDb
->zBusy
, -1);
159 sprintf(zVal
, "%d", nTries
);
160 Tcl_DStringAppendElement(&cmd
, zVal
);
161 zCmd
= Tcl_DStringValue(&cmd
);
162 rc
= Tcl_Eval(pDb
->interp
, zCmd
);
163 Tcl_DStringFree(&cmd
);
164 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
171 ** This routine is invoked as the 'progress callback' for the database.
173 static int DbProgressHandler(void *cd
){
174 SqliteDb
*pDb
= (SqliteDb
*)cd
;
177 assert( pDb
->zProgress
);
178 rc
= Tcl_Eval(pDb
->interp
, pDb
->zProgress
);
179 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
186 ** This routine is called by the SQLite trace handler whenever a new
187 ** block of SQL is executed. The TCL script in pDb->zTrace is executed.
189 static void DbTraceHandler(void *cd
, const char *zSql
){
190 SqliteDb
*pDb
= (SqliteDb
*)cd
;
193 Tcl_DStringInit(&str
);
194 Tcl_DStringAppend(&str
, pDb
->zTrace
, -1);
195 Tcl_DStringAppendElement(&str
, zSql
);
196 Tcl_Eval(pDb
->interp
, Tcl_DStringValue(&str
));
197 Tcl_DStringFree(&str
);
198 Tcl_ResetResult(pDb
->interp
);
202 ** This routine is called when a transaction is committed. The
203 ** TCL script in pDb->zCommit is executed. If it returns non-zero or
204 ** if it throws an exception, the transaction is rolled back instead
205 ** of being committed.
207 static int DbCommitHandler(void *cd
){
208 SqliteDb
*pDb
= (SqliteDb
*)cd
;
211 rc
= Tcl_Eval(pDb
->interp
, pDb
->zCommit
);
212 if( rc
!=TCL_OK
|| atoi(Tcl_GetStringResult(pDb
->interp
)) ){
218 static void tclCollateNeeded(
224 SqliteDb
*pDb
= (SqliteDb
*)pCtx
;
225 Tcl_Obj
*pScript
= Tcl_DuplicateObj(pDb
->pCollateNeeded
);
226 Tcl_IncrRefCount(pScript
);
227 Tcl_ListObjAppendElement(0, pScript
, Tcl_NewStringObj(zName
, -1));
228 Tcl_EvalObjEx(pDb
->interp
, pScript
, 0);
229 Tcl_DecrRefCount(pScript
);
233 ** This routine is called to evaluate an SQL collation function implemented
236 static int tclSqlCollate(
243 SqlCollate
*p
= (SqlCollate
*)pCtx
;
246 pCmd
= Tcl_NewStringObj(p
->zScript
, -1);
247 Tcl_IncrRefCount(pCmd
);
248 Tcl_ListObjAppendElement(p
->interp
, pCmd
, Tcl_NewStringObj(zA
, nA
));
249 Tcl_ListObjAppendElement(p
->interp
, pCmd
, Tcl_NewStringObj(zB
, nB
));
250 Tcl_EvalObjEx(p
->interp
, pCmd
, 0);
251 Tcl_DecrRefCount(pCmd
);
252 return (atoi(Tcl_GetStringResult(p
->interp
)));
256 ** This routine is called to evaluate an SQL function implemented
259 static void tclSqlFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
260 SqlFunc
*p
= sqlite3_user_data(context
);
265 Tcl_DStringInit(&cmd
);
266 Tcl_DStringAppend(&cmd
, p
->zScript
, -1);
267 for(i
=0; i
<argc
; i
++){
268 if( SQLITE_NULL
==sqlite3_value_type(argv
[i
]) ){
269 Tcl_DStringAppendElement(&cmd
, "");
271 Tcl_DStringAppendElement(&cmd
, sqlite3_value_text(argv
[i
]));
274 rc
= Tcl_EvalEx(p
->interp
, Tcl_DStringValue(&cmd
), Tcl_DStringLength(&cmd
),
276 Tcl_DStringFree(&cmd
);
278 if( rc
&& rc
!=TCL_RETURN
){
279 sqlite3_result_error(context
, Tcl_GetStringResult(p
->interp
), -1);
281 Tcl_Obj
*pVar
= Tcl_GetObjResult(p
->interp
);
284 char *zType
= pVar
->typePtr
? pVar
->typePtr
->name
: "";
286 if( c
=='b' && strcmp(zType
,"bytearray")==0 ){
287 data
= Tcl_GetByteArrayFromObj(pVar
, &n
);
288 sqlite3_result_blob(context
, data
, n
, SQLITE_TRANSIENT
);
289 }else if( (c
=='b' && strcmp(zType
,"boolean")==0) ||
290 (c
=='i' && strcmp(zType
,"int")==0) ){
291 Tcl_GetIntFromObj(0, pVar
, &n
);
292 sqlite3_result_int(context
, n
);
293 }else if( c
=='d' && strcmp(zType
,"double")==0 ){
295 Tcl_GetDoubleFromObj(0, pVar
, &r
);
296 sqlite3_result_double(context
, r
);
298 data
= Tcl_GetStringFromObj(pVar
, &n
);
299 sqlite3_result_text(context
, data
, n
, SQLITE_TRANSIENT
);
304 #ifndef SQLITE_OMIT_AUTHORIZATION
306 ** This is the authentication function. It appends the authentication
307 ** type code and the two arguments to zCmd[] then invokes the result
308 ** on the interpreter. The reply is examined to determine if the
309 ** authentication fails or succeeds.
311 static int auth_callback(
323 SqliteDb
*pDb
= (SqliteDb
*)pArg
;
326 case SQLITE_COPY
: zCode
="SQLITE_COPY"; break;
327 case SQLITE_CREATE_INDEX
: zCode
="SQLITE_CREATE_INDEX"; break;
328 case SQLITE_CREATE_TABLE
: zCode
="SQLITE_CREATE_TABLE"; break;
329 case SQLITE_CREATE_TEMP_INDEX
: zCode
="SQLITE_CREATE_TEMP_INDEX"; break;
330 case SQLITE_CREATE_TEMP_TABLE
: zCode
="SQLITE_CREATE_TEMP_TABLE"; break;
331 case SQLITE_CREATE_TEMP_TRIGGER
: zCode
="SQLITE_CREATE_TEMP_TRIGGER"; break;
332 case SQLITE_CREATE_TEMP_VIEW
: zCode
="SQLITE_CREATE_TEMP_VIEW"; break;
333 case SQLITE_CREATE_TRIGGER
: zCode
="SQLITE_CREATE_TRIGGER"; break;
334 case SQLITE_CREATE_VIEW
: zCode
="SQLITE_CREATE_VIEW"; break;
335 case SQLITE_DELETE
: zCode
="SQLITE_DELETE"; break;
336 case SQLITE_DROP_INDEX
: zCode
="SQLITE_DROP_INDEX"; break;
337 case SQLITE_DROP_TABLE
: zCode
="SQLITE_DROP_TABLE"; break;
338 case SQLITE_DROP_TEMP_INDEX
: zCode
="SQLITE_DROP_TEMP_INDEX"; break;
339 case SQLITE_DROP_TEMP_TABLE
: zCode
="SQLITE_DROP_TEMP_TABLE"; break;
340 case SQLITE_DROP_TEMP_TRIGGER
: zCode
="SQLITE_DROP_TEMP_TRIGGER"; break;
341 case SQLITE_DROP_TEMP_VIEW
: zCode
="SQLITE_DROP_TEMP_VIEW"; break;
342 case SQLITE_DROP_TRIGGER
: zCode
="SQLITE_DROP_TRIGGER"; break;
343 case SQLITE_DROP_VIEW
: zCode
="SQLITE_DROP_VIEW"; break;
344 case SQLITE_INSERT
: zCode
="SQLITE_INSERT"; break;
345 case SQLITE_PRAGMA
: zCode
="SQLITE_PRAGMA"; break;
346 case SQLITE_READ
: zCode
="SQLITE_READ"; break;
347 case SQLITE_SELECT
: zCode
="SQLITE_SELECT"; break;
348 case SQLITE_TRANSACTION
: zCode
="SQLITE_TRANSACTION"; break;
349 case SQLITE_UPDATE
: zCode
="SQLITE_UPDATE"; break;
350 case SQLITE_ATTACH
: zCode
="SQLITE_ATTACH"; break;
351 case SQLITE_DETACH
: zCode
="SQLITE_DETACH"; break;
352 case SQLITE_ALTER_TABLE
: zCode
="SQLITE_ALTER_TABLE"; break;
353 case SQLITE_REINDEX
: zCode
="SQLITE_REINDEX"; break;
354 default : zCode
="????"; break;
356 Tcl_DStringInit(&str
);
357 Tcl_DStringAppend(&str
, pDb
->zAuth
, -1);
358 Tcl_DStringAppendElement(&str
, zCode
);
359 Tcl_DStringAppendElement(&str
, zArg1
? zArg1
: "");
360 Tcl_DStringAppendElement(&str
, zArg2
? zArg2
: "");
361 Tcl_DStringAppendElement(&str
, zArg3
? zArg3
: "");
362 Tcl_DStringAppendElement(&str
, zArg4
? zArg4
: "");
363 rc
= Tcl_GlobalEval(pDb
->interp
, Tcl_DStringValue(&str
));
364 Tcl_DStringFree(&str
);
365 zReply
= Tcl_GetStringResult(pDb
->interp
);
366 if( strcmp(zReply
,"SQLITE_OK")==0 ){
368 }else if( strcmp(zReply
,"SQLITE_DENY")==0 ){
370 }else if( strcmp(zReply
,"SQLITE_IGNORE")==0 ){
377 #endif /* SQLITE_OMIT_AUTHORIZATION */
380 ** zText is a pointer to text obtained via an sqlite3_result_text()
381 ** or similar interface. This routine returns a Tcl string object,
382 ** reference count set to 0, containing the text. If a translation
383 ** between iso8859 and UTF-8 is required, it is preformed.
385 static Tcl_Obj
*dbTextToObj(char const *zText
){
387 #ifdef UTF_TRANSLATION_NEEDED
389 Tcl_DStringInit(&dCol
);
390 Tcl_ExternalToUtfDString(NULL
, zText
, -1, &dCol
);
391 pVal
= Tcl_NewStringObj(Tcl_DStringValue(&dCol
), -1);
392 Tcl_DStringFree(&dCol
);
394 pVal
= Tcl_NewStringObj(zText
, -1);
400 ** This routine reads a line of text from FILE in, stores
401 ** the text in memory obtained from malloc() and returns a pointer
402 ** to the text. NULL is returned at end of file, or if malloc()
405 ** The interface is like "readline" but no command-line editing
408 ** copied from shell.c from '.import' command
410 static char *local_getline(char *zPrompt
, FILE *in
){
417 zLine
= malloc( nLine
);
418 if( zLine
==0 ) return 0;
423 nLine
= nLine
*2 + 100;
424 zLine
= realloc(zLine
, nLine
);
425 if( zLine
==0 ) return 0;
427 if( fgets(&zLine
[n
], nLine
- n
, in
)==0 ){
436 while( zLine
[n
] ){ n
++; }
437 if( n
>0 && zLine
[n
-1]=='\n' ){
443 zLine
= realloc( zLine
, n
+1 );
448 ** The "sqlite" command below creates a new Tcl command for each
449 ** connection it opens to an SQLite database. This routine is invoked
450 ** whenever one of those connection-specific commands is executed
451 ** in Tcl. For example, if you run Tcl code like this:
453 ** sqlite3 db1 "my_database"
456 ** The first command opens a connection to the "my_database" database
457 ** and calls that connection "db1". The second command causes this
458 ** subroutine to be invoked.
460 static int DbObjCmd(void *cd
, Tcl_Interp
*interp
, int objc
,Tcl_Obj
*const*objv
){
461 SqliteDb
*pDb
= (SqliteDb
*)cd
;
464 static const char *DB_strs
[] = {
465 "authorizer", "busy", "cache",
466 "changes", "close", "collate",
467 "collation_needed", "commit_hook", "complete",
468 "copy", "errorcode", "eval",
469 "function", "last_insert_rowid", "nullvalue",
470 "onecolumn", "progress", "rekey",
471 "timeout", "total_changes", "trace",
476 DB_AUTHORIZER
, DB_BUSY
, DB_CACHE
,
477 DB_CHANGES
, DB_CLOSE
, DB_COLLATE
,
478 DB_COLLATION_NEEDED
, DB_COMMIT_HOOK
, DB_COMPLETE
,
479 DB_COPY
, DB_ERRORCODE
, DB_EVAL
,
480 DB_FUNCTION
, DB_LAST_INSERT_ROWID
,DB_NULLVALUE
,
481 DB_ONECOLUMN
, DB_PROGRESS
, DB_REKEY
,
482 DB_TIMEOUT
, DB_TOTAL_CHANGES
, DB_TRACE
,
485 /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
488 Tcl_WrongNumArgs(interp
, 1, objv
, "SUBCOMMAND ...");
491 if( Tcl_GetIndexFromObj(interp
, objv
[1], DB_strs
, "option", 0, &choice
) ){
495 switch( (enum DB_enum
)choice
){
497 /* $db authorizer ?CALLBACK?
499 ** Invoke the given callback to authorize each SQL operation as it is
500 ** compiled. 5 arguments are appended to the callback before it is
503 ** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
504 ** (2) First descriptive name (depends on authorization type)
505 ** (3) Second descriptive name
506 ** (4) Name of the database (ex: "main", "temp")
507 ** (5) Name of trigger that is doing the access
509 ** The callback should return on of the following strings: SQLITE_OK,
510 ** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error.
512 ** If this method is invoked with no arguments, the current authorization
513 ** callback string is returned.
515 case DB_AUTHORIZER
: {
516 #ifdef SQLITE_OMIT_AUTHORIZATION
517 Tcl_AppendResult(interp
, "authorization not available in this build", 0);
521 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
525 Tcl_AppendResult(interp
, pDb
->zAuth
, 0);
531 Tcl_Free(pDb
->zAuth
);
533 zAuth
= Tcl_GetStringFromObj(objv
[2], &len
);
534 if( zAuth
&& len
>0 ){
535 pDb
->zAuth
= Tcl_Alloc( len
+ 1 );
536 strcpy(pDb
->zAuth
, zAuth
);
541 pDb
->interp
= interp
;
542 sqlite3_set_authorizer(pDb
->db
, auth_callback
, pDb
);
544 sqlite3_set_authorizer(pDb
->db
, 0, 0);
551 /* $db busy ?CALLBACK?
553 ** Invoke the given callback if an SQL statement attempts to open
554 ** a locked database file.
558 Tcl_WrongNumArgs(interp
, 2, objv
, "CALLBACK");
562 Tcl_AppendResult(interp
, pDb
->zBusy
, 0);
568 Tcl_Free(pDb
->zBusy
);
570 zBusy
= Tcl_GetStringFromObj(objv
[2], &len
);
571 if( zBusy
&& len
>0 ){
572 pDb
->zBusy
= Tcl_Alloc( len
+ 1 );
573 strcpy(pDb
->zBusy
, zBusy
);
578 pDb
->interp
= interp
;
579 sqlite3_busy_handler(pDb
->db
, DbBusyHandler
, pDb
);
581 sqlite3_busy_handler(pDb
->db
, 0, 0);
590 ** Flush the prepared statement cache, or set the maximum number of
591 ** cached statements.
598 Tcl_WrongNumArgs(interp
, 1, objv
, "cache option ?arg?");
601 subCmd
= Tcl_GetStringFromObj( objv
[2], 0 );
602 if( *subCmd
=='f' && strcmp(subCmd
,"flush")==0 ){
604 Tcl_WrongNumArgs(interp
, 2, objv
, "flush");
607 flushStmtCache( pDb
);
609 }else if( *subCmd
=='s' && strcmp(subCmd
,"size")==0 ){
611 Tcl_WrongNumArgs(interp
, 2, objv
, "size n");
614 if( TCL_ERROR
==Tcl_GetIntFromObj(interp
, objv
[3], &n
) ){
615 Tcl_AppendResult( interp
, "cannot convert \"",
616 Tcl_GetStringFromObj(objv
[3],0), "\" to integer", 0);
620 flushStmtCache( pDb
);
622 }else if( n
>MAX_PREPARED_STMTS
){
623 n
= MAX_PREPARED_STMTS
;
629 Tcl_AppendResult( interp
, "bad option \"",
630 Tcl_GetStringFromObj(objv
[0],0), "\": must be flush or size", 0);
638 ** Return the number of rows that were modified, inserted, or deleted by
639 ** the most recent INSERT, UPDATE or DELETE statement, not including
640 ** any changes made by trigger programs.
645 Tcl_WrongNumArgs(interp
, 2, objv
, "");
648 pResult
= Tcl_GetObjResult(interp
);
649 Tcl_SetIntObj(pResult
, sqlite3_changes(pDb
->db
));
655 ** Shutdown the database
658 Tcl_DeleteCommand(interp
, Tcl_GetStringFromObj(objv
[0], 0));
662 /* $db commit_hook ?CALLBACK?
664 ** Invoke the given callback just before committing every SQL transaction.
665 ** If the callback throws an exception or returns non-zero, then the
666 ** transaction is aborted. If CALLBACK is an empty string, the callback
669 case DB_COMMIT_HOOK
: {
671 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
675 Tcl_AppendResult(interp
, pDb
->zCommit
, 0);
681 Tcl_Free(pDb
->zCommit
);
683 zCommit
= Tcl_GetStringFromObj(objv
[2], &len
);
684 if( zCommit
&& len
>0 ){
685 pDb
->zCommit
= Tcl_Alloc( len
+ 1 );
686 strcpy(pDb
->zCommit
, zCommit
);
691 pDb
->interp
= interp
;
692 sqlite3_commit_hook(pDb
->db
, DbCommitHandler
, pDb
);
694 sqlite3_commit_hook(pDb
->db
, 0, 0);
701 ** $db collate NAME SCRIPT
703 ** Create a new SQL collation function called NAME. Whenever
704 ** that function is called, invoke SCRIPT to evaluate the function.
707 SqlCollate
*pCollate
;
712 Tcl_WrongNumArgs(interp
, 2, objv
, "NAME SCRIPT");
715 zName
= Tcl_GetStringFromObj(objv
[2], 0);
716 zScript
= Tcl_GetStringFromObj(objv
[3], &nScript
);
717 pCollate
= (SqlCollate
*)Tcl_Alloc( sizeof(*pCollate
) + nScript
+ 1 );
718 if( pCollate
==0 ) return TCL_ERROR
;
719 pCollate
->interp
= interp
;
720 pCollate
->pNext
= pDb
->pCollate
;
721 pCollate
->zScript
= (char*)&pCollate
[1];
722 pDb
->pCollate
= pCollate
;
723 strcpy(pCollate
->zScript
, zScript
);
724 if( sqlite3_create_collation(pDb
->db
, zName
, SQLITE_UTF8
,
725 pCollate
, tclSqlCollate
) ){
726 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
733 ** $db collation_needed SCRIPT
735 ** Create a new SQL collation function called NAME. Whenever
736 ** that function is called, invoke SCRIPT to evaluate the function.
738 case DB_COLLATION_NEEDED
: {
740 Tcl_WrongNumArgs(interp
, 2, objv
, "SCRIPT");
743 if( pDb
->pCollateNeeded
){
744 Tcl_DecrRefCount(pDb
->pCollateNeeded
);
746 pDb
->pCollateNeeded
= Tcl_DuplicateObj(objv
[2]);
747 Tcl_IncrRefCount(pDb
->pCollateNeeded
);
748 sqlite3_collation_needed(pDb
->db
, pDb
, tclCollateNeeded
);
754 ** Return TRUE if SQL is a complete SQL statement. Return FALSE if
755 ** additional lines of input are needed. This is similar to the
756 ** built-in "info complete" command of Tcl.
759 #ifndef SQLITE_OMIT_COMPLETE
763 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL");
766 isComplete
= sqlite3_complete( Tcl_GetStringFromObj(objv
[2], 0) );
767 pResult
= Tcl_GetObjResult(interp
);
768 Tcl_SetBooleanObj(pResult
, isComplete
);
776 ** Return the numeric error code that was returned by the most recent
777 ** call to sqlite3_exec().
780 Tcl_SetObjResult(interp
, Tcl_NewIntObj(sqlite3_errcode(pDb
->db
)));
785 ** $db eval $sql ?array? ?{ ...code... }?
786 ** $db onecolumn $sql
788 ** The SQL statement in $sql is evaluated. For each row, the values are
789 ** placed in elements of the array named "array" and ...code... is executed.
790 ** If "array" and "code" are omitted, then no callback is every invoked.
791 ** If "array" is an empty string, then the values are placed in variables
792 ** that have the same name as the fields extracted by the query.
794 ** The onecolumn method is the equivalent of:
795 ** lindex [$db eval $sql] 0
799 char const *zSql
; /* Next SQL statement to execute */
800 char const *zLeft
; /* What is left after first stmt in zSql */
801 sqlite3_stmt
*pStmt
; /* Compiled SQL statment */
802 Tcl_Obj
*pArray
; /* Name of array into which results are written */
803 Tcl_Obj
*pScript
; /* Script to run for each result set */
804 Tcl_Obj
**apParm
; /* Parameters that need a Tcl_DecrRefCount() */
805 int nParm
; /* Number of entries used in apParm[] */
806 Tcl_Obj
*aParm
[10]; /* Static space for apParm[] in the common case */
807 Tcl_Obj
*pRet
; /* Value to be returned */
808 SqlPreparedStmt
*pPreStmt
; /* Pointer to a prepared statement */
811 if( choice
==DB_ONECOLUMN
){
813 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL");
818 if( objc
<3 || objc
>5 ){
819 Tcl_WrongNumArgs(interp
, 2, objv
, "SQL ?ARRAY-NAME? ?SCRIPT?");
823 Tcl_IncrRefCount(pRet
);
826 pArray
= pScript
= 0;
832 if( Tcl_GetString(pArray
)[0]==0 ) pArray
= 0;
836 Tcl_IncrRefCount(objv
[2]);
837 zSql
= Tcl_GetStringFromObj(objv
[2], 0);
838 while( rc
==TCL_OK
&& zSql
[0] ){
839 int i
; /* Loop counter */
840 int nVar
; /* Number of bind parameters in the pStmt */
841 int nCol
; /* Number of columns in the result set */
842 Tcl_Obj
**apColName
= 0; /* Array of column names */
843 int len
; /* String length of zSql */
845 /* Try to find a SQL statement that has already been compiled and
846 ** which matches the next sequence of SQL.
849 pPreStmt
= pDb
->stmtList
;
851 if( pPreStmt
&& sqlite3_expired(pPreStmt
->pStmt
) ){
855 for(; pPreStmt
; pPreStmt
=pPreStmt
->pNext
){
856 int n
= pPreStmt
->nSql
;
858 && memcmp(pPreStmt
->zSql
, zSql
, n
)==0
859 && (zSql
[n
]==0 || zSql
[n
-1]==';')
861 pStmt
= pPreStmt
->pStmt
;
862 zLeft
= &zSql
[pPreStmt
->nSql
];
864 /* When a prepared statement is found, unlink it from the
865 ** cache list. It will later be added back to the beginning
866 ** of the cache list in order to implement LRU replacement.
868 if( pPreStmt
->pPrev
){
869 pPreStmt
->pPrev
->pNext
= pPreStmt
->pNext
;
871 pDb
->stmtList
= pPreStmt
->pNext
;
873 if( pPreStmt
->pNext
){
874 pPreStmt
->pNext
->pPrev
= pPreStmt
->pPrev
;
876 pDb
->stmtLast
= pPreStmt
->pPrev
;
883 /* If no prepared statement was found. Compile the SQL text
886 if( SQLITE_OK
!=sqlite3_prepare(pDb
->db
, zSql
, -1, &pStmt
, &zLeft
) ){
887 Tcl_SetObjResult(interp
, dbTextToObj(sqlite3_errmsg(pDb
->db
)));
892 if( SQLITE_OK
!=sqlite3_errcode(pDb
->db
) ){
893 /* A compile-time error in the statement
895 Tcl_SetObjResult(interp
, dbTextToObj(sqlite3_errmsg(pDb
->db
)));
899 /* The statement was a no-op. Continue to the next statement
900 ** in the SQL string.
906 assert( pPreStmt
==0 );
909 /* Bind values to parameters that begin with $ or :
911 nVar
= sqlite3_bind_parameter_count(pStmt
);
913 if( nVar
>sizeof(aParm
)/sizeof(aParm
[0]) ){
914 apParm
= (Tcl_Obj
**)Tcl_Alloc(nVar
*sizeof(apParm
[0]));
918 for(i
=1; i
<=nVar
; i
++){
919 const char *zVar
= sqlite3_bind_parameter_name(pStmt
, i
);
920 if( zVar
!=0 && (zVar
[0]=='$' || zVar
[0]==':') ){
921 Tcl_Obj
*pVar
= Tcl_GetVar2Ex(interp
, &zVar
[1], 0, 0);
925 char *zType
= pVar
->typePtr
? pVar
->typePtr
->name
: "";
927 if( c
=='b' && strcmp(zType
,"bytearray")==0 ){
928 data
= Tcl_GetByteArrayFromObj(pVar
, &n
);
929 sqlite3_bind_blob(pStmt
, i
, data
, n
, SQLITE_STATIC
);
930 Tcl_IncrRefCount(pVar
);
931 apParm
[nParm
++] = pVar
;
932 }else if( (c
=='b' && strcmp(zType
,"boolean")==0) ||
933 (c
=='i' && strcmp(zType
,"int")==0) ){
934 Tcl_GetIntFromObj(interp
, pVar
, &n
);
935 sqlite3_bind_int(pStmt
, i
, n
);
936 }else if( c
=='d' && strcmp(zType
,"double")==0 ){
938 Tcl_GetDoubleFromObj(interp
, pVar
, &r
);
939 sqlite3_bind_double(pStmt
, i
, r
);
941 data
= Tcl_GetStringFromObj(pVar
, &n
);
942 sqlite3_bind_text(pStmt
, i
, data
, n
, SQLITE_STATIC
);
943 Tcl_IncrRefCount(pVar
);
944 apParm
[nParm
++] = pVar
;
947 sqlite3_bind_null( pStmt
, i
);
952 /* Compute column names */
953 nCol
= sqlite3_column_count(pStmt
);
955 apColName
= (Tcl_Obj
**)Tcl_Alloc( sizeof(Tcl_Obj
*)*nCol
);
956 if( apColName
==0 ) break;
957 for(i
=0; i
<nCol
; i
++){
958 apColName
[i
] = dbTextToObj(sqlite3_column_name(pStmt
,i
));
959 Tcl_IncrRefCount(apColName
[i
]);
963 /* If results are being stored in an array variable, then create
964 ** the array(*) entry for that array
967 Tcl_Obj
*pColList
= Tcl_NewObj();
968 Tcl_Obj
*pStar
= Tcl_NewStringObj("*", -1);
969 Tcl_IncrRefCount(pColList
);
970 for(i
=0; i
<nCol
; i
++){
971 Tcl_ListObjAppendElement(interp
, pColList
, apColName
[i
]);
973 Tcl_ObjSetVar2(interp
, pArray
, pStar
, pColList
,0);
974 Tcl_DecrRefCount(pColList
);
975 Tcl_DecrRefCount(pStar
);
980 while( rc
==TCL_OK
&& pStmt
&& SQLITE_ROW
==sqlite3_step(pStmt
) ){
981 for(i
=0; i
<nCol
; i
++){
984 /* Set pVal to contain the i'th column of this row. */
985 switch( sqlite3_column_type(pStmt
, i
) ){
987 int bytes
= sqlite3_column_bytes(pStmt
, i
);
988 pVal
= Tcl_NewByteArrayObj(sqlite3_column_blob(pStmt
, i
), bytes
);
991 case SQLITE_INTEGER
: {
992 sqlite_int64 v
= sqlite3_column_int64(pStmt
, i
);
993 if( v
>=-2147483647 && v
<=2147483647 ){
994 pVal
= Tcl_NewIntObj(v
);
996 pVal
= Tcl_NewWideIntObj(v
);
1000 case SQLITE_FLOAT
: {
1001 double r
= sqlite3_column_double(pStmt
, i
);
1002 pVal
= Tcl_NewDoubleObj(r
);
1006 pVal
= dbTextToObj(pDb
->zNull
);
1010 pVal
= dbTextToObj(sqlite3_column_text(pStmt
, i
));
1017 Tcl_ObjSetVar2(interp
, apColName
[i
], 0, pVal
, 0);
1019 Tcl_ObjSetVar2(interp
, pArray
, apColName
[i
], pVal
, 0);
1021 }else if( choice
==DB_ONECOLUMN
){
1024 Tcl_IncrRefCount(pRet
);
1028 Tcl_ListObjAppendElement(interp
, pRet
, pVal
);
1033 rc
= Tcl_EvalObjEx(interp
, pScript
, 0);
1034 if( rc
==TCL_CONTINUE
){
1039 if( rc
==TCL_BREAK
){
1043 /* Free the column name objects */
1045 for(i
=0; i
<nCol
; i
++){
1046 Tcl_DecrRefCount(apColName
[i
]);
1048 Tcl_Free((char*)apColName
);
1051 /* Free the bound string and blob parameters */
1052 for(i
=0; i
<nParm
; i
++){
1053 Tcl_DecrRefCount(apParm
[i
]);
1055 if( apParm
!=aParm
){
1056 Tcl_Free((char*)apParm
);
1059 /* Reset the statement. If the result code is SQLITE_SCHEMA, then
1060 ** flush the statement cache and try the statement again.
1062 rc2
= sqlite3_reset(pStmt
);
1063 if( SQLITE_SCHEMA
==rc2
){
1064 /* After a schema change, flush the cache and try to run the
1067 flushStmtCache( pDb
);
1068 sqlite3_finalize(pStmt
);
1069 if( pPreStmt
) Tcl_Free((char*)pPreStmt
);
1071 }else if( SQLITE_OK
!=rc2
){
1072 /* If a run-time error occurs, report the error and stop reading
1075 Tcl_SetObjResult(interp
, dbTextToObj(sqlite3_errmsg(pDb
->db
)));
1076 sqlite3_finalize(pStmt
);
1078 if( pPreStmt
) Tcl_Free((char*)pPreStmt
);
1080 }else if( pDb
->maxStmt
<=0 ){
1081 /* If the cache is turned off, deallocated the statement */
1082 if( pPreStmt
) Tcl_Free((char*)pPreStmt
);
1083 sqlite3_finalize(pStmt
);
1085 /* Everything worked and the cache is operational.
1086 ** Create a new SqlPreparedStmt structure if we need one.
1087 ** (If we already have one we can just reuse it.)
1091 pPreStmt
= (SqlPreparedStmt
*)Tcl_Alloc( sizeof(*pPreStmt
) + len
);
1092 if( pPreStmt
==0 ) return TCL_ERROR
;
1093 pPreStmt
->pStmt
= pStmt
;
1094 pPreStmt
->nSql
= len
;
1095 memcpy(pPreStmt
->zSql
, zSql
, len
);
1096 pPreStmt
->zSql
[len
] = 0;
1099 /* Add the prepared statement to the beginning of the cache list
1101 pPreStmt
->pNext
= pDb
->stmtList
;
1102 pPreStmt
->pPrev
= 0;
1103 if( pDb
->stmtList
){
1104 pDb
->stmtList
->pPrev
= pPreStmt
;
1106 pDb
->stmtList
= pPreStmt
;
1107 if( pDb
->stmtLast
==0 ){
1108 assert( pDb
->nStmt
==0 );
1109 pDb
->stmtLast
= pPreStmt
;
1111 assert( pDb
->nStmt
>0 );
1115 /* If we have too many statement in cache, remove the surplus from the
1116 ** end of the cache list.
1118 while( pDb
->nStmt
>pDb
->maxStmt
){
1119 sqlite3_finalize(pDb
->stmtLast
->pStmt
);
1120 pDb
->stmtLast
= pDb
->stmtLast
->pPrev
;
1121 Tcl_Free((char*)pDb
->stmtLast
->pNext
);
1122 pDb
->stmtLast
->pNext
= 0;
1127 /* Proceed to the next statement */
1130 Tcl_DecrRefCount(objv
[2]);
1134 Tcl_SetObjResult(interp
, pRet
);
1136 Tcl_DecrRefCount(pRet
);
1142 ** $db function NAME SCRIPT
1144 ** Create a new SQL function called NAME. Whenever that function is
1145 ** called, invoke SCRIPT to evaluate the function.
1153 Tcl_WrongNumArgs(interp
, 2, objv
, "NAME SCRIPT");
1156 zName
= Tcl_GetStringFromObj(objv
[2], 0);
1157 zScript
= Tcl_GetStringFromObj(objv
[3], &nScript
);
1158 pFunc
= (SqlFunc
*)Tcl_Alloc( sizeof(*pFunc
) + nScript
+ 1 );
1159 if( pFunc
==0 ) return TCL_ERROR
;
1160 pFunc
->interp
= interp
;
1161 pFunc
->pNext
= pDb
->pFunc
;
1162 pFunc
->zScript
= (char*)&pFunc
[1];
1164 strcpy(pFunc
->zScript
, zScript
);
1165 rc
= sqlite3_create_function(pDb
->db
, zName
, -1, SQLITE_UTF8
,
1166 pFunc
, tclSqlFunc
, 0, 0);
1167 if( rc
!=SQLITE_OK
){
1169 Tcl_SetResult(interp
, (char *)sqlite3_errmsg(pDb
->db
), TCL_VOLATILE
);
1171 /* Must flush any cached statements */
1172 flushStmtCache( pDb
);
1178 ** $db last_insert_rowid
1180 ** Return an integer which is the ROWID for the most recent insert.
1182 case DB_LAST_INSERT_ROWID
: {
1186 Tcl_WrongNumArgs(interp
, 2, objv
, "");
1189 rowid
= sqlite3_last_insert_rowid(pDb
->db
);
1190 pResult
= Tcl_GetObjResult(interp
);
1191 Tcl_SetIntObj(pResult
, rowid
);
1196 ** The DB_ONECOLUMN method is implemented together with DB_EVAL.
1199 /* $db progress ?N CALLBACK?
1201 ** Invoke the given callback every N virtual machine opcodes while executing
1206 if( pDb
->zProgress
){
1207 Tcl_AppendResult(interp
, pDb
->zProgress
, 0);
1209 }else if( objc
==4 ){
1213 if( TCL_OK
!=Tcl_GetIntFromObj(interp
, objv
[2], &N
) ){
1216 if( pDb
->zProgress
){
1217 Tcl_Free(pDb
->zProgress
);
1219 zProgress
= Tcl_GetStringFromObj(objv
[3], &len
);
1220 if( zProgress
&& len
>0 ){
1221 pDb
->zProgress
= Tcl_Alloc( len
+ 1 );
1222 strcpy(pDb
->zProgress
, zProgress
);
1226 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1227 if( pDb
->zProgress
){
1228 pDb
->interp
= interp
;
1229 sqlite3_progress_handler(pDb
->db
, N
, DbProgressHandler
, pDb
);
1231 sqlite3_progress_handler(pDb
->db
, 0, 0, 0);
1235 Tcl_WrongNumArgs(interp
, 2, objv
, "N CALLBACK");
1244 ** Change the encryption key on the currently open database.
1250 Tcl_WrongNumArgs(interp
, 2, objv
, "KEY");
1253 pKey
= Tcl_GetByteArrayFromObj(objv
[2], &nKey
);
1254 #ifdef SQLITE_HAS_CODEC
1255 rc
= sqlite3_rekey(pDb
->db
, pKey
, nKey
);
1257 Tcl_AppendResult(interp
, sqlite3ErrStr(rc
), 0);
1265 ** $db timeout MILLESECONDS
1267 ** Delay for the number of milliseconds specified when a file is locked.
1272 Tcl_WrongNumArgs(interp
, 2, objv
, "MILLISECONDS");
1275 if( Tcl_GetIntFromObj(interp
, objv
[2], &ms
) ) return TCL_ERROR
;
1276 sqlite3_busy_timeout(pDb
->db
, ms
);
1281 ** $db nullvalue ?STRING?
1283 ** Change text used when a NULL comes back from the database. If ?STRING?
1284 ** is not present, then the current string used for NULL is returned.
1285 ** If STRING is present, then STRING is returned.
1288 case DB_NULLVALUE
: {
1289 if( objc
!=2 && objc
!=3 ){
1290 Tcl_WrongNumArgs(interp
, 2, objv
, "NULLVALUE");
1295 char *zNull
= Tcl_GetStringFromObj(objv
[2], &len
);
1297 Tcl_Free(pDb
->zNull
);
1299 if( zNull
&& len
>0 ){
1300 pDb
->zNull
= Tcl_Alloc( len
+ 1 );
1301 strncpy(pDb
->zNull
, zNull
, len
);
1302 pDb
->zNull
[len
] = '\0';
1307 Tcl_SetObjResult(interp
, dbTextToObj(pDb
->zNull
));
1312 ** $db total_changes
1314 ** Return the number of rows that were modified, inserted, or deleted
1315 ** since the database handle was created.
1317 case DB_TOTAL_CHANGES
: {
1320 Tcl_WrongNumArgs(interp
, 2, objv
, "");
1323 pResult
= Tcl_GetObjResult(interp
);
1324 Tcl_SetIntObj(pResult
, sqlite3_total_changes(pDb
->db
));
1328 /* $db trace ?CALLBACK?
1330 ** Make arrangements to invoke the CALLBACK routine for each SQL statement
1331 ** that is executed. The text of the SQL is appended to CALLBACK before
1336 Tcl_WrongNumArgs(interp
, 2, objv
, "?CALLBACK?");
1338 }else if( objc
==2 ){
1340 Tcl_AppendResult(interp
, pDb
->zTrace
, 0);
1346 Tcl_Free(pDb
->zTrace
);
1348 zTrace
= Tcl_GetStringFromObj(objv
[2], &len
);
1349 if( zTrace
&& len
>0 ){
1350 pDb
->zTrace
= Tcl_Alloc( len
+ 1 );
1351 strcpy(pDb
->zTrace
, zTrace
);
1356 pDb
->interp
= interp
;
1357 sqlite3_trace(pDb
->db
, DbTraceHandler
, pDb
);
1359 sqlite3_trace(pDb
->db
, 0, 0);
1365 /* $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
1367 ** Copy data into table from filename, optionally using SEPARATOR
1368 ** as column separators. If a column contains a null string, or the
1369 ** value of NULLINDICATOR, a NULL is inserted for the column.
1370 ** conflict-algorithm is one of the sqlite conflict algorithms:
1371 ** rollback, abort, fail, ignore, replace
1372 ** On success, return the number of lines processed, not necessarily same
1373 ** as 'db changes' due to conflict-algorithm selected.
1375 ** This code is basically an implementation/enhancement of
1376 ** the sqlite3 shell.c ".import" command.
1378 ** This command usage is equivalent to the sqlite2.x COPY statement,
1379 ** which imports file data into a table using the PostgreSQL COPY file format:
1380 ** $db copy $conflit_algo $table_name $filename \t \\N
1383 char *zTable
; /* Insert data into this table */
1384 char *zFile
; /* The file from which to extract data */
1385 char *zConflict
; /* The conflict algorithm to use */
1386 sqlite3_stmt
*pStmt
; /* A statement */
1387 int rc
; /* Result code */
1388 int nCol
; /* Number of columns in the table */
1389 int nByte
; /* Number of bytes in an SQL string */
1390 int i
, j
; /* Loop counters */
1391 int nSep
; /* Number of bytes in zSep[] */
1392 int nNull
; /* Number of bytes in zNull[] */
1393 char *zSql
; /* An SQL statement */
1394 char *zLine
; /* A single line of input from the file */
1395 char **azCol
; /* zLine[] broken up into columns */
1396 char *zCommit
; /* How to commit changes */
1397 FILE *in
; /* The input file */
1398 int lineno
= 0; /* Line number of input file */
1399 char zLineNum
[80]; /* Line number print buffer */
1400 Tcl_Obj
*pResult
; /* interp result */
1404 if( objc
<5 || objc
>7 ){
1405 Tcl_WrongNumArgs(interp
, 2, objv
,
1406 "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");
1410 zSep
= Tcl_GetStringFromObj(objv
[5], 0);
1415 zNull
= Tcl_GetStringFromObj(objv
[6], 0);
1419 zConflict
= Tcl_GetStringFromObj(objv
[2], 0);
1420 zTable
= Tcl_GetStringFromObj(objv
[3], 0);
1421 zFile
= Tcl_GetStringFromObj(objv
[4], 0);
1422 nSep
= strlen(zSep
);
1423 nNull
= strlen(zNull
);
1425 Tcl_AppendResult(interp
, "Error: non-null separator required for copy", 0);
1428 if(sqlite3StrICmp(zConflict
, "rollback") != 0 &&
1429 sqlite3StrICmp(zConflict
, "abort" ) != 0 &&
1430 sqlite3StrICmp(zConflict
, "fail" ) != 0 &&
1431 sqlite3StrICmp(zConflict
, "ignore" ) != 0 &&
1432 sqlite3StrICmp(zConflict
, "replace" ) != 0 ) {
1433 Tcl_AppendResult(interp
, "Error: \"", zConflict
,
1434 "\", conflict-algorithm must be one of: rollback, "
1435 "abort, fail, ignore, or replace", 0);
1438 zSql
= sqlite3_mprintf("SELECT * FROM '%q'", zTable
);
1440 Tcl_AppendResult(interp
, "Error: no such table: ", zTable
, 0);
1443 nByte
= strlen(zSql
);
1444 rc
= sqlite3_prepare(pDb
->db
, zSql
, 0, &pStmt
, 0);
1447 Tcl_AppendResult(interp
, "Error: ", sqlite3_errmsg(pDb
->db
), 0);
1450 nCol
= sqlite3_column_count(pStmt
);
1452 sqlite3_finalize(pStmt
);
1456 zSql
= malloc( nByte
+ 50 + nCol
*2 );
1458 Tcl_AppendResult(interp
, "Error: can't malloc()", 0);
1461 sqlite3_snprintf(nByte
+50, zSql
, "INSERT OR %q INTO '%q' VALUES(?",
1464 for(i
=1; i
<nCol
; i
++){
1470 rc
= sqlite3_prepare(pDb
->db
, zSql
, 0, &pStmt
, 0);
1473 Tcl_AppendResult(interp
, "Error: ", sqlite3_errmsg(pDb
->db
), 0);
1474 sqlite3_finalize(pStmt
);
1477 in
= fopen(zFile
, "rb");
1479 Tcl_AppendResult(interp
, "Error: cannot open file: ", zFile
, NULL
);
1480 sqlite3_finalize(pStmt
);
1483 azCol
= malloc( sizeof(azCol
[0])*(nCol
+1) );
1485 Tcl_AppendResult(interp
, "Error: can't malloc()", 0);
1488 sqlite3_exec(pDb
->db
, "BEGIN", 0, 0, 0);
1490 while( (zLine
= local_getline(0, in
))!=0 ){
1495 for(i
=0, z
=zLine
; *z
; z
++){
1496 if( *z
==zSep
[0] && strncmp(z
, zSep
, nSep
)==0 ){
1500 azCol
[i
] = &z
[nSep
];
1507 zErr
= malloc(200 + strlen(zFile
));
1508 sprintf(zErr
,"Error: %s line %d: expected %d columns of data but found %d",
1509 zFile
, lineno
, nCol
, i
+1);
1510 Tcl_AppendResult(interp
, zErr
, 0);
1512 zCommit
= "ROLLBACK";
1515 for(i
=0; i
<nCol
; i
++){
1516 /* check for null data, if so, bind as null */
1517 if ((nNull
>0 && strcmp(azCol
[i
], zNull
)==0) || strlen(azCol
[i
])==0) {
1518 sqlite3_bind_null(pStmt
, i
+1);
1520 sqlite3_bind_text(pStmt
, i
+1, azCol
[i
], -1, SQLITE_STATIC
);
1523 sqlite3_step(pStmt
);
1524 rc
= sqlite3_reset(pStmt
);
1526 if( rc
!=SQLITE_OK
){
1527 Tcl_AppendResult(interp
,"Error: ", sqlite3_errmsg(pDb
->db
), 0);
1528 zCommit
= "ROLLBACK";
1534 sqlite3_finalize(pStmt
);
1535 sqlite3_exec(pDb
->db
, zCommit
, 0, 0, 0);
1537 if( zCommit
[0] == 'C' ){
1538 /* success, set result as number of lines processed */
1539 pResult
= Tcl_GetObjResult(interp
);
1540 Tcl_SetIntObj(pResult
, lineno
);
1543 /* failure, append lineno where failed */
1544 sprintf(zLineNum
,"%d",lineno
);
1545 Tcl_AppendResult(interp
,", failed while processing line: ",zLineNum
,0);
1553 ** Return the version string for this database.
1556 Tcl_SetResult(interp
, (char *)sqlite3_libversion(), TCL_STATIC
);
1561 } /* End of the SWITCH statement */
1566 ** sqlite3 DBNAME FILENAME ?MODE? ?-key KEY?
1568 ** This is the main Tcl command. When the "sqlite" Tcl command is
1569 ** invoked, this routine runs to process that command.
1571 ** The first argument, DBNAME, is an arbitrary name for a new
1572 ** database connection. This command creates a new command named
1573 ** DBNAME that is used to control that connection. The database
1574 ** connection is deleted when the DBNAME command is deleted.
1576 ** The second argument is the name of the directory that contains
1577 ** the sqlite database that is to be accessed.
1579 ** For testing purposes, we also support the following:
1581 ** sqlite3 -encoding
1583 ** Return the encoding used by LIKE and GLOB operators. Choices
1584 ** are UTF-8 and iso8859.
1588 ** Return the version number of the SQLite library.
1590 ** sqlite3 -tcl-uses-utf
1592 ** Return "1" if compiled with a Tcl uses UTF-8. Return "0" if
1593 ** not. Used by tests to make sure the library was compiled
1596 static int DbMain(void *cd
, Tcl_Interp
*interp
, int objc
,Tcl_Obj
*const*objv
){
1605 zArg
= Tcl_GetStringFromObj(objv
[1], 0);
1606 if( strcmp(zArg
,"-version")==0 ){
1607 Tcl_AppendResult(interp
,sqlite3_version
,0);
1610 if( strcmp(zArg
,"-has-codec")==0 ){
1611 #ifdef SQLITE_HAS_CODEC
1612 Tcl_AppendResult(interp
,"1",0);
1614 Tcl_AppendResult(interp
,"0",0);
1618 if( strcmp(zArg
,"-tcl-uses-utf")==0 ){
1620 Tcl_AppendResult(interp
,"1",0);
1622 Tcl_AppendResult(interp
,"0",0);
1627 if( objc
==5 || objc
==6 ){
1628 zArg
= Tcl_GetStringFromObj(objv
[objc
-2], 0);
1629 if( strcmp(zArg
,"-key")==0 ){
1630 pKey
= Tcl_GetByteArrayFromObj(objv
[objc
-1], &nKey
);
1634 if( objc
!=3 && objc
!=4 ){
1635 Tcl_WrongNumArgs(interp
, 1, objv
,
1636 #ifdef SQLITE_HAS_CODEC
1637 "HANDLE FILENAME ?-key CODEC-KEY?"
1639 "HANDLE FILENAME ?MODE?"
1645 p
= (SqliteDb
*)Tcl_Alloc( sizeof(*p
) );
1647 Tcl_SetResult(interp
, "malloc failed", TCL_STATIC
);
1650 memset(p
, 0, sizeof(*p
));
1651 zFile
= Tcl_GetStringFromObj(objv
[2], 0);
1652 sqlite3_open(zFile
, &p
->db
);
1653 if( SQLITE_OK
!=sqlite3_errcode(p
->db
) ){
1654 zErrMsg
= strdup(sqlite3_errmsg(p
->db
));
1655 sqlite3_close(p
->db
);
1658 #ifdef SQLITE_HAS_CODEC
1659 sqlite3_key(p
->db
, pKey
, nKey
);
1662 Tcl_SetResult(interp
, zErrMsg
, TCL_VOLATILE
);
1667 p
->maxStmt
= NUM_PREPARED_STMTS
;
1668 zArg
= Tcl_GetStringFromObj(objv
[1], 0);
1669 Tcl_CreateObjCommand(interp
, zArg
, DbObjCmd
, (char*)p
, DbDeleteCmd
);
1671 /* The return value is the value of the sqlite* pointer
1673 sprintf(zBuf
, "%p", p
->db
);
1674 if( strncmp(zBuf
,"0x",2) ){
1675 sprintf(zBuf
, "0x%p", p
->db
);
1677 Tcl_AppendResult(interp
, zBuf
, 0);
1679 /* If compiled with SQLITE_TEST turned on, then register the "md5sum"
1684 extern void Md5_Register(sqlite3
*);
1685 #ifdef SQLITE_MEMDEBUG
1686 int mallocfail
= sqlite3_iMallocFail
;
1687 sqlite3_iMallocFail
= 0;
1689 Md5_Register(p
->db
);
1690 #ifdef SQLITE_MEMDEBUG
1691 sqlite3_iMallocFail
= mallocfail
;
1700 ** Provide a dummy Tcl_InitStubs if we are using this as a static
1703 #ifndef USE_TCL_STUBS
1704 # undef Tcl_InitStubs
1705 # define Tcl_InitStubs(a,b,c)
1709 ** Initialize this module.
1711 ** This Tcl module contains only a single new Tcl command named "sqlite".
1712 ** (Hence there is no namespace. There is no point in using a namespace
1713 ** if the extension only supplies one new name!) The "sqlite" command is
1714 ** used to open a new SQLite database. See the DbMain() routine above
1715 ** for additional information.
1717 int Sqlite3_Init(Tcl_Interp
*interp
){
1718 Tcl_InitStubs(interp
, "8.4", 0);
1719 Tcl_CreateObjCommand(interp
, "sqlite3", (Tcl_ObjCmdProc
*)DbMain
, 0, 0);
1720 Tcl_PkgProvide(interp
, "sqlite3", "3.0");
1721 Tcl_CreateObjCommand(interp
, "sqlite", (Tcl_ObjCmdProc
*)DbMain
, 0, 0);
1722 Tcl_PkgProvide(interp
, "sqlite", "3.0");
1725 int Tclsqlite3_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
1726 int Sqlite3_SafeInit(Tcl_Interp
*interp
){ return TCL_OK
; }
1727 int Tclsqlite3_SafeInit(Tcl_Interp
*interp
){ return TCL_OK
; }
1729 #ifndef SQLITE_3_SUFFIX_ONLY
1730 int Sqlite_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
1731 int Tclsqlite_Init(Tcl_Interp
*interp
){ return Sqlite3_Init(interp
); }
1732 int Sqlite_SafeInit(Tcl_Interp
*interp
){ return TCL_OK
; }
1733 int Tclsqlite_SafeInit(Tcl_Interp
*interp
){ return TCL_OK
; }
1737 /*****************************************************************************
1738 ** The code that follows is used to build standalone TCL interpreters
1742 ** If the macro TCLSH is one, then put in code this for the
1743 ** "main" routine that will initialize Tcl and take input from
1747 static char zMainloop
[] =
1749 "while {![eof stdin]} {\n"
1750 "if {$line!=\"\"} {\n"
1751 "puts -nonewline \"> \"\n"
1753 "puts -nonewline \"% \"\n"
1756 "append line [gets stdin]\n"
1757 "if {[info complete $line]} {\n"
1758 "if {[catch {uplevel #0 $line} result]} {\n"
1759 "puts stderr \"Error: $result\"\n"
1760 "} elseif {$result!=\"\"} {\n"
1772 ** If the macro TCLSH is two, then get the main loop code out of
1773 ** the separate file "spaceanal_tcl.h".
1776 static char zMainloop
[] =
1777 #include "spaceanal_tcl.h"
1781 #define TCLSH_MAIN main /* Needed to fake out mktclapp */
1782 int TCLSH_MAIN(int argc
, char **argv
){
1784 Tcl_FindExecutable(argv
[0]);
1785 interp
= Tcl_CreateInterp();
1786 Sqlite3_Init(interp
);
1789 extern int Sqlitetest1_Init(Tcl_Interp
*);
1790 extern int Sqlitetest2_Init(Tcl_Interp
*);
1791 extern int Sqlitetest3_Init(Tcl_Interp
*);
1792 extern int Sqlitetest4_Init(Tcl_Interp
*);
1793 extern int Sqlitetest5_Init(Tcl_Interp
*);
1794 extern int Md5_Init(Tcl_Interp
*);
1795 extern int Sqlitetestsse_Init(Tcl_Interp
*);
1797 Sqlitetest1_Init(interp
);
1798 Sqlitetest2_Init(interp
);
1799 Sqlitetest3_Init(interp
);
1800 Sqlitetest4_Init(interp
);
1801 Sqlitetest5_Init(interp
);
1804 Sqlitetestsse_Init(interp
);
1808 if( argc
>=2 || TCLSH
==2 ){
1810 Tcl_SetVar(interp
,"argv0",argv
[1],TCL_GLOBAL_ONLY
);
1811 Tcl_SetVar(interp
,"argv", "", TCL_GLOBAL_ONLY
);
1812 for(i
=3-TCLSH
; i
<argc
; i
++){
1813 Tcl_SetVar(interp
, "argv", argv
[i
],
1814 TCL_GLOBAL_ONLY
| TCL_LIST_ELEMENT
| TCL_APPEND_VALUE
);
1816 if( TCLSH
==1 && Tcl_EvalFile(interp
, argv
[1])!=TCL_OK
){
1817 const char *zInfo
= Tcl_GetVar(interp
, "errorInfo", TCL_GLOBAL_ONLY
);
1818 if( zInfo
==0 ) zInfo
= interp
->result
;
1819 fprintf(stderr
,"%s: %s\n", *argv
, zInfo
);
1823 if( argc
<=1 || TCLSH
==2 ){
1824 Tcl_GlobalEval(interp
, zMainloop
);
1830 #endif /* !defined(NO_TCL) */