1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** Code for testing all sorts of SQLite interfaces. This code
13 ** is not included in the SQLite library. It is used for automated
14 ** testing of the SQLite library.
15 */
16 #include "sqliteInt.h"
17 #if SQLITE_OS_WIN
18 # include "os_win.h"
19 #endif
20
21 #include "vdbeInt.h"
22 #if defined(INCLUDE_SQLITE_TCL_H)
23 # include "sqlite_tcl.h"
24 #else
25 # include "tcl.h"
26 #endif
27 #include <stdlib.h>
28 #include <string.h>
29
30 /*
31 ** This is a copy of the first part of the SqliteDb structure in
32 ** tclsqlite.c. We need it here so that the get_sqlite_pointer routine
33 ** can extract the sqlite3* pointer from an existing Tcl SQLite
34 ** connection.
35 */
36 struct SqliteDb {
37 sqlite3 *db;
38 };
39
40 /*
41 ** Convert text generated by the "%p" conversion format back into
42 ** a pointer.
43 */
testHexToInt(int h)44 static int testHexToInt(int h){
45 if( h>='0' && h<='9' ){
46 return h - '0';
47 }else if( h>='a' && h<='f' ){
48 return h - 'a' + 10;
49 }else{
50 assert( h>='A' && h<='F' );
51 return h - 'A' + 10;
52 }
53 }
sqlite3TestTextToPtr(const char * z)54 void *sqlite3TestTextToPtr(const char *z){
55 void *p;
56 u64 v;
57 u32 v2;
58 if( z[0]=='0' && z[1]=='x' ){
59 z += 2;
60 }
61 v = 0;
62 while( *z ){
63 v = (v<<4) + testHexToInt(*z);
64 z++;
65 }
66 if( sizeof(p)==sizeof(v) ){
67 memcpy(&p, &v, sizeof(p));
68 }else{
69 assert( sizeof(p)==sizeof(v2) );
70 v2 = (u32)v;
71 memcpy(&p, &v2, sizeof(p));
72 }
73 return p;
74 }
75
76
77 /*
78 ** A TCL command that returns the address of the sqlite* pointer
79 ** for an sqlite connection instance. Bad things happen if the
80 ** input is not an sqlite connection.
81 */
get_sqlite_pointer(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])82 static int SQLITE_TCLAPI get_sqlite_pointer(
83 void * clientData,
84 Tcl_Interp *interp,
85 int objc,
86 Tcl_Obj *CONST objv[]
87 ){
88 struct SqliteDb *p;
89 Tcl_CmdInfo cmdInfo;
90 char zBuf[100];
91 if( objc!=2 ){
92 Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION");
93 return TCL_ERROR;
94 }
95 if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
96 Tcl_AppendResult(interp, "command not found: ",
97 Tcl_GetString(objv[1]), (char*)0);
98 return TCL_ERROR;
99 }
100 p = (struct SqliteDb*)cmdInfo.objClientData;
101 sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", p->db);
102 Tcl_AppendResult(interp, zBuf, 0);
103 return TCL_OK;
104 }
105
106 /*
107 ** Decode a pointer to an sqlite3 object.
108 */
getDbPointer(Tcl_Interp * interp,const char * zA,sqlite3 ** ppDb)109 int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
110 struct SqliteDb *p;
111 Tcl_CmdInfo cmdInfo;
112 if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){
113 p = (struct SqliteDb*)cmdInfo.objClientData;
114 *ppDb = p->db;
115 }else{
116 *ppDb = (sqlite3*)sqlite3TestTextToPtr(zA);
117 }
118 return TCL_OK;
119 }
120
121 #if SQLITE_OS_WIN
122 /*
123 ** Decode a Win32 HANDLE object.
124 */
getWin32Handle(Tcl_Interp * interp,const char * zA,LPHANDLE phFile)125 int getWin32Handle(Tcl_Interp *interp, const char *zA, LPHANDLE phFile){
126 *phFile = (HANDLE)sqlite3TestTextToPtr(zA);
127 return TCL_OK;
128 }
129 #endif
130
131 extern const char *sqlite3ErrName(int);
132 #define t1ErrorName sqlite3ErrName
133
134 /*
135 ** Convert an sqlite3_stmt* into an sqlite3*. This depends on the
136 ** fact that the sqlite3* is the first field in the Vdbe structure.
137 */
138 #define StmtToDb(X) sqlite3_db_handle(X)
139
140 /*
141 ** Check a return value to make sure it agrees with the results
142 ** from sqlite3_errcode.
143 */
sqlite3TestErrCode(Tcl_Interp * interp,sqlite3 * db,int rc)144 int sqlite3TestErrCode(Tcl_Interp *interp, sqlite3 *db, int rc){
145 if( sqlite3_threadsafe()==0 && rc!=SQLITE_MISUSE && rc!=SQLITE_OK
146 && sqlite3_errcode(db)!=rc ){
147 char zBuf[200];
148 int r2 = sqlite3_errcode(db);
149 sqlite3_snprintf(sizeof(zBuf), zBuf,
150 "error code %s (%d) does not match sqlite3_errcode %s (%d)",
151 t1ErrorName(rc), rc, t1ErrorName(r2), r2);
152 Tcl_ResetResult(interp);
153 Tcl_AppendResult(interp, zBuf, 0);
154 return 1;
155 }
156 return 0;
157 }
158
159 /*
160 ** Decode a pointer to an sqlite3_stmt object.
161 */
getStmtPointer(Tcl_Interp * interp,const char * zArg,sqlite3_stmt ** ppStmt)162 static int getStmtPointer(
163 Tcl_Interp *interp,
164 const char *zArg,
165 sqlite3_stmt **ppStmt
166 ){
167 *ppStmt = (sqlite3_stmt*)sqlite3TestTextToPtr(zArg);
168 return TCL_OK;
169 }
170
171 /*
172 ** Generate a text representation of a pointer that can be understood
173 ** by the getDbPointer and getVmPointer routines above.
174 **
175 ** The problem is, on some machines (Solaris) if you do a printf with
176 ** "%p" you cannot turn around and do a scanf with the same "%p" and
177 ** get your pointer back. You have to prepend a "0x" before it will
178 ** work. Or at least that is what is reported to me (drh). But this
179 ** behavior varies from machine to machine. The solution used her is
180 ** to test the string right after it is generated to see if it can be
181 ** understood by scanf, and if not, try prepending an "0x" to see if
182 ** that helps. If nothing works, a fatal error is generated.
183 */
sqlite3TestMakePointerStr(Tcl_Interp * interp,char * zPtr,void * p)184 int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){
185 sqlite3_snprintf(100, zPtr, "%p", p);
186 return TCL_OK;
187 }
188
189 /*
190 ** The callback routine for sqlite3_exec_printf().
191 */
exec_printf_cb(void * pArg,int argc,char ** argv,char ** name)192 static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){
193 Tcl_DString *str = (Tcl_DString*)pArg;
194 int i;
195
196 if( Tcl_DStringLength(str)==0 ){
197 for(i=0; i<argc; i++){
198 Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL");
199 }
200 }
201 for(i=0; i<argc; i++){
202 Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL");
203 }
204 return 0;
205 }
206
207 /*
208 ** The I/O tracing callback.
209 */
210 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
211 static FILE *iotrace_file = 0;
io_trace_callback(const char * zFormat,...)212 static void io_trace_callback(const char *zFormat, ...){
213 va_list ap;
214 va_start(ap, zFormat);
215 vfprintf(iotrace_file, zFormat, ap);
216 va_end(ap);
217 fflush(iotrace_file);
218 }
219 #endif
220
221 /*
222 ** Usage: io_trace FILENAME
223 **
224 ** Turn I/O tracing on or off. If FILENAME is not an empty string,
225 ** I/O tracing begins going into FILENAME. If FILENAME is an empty
226 ** string, I/O tracing is turned off.
227 */
test_io_trace(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)228 static int SQLITE_TCLAPI test_io_trace(
229 void *NotUsed,
230 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
231 int argc, /* Number of arguments */
232 char **argv /* Text of each argument */
233 ){
234 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
235 if( argc!=2 ){
236 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
237 " FILENAME\"", 0);
238 return TCL_ERROR;
239 }
240 if( iotrace_file ){
241 if( iotrace_file!=stdout && iotrace_file!=stderr ){
242 fclose(iotrace_file);
243 }
244 iotrace_file = 0;
245 sqlite3IoTrace = 0;
246 }
247 if( argv[1][0] ){
248 if( strcmp(argv[1],"stdout")==0 ){
249 iotrace_file = stdout;
250 }else if( strcmp(argv[1],"stderr")==0 ){
251 iotrace_file = stderr;
252 }else{
253 iotrace_file = fopen(argv[1], "w");
254 }
255 sqlite3IoTrace = io_trace_callback;
256 }
257 #endif
258 return TCL_OK;
259 }
260
261 /*
262 ** Usage: clang_sanitize_address
263 **
264 ** Returns true if the program was compiled using clang with the
265 ** -fsanitize=address switch on the command line. False otherwise.
266 **
267 ** Also return true if the OMIT_MISUSE environment variable exists.
268 */
clang_sanitize_address(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)269 static int SQLITE_TCLAPI clang_sanitize_address(
270 void *NotUsed,
271 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
272 int argc, /* Number of arguments */
273 char **argv /* Text of each argument */
274 ){
275 int res = 0;
276 #if defined(__has_feature)
277 # if __has_feature(address_sanitizer)
278 res = 1;
279 # endif
280 #endif
281 #ifdef __SANITIZE_ADDRESS__
282 res = 1;
283 #endif
284 if( res==0 && getenv("OMIT_MISUSE")!=0 ) res = 1;
285 Tcl_SetObjResult(interp, Tcl_NewIntObj(res));
286 return TCL_OK;
287 }
288
289 /*
290 ** Usage: sqlite3_exec_printf DB FORMAT STRING
291 **
292 ** Invoke the sqlite3_exec_printf() interface using the open database
293 ** DB. The SQL is the string FORMAT. The format string should contain
294 ** one %s or %q. STRING is the value inserted into %s or %q.
295 */
test_exec_printf(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)296 static int SQLITE_TCLAPI test_exec_printf(
297 void *NotUsed,
298 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
299 int argc, /* Number of arguments */
300 char **argv /* Text of each argument */
301 ){
302 sqlite3 *db;
303 Tcl_DString str;
304 int rc;
305 char *zErr = 0;
306 char *zSql;
307 char zBuf[30];
308 if( argc!=4 ){
309 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
310 " DB FORMAT STRING", 0);
311 return TCL_ERROR;
312 }
313 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
314 Tcl_DStringInit(&str);
315 zSql = sqlite3_mprintf(argv[2], argv[3]);
316 rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
317 sqlite3_free(zSql);
318 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc);
319 Tcl_AppendElement(interp, zBuf);
320 Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
321 Tcl_DStringFree(&str);
322 if( zErr ) sqlite3_free(zErr);
323 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
324 return TCL_OK;
325 }
326
327 /*
328 ** Usage: sqlite3_exec_hex DB HEX
329 **
330 ** Invoke the sqlite3_exec() on a string that is obtained by translating
331 ** HEX into ASCII. Most characters are translated as is. %HH becomes
332 ** a hex character.
333 */
test_exec_hex(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)334 static int SQLITE_TCLAPI test_exec_hex(
335 void *NotUsed,
336 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
337 int argc, /* Number of arguments */
338 char **argv /* Text of each argument */
339 ){
340 sqlite3 *db;
341 Tcl_DString str;
342 int rc, i, j;
343 char *zErr = 0;
344 char *zHex;
345 char zSql[501];
346 char zBuf[30];
347 if( argc!=3 ){
348 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
349 " DB HEX", 0);
350 return TCL_ERROR;
351 }
352 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
353 zHex = argv[2];
354 for(i=j=0; i<(sizeof(zSql)-1) && zHex[j]; i++, j++){
355 if( zHex[j]=='%' && zHex[j+2] && zHex[j+2] ){
356 zSql[i] = (testHexToInt(zHex[j+1])<<4) + testHexToInt(zHex[j+2]);
357 j += 2;
358 }else{
359 zSql[i] = zHex[j];
360 }
361 }
362 zSql[i] = 0;
363 Tcl_DStringInit(&str);
364 rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
365 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc);
366 Tcl_AppendElement(interp, zBuf);
367 Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
368 Tcl_DStringFree(&str);
369 if( zErr ) sqlite3_free(zErr);
370 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
371 return TCL_OK;
372 }
373
374 /*
375 ** Usage: db_enter DB
376 ** db_leave DB
377 **
378 ** Enter or leave the mutex on a database connection.
379 */
db_enter(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)380 static int SQLITE_TCLAPI db_enter(
381 void *NotUsed,
382 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
383 int argc, /* Number of arguments */
384 char **argv /* Text of each argument */
385 ){
386 sqlite3 *db;
387 if( argc!=2 ){
388 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
389 " DB", 0);
390 return TCL_ERROR;
391 }
392 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
393 sqlite3_mutex_enter(db->mutex);
394 return TCL_OK;
395 }
db_leave(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)396 static int SQLITE_TCLAPI db_leave(
397 void *NotUsed,
398 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
399 int argc, /* Number of arguments */
400 char **argv /* Text of each argument */
401 ){
402 sqlite3 *db;
403 if( argc!=2 ){
404 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
405 " DB", 0);
406 return TCL_ERROR;
407 }
408 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
409 sqlite3_mutex_leave(db->mutex);
410 return TCL_OK;
411 }
412
413 /*
414 ** Usage: sqlite3_exec DB SQL
415 **
416 ** Invoke the sqlite3_exec interface using the open database DB
417 */
test_exec(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)418 static int SQLITE_TCLAPI test_exec(
419 void *NotUsed,
420 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
421 int argc, /* Number of arguments */
422 char **argv /* Text of each argument */
423 ){
424 sqlite3 *db;
425 Tcl_DString str;
426 int rc;
427 char *zErr = 0;
428 char *zSql;
429 int i, j;
430 char zBuf[30];
431 if( argc!=3 ){
432 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
433 " DB SQL", 0);
434 return TCL_ERROR;
435 }
436 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
437 Tcl_DStringInit(&str);
438 zSql = sqlite3_mprintf("%s", argv[2]);
439 for(i=j=0; zSql[i];){
440 if( zSql[i]=='%' ){
441 zSql[j++] = (testHexToInt(zSql[i+1])<<4) + testHexToInt(zSql[i+2]);
442 i += 3;
443 }else{
444 zSql[j++] = zSql[i++];
445 }
446 }
447 zSql[j] = 0;
448 rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
449 sqlite3_free(zSql);
450 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc);
451 Tcl_AppendElement(interp, zBuf);
452 Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
453 Tcl_DStringFree(&str);
454 if( zErr ) sqlite3_free(zErr);
455 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
456 return TCL_OK;
457 }
458
459 /*
460 ** Usage: sqlite3_exec_nr DB SQL
461 **
462 ** Invoke the sqlite3_exec interface using the open database DB. Discard
463 ** all results
464 */
test_exec_nr(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)465 static int SQLITE_TCLAPI test_exec_nr(
466 void *NotUsed,
467 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
468 int argc, /* Number of arguments */
469 char **argv /* Text of each argument */
470 ){
471 sqlite3 *db;
472 int rc;
473 char *zErr = 0;
474 if( argc!=3 ){
475 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
476 " DB SQL", 0);
477 return TCL_ERROR;
478 }
479 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
480 rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
481 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
482 return TCL_OK;
483 }
484
485 /*
486 ** Usage: sqlite3_mprintf_z_test SEPARATOR ARG0 ARG1 ...
487 **
488 ** Test the %z format of sqlite_mprintf(). Use multiple mprintf() calls to
489 ** concatenate arg0 through argn using separator as the separator.
490 ** Return the result.
491 */
test_mprintf_z(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)492 static int SQLITE_TCLAPI test_mprintf_z(
493 void *NotUsed,
494 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
495 int argc, /* Number of arguments */
496 char **argv /* Text of each argument */
497 ){
498 char *zResult = 0;
499 int i;
500
501 for(i=2; i<argc && (i==2 || zResult); i++){
502 zResult = sqlite3_mprintf("%z%s%s", zResult, argv[1], argv[i]);
503 }
504 Tcl_AppendResult(interp, zResult, 0);
505 sqlite3_free(zResult);
506 return TCL_OK;
507 }
508
509 /*
510 ** Usage: sqlite3_mprintf_n_test STRING
511 **
512 ** Test the %n format of sqlite_mprintf(). Return the length of the
513 ** input string.
514 */
test_mprintf_n(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)515 static int SQLITE_TCLAPI test_mprintf_n(
516 void *NotUsed,
517 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
518 int argc, /* Number of arguments */
519 char **argv /* Text of each argument */
520 ){
521 char *zStr;
522 int n = 0;
523 zStr = sqlite3_mprintf("%s%n", argv[1], &n);
524 sqlite3_free(zStr);
525 Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
526 return TCL_OK;
527 }
528
529 /*
530 ** Usage: sqlite3_snprintf_int SIZE FORMAT INT
531 **
532 ** Test the of sqlite3_snprintf() routine. SIZE is the size of the
533 ** output buffer in bytes. The maximum size is 100. FORMAT is the
534 ** format string. INT is a single integer argument. The FORMAT
535 ** string must require no more than this one integer argument. If
536 ** You pass in a format string that requires more than one argument,
537 ** bad things will happen.
538 */
test_snprintf_int(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)539 static int SQLITE_TCLAPI test_snprintf_int(
540 void *NotUsed,
541 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
542 int argc, /* Number of arguments */
543 char **argv /* Text of each argument */
544 ){
545 char zStr[100];
546 int n = atoi(argv[1]);
547 const char *zFormat = argv[2];
548 int a1 = atoi(argv[3]);
549 if( n>sizeof(zStr) ) n = sizeof(zStr);
550 sqlite3_snprintf(sizeof(zStr), zStr, "abcdefghijklmnopqrstuvwxyz");
551 sqlite3_snprintf(n, zStr, zFormat, a1);
552 Tcl_AppendResult(interp, zStr, 0);
553 return TCL_OK;
554 }
555
556 #ifndef SQLITE_OMIT_GET_TABLE
557
558 /*
559 ** Usage: sqlite3_get_table_printf DB FORMAT STRING ?--no-counts?
560 **
561 ** Invoke the sqlite3_get_table_printf() interface using the open database
562 ** DB. The SQL is the string FORMAT. The format string should contain
563 ** one %s or %q. STRING is the value inserted into %s or %q.
564 */
test_get_table_printf(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)565 static int SQLITE_TCLAPI test_get_table_printf(
566 void *NotUsed,
567 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
568 int argc, /* Number of arguments */
569 char **argv /* Text of each argument */
570 ){
571 sqlite3 *db;
572 Tcl_DString str;
573 int rc;
574 char *zErr = 0;
575 int nRow = 0, nCol = 0;
576 char **aResult;
577 int i;
578 char zBuf[30];
579 char *zSql;
580 int resCount = -1;
581 if( argc==5 ){
582 if( Tcl_GetInt(interp, argv[4], &resCount) ) return TCL_ERROR;
583 }
584 if( argc!=4 && argc!=5 ){
585 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
586 " DB FORMAT STRING ?COUNT?", 0);
587 return TCL_ERROR;
588 }
589 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
590 Tcl_DStringInit(&str);
591 zSql = sqlite3_mprintf(argv[2],argv[3]);
592 if( argc==5 ){
593 rc = sqlite3_get_table(db, zSql, &aResult, 0, 0, &zErr);
594 }else{
595 rc = sqlite3_get_table(db, zSql, &aResult, &nRow, &nCol, &zErr);
596 resCount = (nRow+1)*nCol;
597 }
598 sqlite3_free(zSql);
599 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc);
600 Tcl_AppendElement(interp, zBuf);
601 if( rc==SQLITE_OK ){
602 if( argc==4 ){
603 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nRow);
604 Tcl_AppendElement(interp, zBuf);
605 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nCol);
606 Tcl_AppendElement(interp, zBuf);
607 }
608 for(i=0; i<resCount; i++){
609 Tcl_AppendElement(interp, aResult[i] ? aResult[i] : "NULL");
610 }
611 }else{
612 Tcl_AppendElement(interp, zErr);
613 }
614 sqlite3_free_table(aResult);
615 if( zErr ) sqlite3_free(zErr);
616 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
617 return TCL_OK;
618 }
619
620 #endif /* SQLITE_OMIT_GET_TABLE */
621
622
623 /*
624 ** Usage: sqlite3_last_insert_rowid DB
625 **
626 ** Returns the integer ROWID of the most recent insert.
627 */
test_last_rowid(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)628 static int SQLITE_TCLAPI test_last_rowid(
629 void *NotUsed,
630 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
631 int argc, /* Number of arguments */
632 char **argv /* Text of each argument */
633 ){
634 sqlite3 *db;
635 char zBuf[30];
636
637 if( argc!=2 ){
638 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0);
639 return TCL_ERROR;
640 }
641 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
642 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", sqlite3_last_insert_rowid(db));
643 Tcl_AppendResult(interp, zBuf, 0);
644 return SQLITE_OK;
645 }
646
647 /*
648 ** Usage: sqlite3_key DB KEY
649 **
650 ** Set the codec key.
651 */
test_key(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)652 static int SQLITE_TCLAPI test_key(
653 void *NotUsed,
654 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
655 int argc, /* Number of arguments */
656 char **argv /* Text of each argument */
657 ){
658 return TCL_OK;
659 }
660
661 /*
662 ** Usage: sqlite3_rekey DB KEY
663 **
664 ** Change the codec key.
665 */
test_rekey(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)666 static int SQLITE_TCLAPI test_rekey(
667 void *NotUsed,
668 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
669 int argc, /* Number of arguments */
670 char **argv /* Text of each argument */
671 ){
672 return TCL_OK;
673 }
674
675 /*
676 ** Usage: sqlite3_close DB
677 **
678 ** Closes the database opened by sqlite3_open.
679 */
sqlite_test_close(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)680 static int SQLITE_TCLAPI sqlite_test_close(
681 void *NotUsed,
682 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
683 int argc, /* Number of arguments */
684 char **argv /* Text of each argument */
685 ){
686 sqlite3 *db;
687 int rc;
688 if( argc!=2 ){
689 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
690 " FILENAME\"", 0);
691 return TCL_ERROR;
692 }
693 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
694 rc = sqlite3_close(db);
695 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
696 return TCL_OK;
697 }
698
699 /*
700 ** Usage: sqlite3_close_v2 DB
701 **
702 ** Closes the database opened by sqlite3_open.
703 */
sqlite_test_close_v2(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)704 static int SQLITE_TCLAPI sqlite_test_close_v2(
705 void *NotUsed,
706 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
707 int argc, /* Number of arguments */
708 char **argv /* Text of each argument */
709 ){
710 sqlite3 *db;
711 int rc;
712 if( argc!=2 ){
713 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
714 " FILENAME\"", 0);
715 return TCL_ERROR;
716 }
717 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
718 rc = sqlite3_close_v2(db);
719 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
720 return TCL_OK;
721 }
722
723 /*
724 ** Implementation of the x_coalesce() function.
725 ** Return the first argument non-NULL argument.
726 */
t1_ifnullFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)727 static void t1_ifnullFunc(
728 sqlite3_context *context,
729 int argc,
730 sqlite3_value **argv
731 ){
732 int i;
733 for(i=0; i<argc; i++){
734 if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
735 int n = sqlite3_value_bytes(argv[i]);
736 sqlite3_result_text(context, (char*)sqlite3_value_text(argv[i]),
737 n, SQLITE_TRANSIENT);
738 break;
739 }
740 }
741 }
742
743 /*
744 ** These are test functions. hex8() interprets its argument as
745 ** UTF8 and returns a hex encoding. hex16le() interprets its argument
746 ** as UTF16le and returns a hex encoding.
747 */
hex8Func(sqlite3_context * p,int argc,sqlite3_value ** argv)748 static void hex8Func(sqlite3_context *p, int argc, sqlite3_value **argv){
749 const unsigned char *z;
750 int i;
751 char zBuf[200];
752 z = sqlite3_value_text(argv[0]);
753 for(i=0; i<sizeof(zBuf)/2 - 2 && z[i]; i++){
754 sqlite3_snprintf(sizeof(zBuf)-i*2, &zBuf[i*2], "%02x", z[i]);
755 }
756 zBuf[i*2] = 0;
757 sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);
758 }
759 #ifndef SQLITE_OMIT_UTF16
hex16Func(sqlite3_context * p,int argc,sqlite3_value ** argv)760 static void hex16Func(sqlite3_context *p, int argc, sqlite3_value **argv){
761 const unsigned short int *z;
762 int i;
763 char zBuf[400];
764 z = sqlite3_value_text16(argv[0]);
765 for(i=0; i<sizeof(zBuf)/4 - 4 && z[i]; i++){
766 sqlite3_snprintf(sizeof(zBuf)-i*4, &zBuf[i*4],"%04x", z[i]&0xff);
767 }
768 zBuf[i*4] = 0;
769 sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);
770 }
771 #endif
772
773 /*
774 ** A structure into which to accumulate text.
775 */
776 struct dstr {
777 int nAlloc; /* Space allocated */
778 int nUsed; /* Space used */
779 char *z; /* The space */
780 };
781
782 /*
783 ** Append text to a dstr
784 */
dstrAppend(struct dstr * p,const char * z,int divider)785 static void dstrAppend(struct dstr *p, const char *z, int divider){
786 int n = (int)strlen(z);
787 if( p->nUsed + n + 2 > p->nAlloc ){
788 char *zNew;
789 p->nAlloc = p->nAlloc*2 + n + 200;
790 zNew = sqlite3_realloc(p->z, p->nAlloc);
791 if( zNew==0 ){
792 sqlite3_free(p->z);
793 memset(p, 0, sizeof(*p));
794 return;
795 }
796 p->z = zNew;
797 }
798 if( divider && p->nUsed>0 ){
799 p->z[p->nUsed++] = divider;
800 }
801 memcpy(&p->z[p->nUsed], z, n+1);
802 p->nUsed += n;
803 }
804
805 /*
806 ** Invoked for each callback from sqlite3ExecFunc
807 */
execFuncCallback(void * pData,int argc,char ** argv,char ** NotUsed)808 static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){
809 struct dstr *p = (struct dstr*)pData;
810 int i;
811 for(i=0; i<argc; i++){
812 if( argv[i]==0 ){
813 dstrAppend(p, "NULL", ' ');
814 }else{
815 dstrAppend(p, argv[i], ' ');
816 }
817 }
818 return 0;
819 }
820
821 /*
822 ** Implementation of the x_sqlite_exec() function. This function takes
823 ** a single argument and attempts to execute that argument as SQL code.
824 ** This is illegal and should set the SQLITE_MISUSE flag on the database.
825 **
826 ** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec()
827 ** from within a function call.
828 **
829 ** This routine simulates the effect of having two threads attempt to
830 ** use the same database at the same time.
831 */
sqlite3ExecFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)832 static void sqlite3ExecFunc(
833 sqlite3_context *context,
834 int argc,
835 sqlite3_value **argv
836 ){
837 struct dstr x;
838 memset(&x, 0, sizeof(x));
839 (void)sqlite3_exec((sqlite3*)sqlite3_user_data(context),
840 (char*)sqlite3_value_text(argv[0]),
841 execFuncCallback, &x, 0);
842 sqlite3_result_text(context, x.z, x.nUsed, SQLITE_TRANSIENT);
843 sqlite3_free(x.z);
844 }
845
846 /*
847 ** Implementation of tkt2213func(), a scalar function that takes exactly
848 ** one argument. It has two interesting features:
849 **
850 ** * It calls sqlite3_value_text() 3 times on the argument sqlite3_value*.
851 ** If the three pointers returned are not the same an SQL error is raised.
852 **
853 ** * Otherwise it returns a copy of the text representation of its
854 ** argument in such a way as the VDBE representation is a Mem* cell
855 ** with the MEM_Term flag clear.
856 **
857 ** Ticket #2213 can therefore be tested by evaluating the following
858 ** SQL expression:
859 **
860 ** tkt2213func(tkt2213func('a string'));
861 */
tkt2213Function(sqlite3_context * context,int argc,sqlite3_value ** argv)862 static void tkt2213Function(
863 sqlite3_context *context,
864 int argc,
865 sqlite3_value **argv
866 ){
867 int nText;
868 unsigned char const *zText1;
869 unsigned char const *zText2;
870 unsigned char const *zText3;
871
872 nText = sqlite3_value_bytes(argv[0]);
873 zText1 = sqlite3_value_text(argv[0]);
874 zText2 = sqlite3_value_text(argv[0]);
875 zText3 = sqlite3_value_text(argv[0]);
876
877 if( zText1!=zText2 || zText2!=zText3 ){
878 sqlite3_result_error(context, "tkt2213 is not fixed", -1);
879 }else{
880 char *zCopy = (char *)sqlite3_malloc(nText);
881 memcpy(zCopy, zText1, nText);
882 sqlite3_result_text(context, zCopy, nText, sqlite3_free);
883 }
884 }
885
886 /*
887 ** The following SQL function takes 4 arguments. The 2nd and
888 ** 4th argument must be one of these strings: 'text', 'text16',
889 ** or 'blob' corresponding to API functions
890 **
891 ** sqlite3_value_text()
892 ** sqlite3_value_text16()
893 ** sqlite3_value_blob()
894 **
895 ** The third argument is a string, either 'bytes' or 'bytes16' or 'noop',
896 ** corresponding to APIs:
897 **
898 ** sqlite3_value_bytes()
899 ** sqlite3_value_bytes16()
900 ** noop
901 **
902 ** The APIs designated by the 2nd through 4th arguments are applied
903 ** to the first argument in order. If the pointers returned by the
904 ** second and fourth are different, this routine returns 1. Otherwise,
905 ** this routine returns 0.
906 **
907 ** This function is used to test to see when returned pointers from
908 ** the _text(), _text16() and _blob() APIs become invalidated.
909 */
ptrChngFunction(sqlite3_context * context,int argc,sqlite3_value ** argv)910 static void ptrChngFunction(
911 sqlite3_context *context,
912 int argc,
913 sqlite3_value **argv
914 ){
915 const void *p1, *p2;
916 const char *zCmd;
917 if( argc!=4 ) return;
918 zCmd = (const char*)sqlite3_value_text(argv[1]);
919 if( zCmd==0 ) return;
920 if( strcmp(zCmd,"text")==0 ){
921 p1 = (const void*)sqlite3_value_text(argv[0]);
922 #ifndef SQLITE_OMIT_UTF16
923 }else if( strcmp(zCmd, "text16")==0 ){
924 p1 = (const void*)sqlite3_value_text16(argv[0]);
925 #endif
926 }else if( strcmp(zCmd, "blob")==0 ){
927 p1 = (const void*)sqlite3_value_blob(argv[0]);
928 }else{
929 return;
930 }
931 zCmd = (const char*)sqlite3_value_text(argv[2]);
932 if( zCmd==0 ) return;
933 if( strcmp(zCmd,"bytes")==0 ){
934 sqlite3_value_bytes(argv[0]);
935 #ifndef SQLITE_OMIT_UTF16
936 }else if( strcmp(zCmd, "bytes16")==0 ){
937 sqlite3_value_bytes16(argv[0]);
938 #endif
939 }else if( strcmp(zCmd, "noop")==0 ){
940 /* do nothing */
941 }else{
942 return;
943 }
944 zCmd = (const char*)sqlite3_value_text(argv[3]);
945 if( zCmd==0 ) return;
946 if( strcmp(zCmd,"text")==0 ){
947 p2 = (const void*)sqlite3_value_text(argv[0]);
948 #ifndef SQLITE_OMIT_UTF16
949 }else if( strcmp(zCmd, "text16")==0 ){
950 p2 = (const void*)sqlite3_value_text16(argv[0]);
951 #endif
952 }else if( strcmp(zCmd, "blob")==0 ){
953 p2 = (const void*)sqlite3_value_blob(argv[0]);
954 }else{
955 return;
956 }
957 sqlite3_result_int(context, p1!=p2);
958 }
959
960 /*
961 ** This SQL function returns a different answer each time it is called, even if
962 ** the arguments are the same.
963 */
nondeterministicFunction(sqlite3_context * context,int argc,sqlite3_value ** argv)964 static void nondeterministicFunction(
965 sqlite3_context *context,
966 int argc,
967 sqlite3_value **argv
968 ){
969 static int cnt = 0;
970 sqlite3_result_int(context, cnt++);
971 }
972
973 /*
974 ** This SQL function returns the integer value of its argument as a MEM_IntReal
975 ** value.
976 */
intrealFunction(sqlite3_context * context,int argc,sqlite3_value ** argv)977 static void intrealFunction(
978 sqlite3_context *context,
979 int argc,
980 sqlite3_value **argv
981 ){
982 sqlite3_int64 v = sqlite3_value_int64(argv[0]);
983 sqlite3_result_int64(context, v);
984 sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, context);
985 }
986
987 /*
988 ** Usage: sqlite3_create_function DB
989 **
990 ** Call the sqlite3_create_function API on the given database in order
991 ** to create a function named "x_coalesce". This function does the same thing
992 ** as the "coalesce" function. This function also registers an SQL function
993 ** named "x_sqlite_exec" that invokes sqlite3_exec(). Invoking sqlite3_exec()
994 ** in this way is illegal recursion and should raise an SQLITE_MISUSE error.
995 ** The effect is similar to trying to use the same database connection from
996 ** two threads at the same time.
997 **
998 ** The original motivation for this routine was to be able to call the
999 ** sqlite3_create_function function while a query is in progress in order
1000 ** to test the SQLITE_MISUSE detection logic.
1001 */
test_create_function(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1002 static int SQLITE_TCLAPI test_create_function(
1003 void *NotUsed,
1004 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1005 int argc, /* Number of arguments */
1006 char **argv /* Text of each argument */
1007 ){
1008 int rc;
1009 sqlite3 *db;
1010
1011 if( argc!=2 ){
1012 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1013 " DB\"", 0);
1014 return TCL_ERROR;
1015 }
1016 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
1017 rc = sqlite3_create_function(db, "x_coalesce", -1, SQLITE_UTF8, 0,
1018 t1_ifnullFunc, 0, 0);
1019 if( rc==SQLITE_OK ){
1020 rc = sqlite3_create_function(db, "hex8", 1, SQLITE_UTF8 | SQLITE_DETERMINISTIC,
1021 0, hex8Func, 0, 0);
1022 }
1023 #ifndef SQLITE_OMIT_UTF16
1024 if( rc==SQLITE_OK ){
1025 rc = sqlite3_create_function(db, "hex16", 1, SQLITE_UTF16 | SQLITE_DETERMINISTIC,
1026 0, hex16Func, 0, 0);
1027 }
1028 #endif
1029 if( rc==SQLITE_OK ){
1030 rc = sqlite3_create_function(db, "tkt2213func", 1, SQLITE_ANY, 0,
1031 tkt2213Function, 0, 0);
1032 }
1033 if( rc==SQLITE_OK ){
1034 rc = sqlite3_create_function(db, "pointer_change", 4, SQLITE_ANY, 0,
1035 ptrChngFunction, 0, 0);
1036 }
1037
1038 /* Functions counter1() and counter2() have the same implementation - they
1039 ** both return an ascending integer with each call. But counter1() is marked
1040 ** as non-deterministic and counter2() is marked as deterministic.
1041 */
1042 if( rc==SQLITE_OK ){
1043 rc = sqlite3_create_function(db, "counter1", -1, SQLITE_UTF8,
1044 0, nondeterministicFunction, 0, 0);
1045 }
1046 if( rc==SQLITE_OK ){
1047 rc = sqlite3_create_function(db, "counter2", -1, SQLITE_UTF8|SQLITE_DETERMINISTIC,
1048 0, nondeterministicFunction, 0, 0);
1049 }
1050
1051 /* The intreal() function converts its argument to an integer and returns
1052 ** it as a MEM_IntReal.
1053 */
1054 if( rc==SQLITE_OK ){
1055 rc = sqlite3_create_function(db, "intreal", 1, SQLITE_UTF8,
1056 0, intrealFunction, 0, 0);
1057 }
1058
1059 #ifndef SQLITE_OMIT_UTF16
1060 /* Use the sqlite3_create_function16() API here. Mainly for fun, but also
1061 ** because it is not tested anywhere else. */
1062 if( rc==SQLITE_OK ){
1063 const void *zUtf16;
1064 sqlite3_value *pVal;
1065 sqlite3_mutex_enter(db->mutex);
1066 pVal = sqlite3ValueNew(db);
1067 sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
1068 zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
1069 if( db->mallocFailed ){
1070 rc = SQLITE_NOMEM;
1071 }else{
1072 rc = sqlite3_create_function16(db, zUtf16,
1073 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
1074 }
1075 sqlite3ValueFree(pVal);
1076 sqlite3_mutex_leave(db->mutex);
1077 }
1078 #endif
1079
1080 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
1081 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
1082 return TCL_OK;
1083 }
1084
1085 /*
1086 ** Usage: sqlite3_drop_modules DB ?NAME ...?
1087 **
1088 ** Invoke the sqlite3_drop_modules(D,L) interface on database
1089 ** connection DB, in order to drop all modules except those named in
1090 ** the argument.
1091 */
test_drop_modules(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1092 static int SQLITE_TCLAPI test_drop_modules(
1093 void *NotUsed,
1094 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1095 int argc, /* Number of arguments */
1096 char **argv /* Text of each argument */
1097 ){
1098 sqlite3 *db;
1099
1100 if( argc!=2 ){
1101 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1102 " DB\"", 0);
1103 return TCL_ERROR;
1104 }
1105 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
1106 #ifndef SQLITE_OMIT_VIRTUALTABLE
1107 sqlite3_drop_modules(db, argc>2 ? (const char**)(argv+2) : 0);
1108 #endif
1109 return TCL_OK;
1110 }
1111
1112 /*
1113 ** Routines to implement the x_count() aggregate function.
1114 **
1115 ** x_count() counts the number of non-null arguments. But there are
1116 ** some twists for testing purposes.
1117 **
1118 ** If the argument to x_count() is 40 then a UTF-8 error is reported
1119 ** on the step function. If x_count(41) is seen, then a UTF-16 error
1120 ** is reported on the step function. If the total count is 42, then
1121 ** a UTF-8 error is reported on the finalize function.
1122 */
1123 typedef struct t1CountCtx t1CountCtx;
1124 struct t1CountCtx {
1125 int n;
1126 };
t1CountStep(sqlite3_context * context,int argc,sqlite3_value ** argv)1127 static void t1CountStep(
1128 sqlite3_context *context,
1129 int argc,
1130 sqlite3_value **argv
1131 ){
1132 t1CountCtx *p;
1133 p = sqlite3_aggregate_context(context, sizeof(*p));
1134 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0]) ) && p ){
1135 p->n++;
1136 }
1137 if( argc>0 ){
1138 int v = sqlite3_value_int(argv[0]);
1139 if( v==40 ){
1140 sqlite3_result_error(context, "value of 40 handed to x_count", -1);
1141 #ifndef SQLITE_OMIT_UTF16
1142 }else if( v==41 ){
1143 const char zUtf16ErrMsg[] = { 0, 0x61, 0, 0x62, 0, 0x63, 0, 0, 0};
1144 sqlite3_result_error16(context, &zUtf16ErrMsg[1-SQLITE_BIGENDIAN], -1);
1145 #endif
1146 }
1147 }
1148 }
t1CountFinalize(sqlite3_context * context)1149 static void t1CountFinalize(sqlite3_context *context){
1150 t1CountCtx *p;
1151 p = sqlite3_aggregate_context(context, sizeof(*p));
1152 if( p ){
1153 if( p->n==42 ){
1154 sqlite3_result_error(context, "x_count totals to 42", -1);
1155 }else{
1156 sqlite3_result_int(context, p ? p->n : 0);
1157 }
1158 }
1159 }
1160
1161 #ifndef SQLITE_OMIT_DEPRECATED
legacyCountStep(sqlite3_context * context,int argc,sqlite3_value ** argv)1162 static void legacyCountStep(
1163 sqlite3_context *context,
1164 int argc,
1165 sqlite3_value **argv
1166 ){
1167 /* no-op */
1168 }
1169
legacyCountFinalize(sqlite3_context * context)1170 static void legacyCountFinalize(sqlite3_context *context){
1171 sqlite3_result_int(context, sqlite3_aggregate_count(context));
1172 }
1173 #endif
1174
1175 /*
1176 ** Usage: sqlite3_create_aggregate DB
1177 **
1178 ** Call the sqlite3_create_function API on the given database in order
1179 ** to create a function named "x_count". This function is similar
1180 ** to the built-in count() function, with a few special quirks
1181 ** for testing the sqlite3_result_error() APIs.
1182 **
1183 ** The original motivation for this routine was to be able to call the
1184 ** sqlite3_create_aggregate function while a query is in progress in order
1185 ** to test the SQLITE_MISUSE detection logic. See misuse.test.
1186 **
1187 ** This routine was later extended to test the use of sqlite3_result_error()
1188 ** within aggregate functions.
1189 **
1190 ** Later: It is now also extended to register the aggregate function
1191 ** "legacy_count()" with the supplied database handle. This is used
1192 ** to test the deprecated sqlite3_aggregate_count() API.
1193 */
test_create_aggregate(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1194 static int SQLITE_TCLAPI test_create_aggregate(
1195 void *NotUsed,
1196 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1197 int argc, /* Number of arguments */
1198 char **argv /* Text of each argument */
1199 ){
1200 sqlite3 *db;
1201 int rc;
1202 if( argc!=2 ){
1203 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1204 " FILENAME\"", 0);
1205 return TCL_ERROR;
1206 }
1207 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
1208 rc = sqlite3_create_function(db, "x_count", 0, SQLITE_UTF8, 0, 0,
1209 t1CountStep,t1CountFinalize);
1210 if( rc==SQLITE_OK ){
1211 rc = sqlite3_create_function(db, "x_count", 1, SQLITE_UTF8, 0, 0,
1212 t1CountStep,t1CountFinalize);
1213 }
1214 #ifndef SQLITE_OMIT_DEPRECATED
1215 if( rc==SQLITE_OK ){
1216 rc = sqlite3_create_function(db, "legacy_count", 0, SQLITE_ANY, 0, 0,
1217 legacyCountStep, legacyCountFinalize
1218 );
1219 }
1220 #endif
1221 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
1222 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
1223 return TCL_OK;
1224 }
1225
1226
1227 /*
1228 ** Usage: printf TEXT
1229 **
1230 ** Send output to printf. Use this rather than puts to merge the output
1231 ** in the correct sequence with debugging printfs inserted into C code.
1232 ** Puts uses a separate buffer and debugging statements will be out of
1233 ** sequence if it is used.
1234 */
test_printf(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1235 static int SQLITE_TCLAPI test_printf(
1236 void *NotUsed,
1237 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1238 int argc, /* Number of arguments */
1239 char **argv /* Text of each argument */
1240 ){
1241 if( argc!=2 ){
1242 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1243 " TEXT\"", 0);
1244 return TCL_ERROR;
1245 }
1246 printf("%s\n", argv[1]);
1247 return TCL_OK;
1248 }
1249
1250
1251
1252 /*
1253 ** Usage: sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER
1254 **
1255 ** Call mprintf with three integer arguments
1256 */
sqlite3_mprintf_int(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1257 static int SQLITE_TCLAPI sqlite3_mprintf_int(
1258 void *NotUsed,
1259 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1260 int argc, /* Number of arguments */
1261 char **argv /* Text of each argument */
1262 ){
1263 int a[3], i;
1264 char *z;
1265 if( argc!=5 ){
1266 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1267 " FORMAT INT INT INT\"", 0);
1268 return TCL_ERROR;
1269 }
1270 for(i=2; i<5; i++){
1271 if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
1272 }
1273 z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
1274 Tcl_AppendResult(interp, z, 0);
1275 sqlite3_free(z);
1276 return TCL_OK;
1277 }
1278
1279 /*
1280 ** Usage: sqlite3_mprintf_int64 FORMAT INTEGER INTEGER INTEGER
1281 **
1282 ** Call mprintf with three 64-bit integer arguments
1283 */
sqlite3_mprintf_int64(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1284 static int SQLITE_TCLAPI sqlite3_mprintf_int64(
1285 void *NotUsed,
1286 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1287 int argc, /* Number of arguments */
1288 char **argv /* Text of each argument */
1289 ){
1290 int i;
1291 sqlite_int64 a[3];
1292 char *z;
1293 if( argc!=5 ){
1294 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1295 " FORMAT INT INT INT\"", 0);
1296 return TCL_ERROR;
1297 }
1298 for(i=2; i<5; i++){
1299 if( sqlite3Atoi64(argv[i], &a[i-2], sqlite3Strlen30(argv[i]), SQLITE_UTF8) ){
1300 Tcl_AppendResult(interp, "argument is not a valid 64-bit integer", 0);
1301 return TCL_ERROR;
1302 }
1303 }
1304 z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
1305 Tcl_AppendResult(interp, z, 0);
1306 sqlite3_free(z);
1307 return TCL_OK;
1308 }
1309
1310 /*
1311 ** Usage: sqlite3_mprintf_long FORMAT INTEGER INTEGER INTEGER
1312 **
1313 ** Call mprintf with three long integer arguments. This might be the
1314 ** same as sqlite3_mprintf_int or sqlite3_mprintf_int64, depending on
1315 ** platform.
1316 */
sqlite3_mprintf_long(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1317 static int SQLITE_TCLAPI sqlite3_mprintf_long(
1318 void *NotUsed,
1319 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1320 int argc, /* Number of arguments */
1321 char **argv /* Text of each argument */
1322 ){
1323 int i;
1324 long int a[3];
1325 int b[3];
1326 char *z;
1327 if( argc!=5 ){
1328 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1329 " FORMAT INT INT INT\"", 0);
1330 return TCL_ERROR;
1331 }
1332 for(i=2; i<5; i++){
1333 if( Tcl_GetInt(interp, argv[i], &b[i-2]) ) return TCL_ERROR;
1334 a[i-2] = (long int)b[i-2];
1335 a[i-2] &= (((u64)1)<<(sizeof(int)*8))-1;
1336 }
1337 z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
1338 Tcl_AppendResult(interp, z, 0);
1339 sqlite3_free(z);
1340 return TCL_OK;
1341 }
1342
1343 /*
1344 ** Usage: sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING
1345 **
1346 ** Call mprintf with two integer arguments and one string argument
1347 */
sqlite3_mprintf_str(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1348 static int SQLITE_TCLAPI sqlite3_mprintf_str(
1349 void *NotUsed,
1350 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1351 int argc, /* Number of arguments */
1352 char **argv /* Text of each argument */
1353 ){
1354 int a[3], i;
1355 char *z;
1356 if( argc<4 || argc>5 ){
1357 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1358 " FORMAT INT INT ?STRING?\"", 0);
1359 return TCL_ERROR;
1360 }
1361 for(i=2; i<4; i++){
1362 if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
1363 }
1364 z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL);
1365 Tcl_AppendResult(interp, z, 0);
1366 sqlite3_free(z);
1367 return TCL_OK;
1368 }
1369
1370 /*
1371 ** Usage: sqlite3_snprintf_str INTEGER FORMAT INTEGER INTEGER STRING
1372 **
1373 ** Call mprintf with two integer arguments and one string argument
1374 */
sqlite3_snprintf_str(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1375 static int SQLITE_TCLAPI sqlite3_snprintf_str(
1376 void *NotUsed,
1377 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1378 int argc, /* Number of arguments */
1379 char **argv /* Text of each argument */
1380 ){
1381 int a[3], i;
1382 int n;
1383 char *z;
1384 if( argc<5 || argc>6 ){
1385 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1386 " INT FORMAT INT INT ?STRING?\"", 0);
1387 return TCL_ERROR;
1388 }
1389 if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
1390 if( n<0 ){
1391 Tcl_AppendResult(interp, "N must be non-negative", 0);
1392 return TCL_ERROR;
1393 }
1394 for(i=3; i<5; i++){
1395 if( Tcl_GetInt(interp, argv[i], &a[i-3]) ) return TCL_ERROR;
1396 }
1397 z = sqlite3_malloc( n+1 );
1398 sqlite3_snprintf(n, z, argv[2], a[0], a[1], argc>4 ? argv[5] : NULL);
1399 Tcl_AppendResult(interp, z, 0);
1400 sqlite3_free(z);
1401 return TCL_OK;
1402 }
1403
1404 /*
1405 ** Usage: sqlite3_mprintf_double FORMAT INTEGER INTEGER DOUBLE
1406 **
1407 ** Call mprintf with two integer arguments and one double argument
1408 */
sqlite3_mprintf_double(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1409 static int SQLITE_TCLAPI sqlite3_mprintf_double(
1410 void *NotUsed,
1411 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1412 int argc, /* Number of arguments */
1413 char **argv /* Text of each argument */
1414 ){
1415 int a[3], i;
1416 double r;
1417 char *z;
1418 if( argc!=5 ){
1419 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1420 " FORMAT INT INT DOUBLE\"", 0);
1421 return TCL_ERROR;
1422 }
1423 for(i=2; i<4; i++){
1424 if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
1425 }
1426 if( Tcl_GetDouble(interp, argv[4], &r) ) return TCL_ERROR;
1427 z = sqlite3_mprintf(argv[1], a[0], a[1], r);
1428 Tcl_AppendResult(interp, z, 0);
1429 sqlite3_free(z);
1430 return TCL_OK;
1431 }
1432
1433 /*
1434 ** Usage: sqlite3_mprintf_scaled FORMAT DOUBLE DOUBLE
1435 **
1436 ** Call mprintf with a single double argument which is the product of the
1437 ** two arguments given above. This is used to generate overflow and underflow
1438 ** doubles to test that they are converted properly.
1439 */
sqlite3_mprintf_scaled(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1440 static int SQLITE_TCLAPI sqlite3_mprintf_scaled(
1441 void *NotUsed,
1442 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1443 int argc, /* Number of arguments */
1444 char **argv /* Text of each argument */
1445 ){
1446 int i;
1447 double r[2];
1448 char *z;
1449 if( argc!=4 ){
1450 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1451 " FORMAT DOUBLE DOUBLE\"", 0);
1452 return TCL_ERROR;
1453 }
1454 for(i=2; i<4; i++){
1455 if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR;
1456 }
1457 z = sqlite3_mprintf(argv[1], r[0]*r[1]);
1458 Tcl_AppendResult(interp, z, 0);
1459 sqlite3_free(z);
1460 return TCL_OK;
1461 }
1462
1463 /*
1464 ** Usage: sqlite3_mprintf_stronly FORMAT STRING
1465 **
1466 ** Call mprintf with a single double argument which is the product of the
1467 ** two arguments given above. This is used to generate overflow and underflow
1468 ** doubles to test that they are converted properly.
1469 */
sqlite3_mprintf_stronly(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1470 static int SQLITE_TCLAPI sqlite3_mprintf_stronly(
1471 void *NotUsed,
1472 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1473 int argc, /* Number of arguments */
1474 char **argv /* Text of each argument */
1475 ){
1476 char *z;
1477 if( argc!=3 ){
1478 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1479 " FORMAT STRING\"", 0);
1480 return TCL_ERROR;
1481 }
1482 z = sqlite3_mprintf(argv[1], argv[2]);
1483 Tcl_AppendResult(interp, z, 0);
1484 sqlite3_free(z);
1485 return TCL_OK;
1486 }
1487
1488 /*
1489 ** Usage: sqlite3_mprintf_hexdouble FORMAT HEX
1490 **
1491 ** Call mprintf with a single double argument which is derived from the
1492 ** hexadecimal encoding of an IEEE double.
1493 */
sqlite3_mprintf_hexdouble(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)1494 static int SQLITE_TCLAPI sqlite3_mprintf_hexdouble(
1495 void *NotUsed,
1496 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1497 int argc, /* Number of arguments */
1498 char **argv /* Text of each argument */
1499 ){
1500 char *z;
1501 double r;
1502 unsigned int x1, x2;
1503 sqlite_uint64 d;
1504 if( argc!=3 ){
1505 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1506 " FORMAT STRING\"", 0);
1507 return TCL_ERROR;
1508 }
1509 if( sscanf(argv[2], "%08x%08x", &x2, &x1)!=2 ){
1510 Tcl_AppendResult(interp, "2nd argument should be 16-characters of hex", 0);
1511 return TCL_ERROR;
1512 }
1513 d = x2;
1514 d = (d<<32) + x1;
1515 memcpy(&r, &d, sizeof(r));
1516 z = sqlite3_mprintf(argv[1], r);
1517 Tcl_AppendResult(interp, z, 0);
1518 sqlite3_free(z);
1519 return TCL_OK;
1520 }
1521
1522 /*
1523 ** Usage: sqlite3_enable_shared_cache ?BOOLEAN?
1524 **
1525 */
1526 #if !defined(SQLITE_OMIT_SHARED_CACHE)
test_enable_shared(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1527 static int SQLITE_TCLAPI test_enable_shared(
1528 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1529 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1530 int objc, /* Number of arguments */
1531 Tcl_Obj *CONST objv[] /* Command arguments */
1532 ){
1533 int rc;
1534 int enable;
1535 int ret = 0;
1536
1537 if( objc!=2 && objc!=1 ){
1538 Tcl_WrongNumArgs(interp, 1, objv, "?BOOLEAN?");
1539 return TCL_ERROR;
1540 }
1541 ret = sqlite3GlobalConfig.sharedCacheEnabled;
1542
1543 if( objc==2 ){
1544 if( Tcl_GetBooleanFromObj(interp, objv[1], &enable) ){
1545 return TCL_ERROR;
1546 }
1547 rc = sqlite3_enable_shared_cache(enable);
1548 if( rc!=SQLITE_OK ){
1549 Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC);
1550 return TCL_ERROR;
1551 }
1552 }
1553 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(ret));
1554 return TCL_OK;
1555 }
1556 #endif
1557
1558
1559
1560 /*
1561 ** Usage: sqlite3_extended_result_codes DB BOOLEAN
1562 **
1563 */
test_extended_result_codes(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1564 static int SQLITE_TCLAPI test_extended_result_codes(
1565 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1566 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1567 int objc, /* Number of arguments */
1568 Tcl_Obj *CONST objv[] /* Command arguments */
1569 ){
1570 int enable;
1571 sqlite3 *db;
1572
1573 if( objc!=3 ){
1574 Tcl_WrongNumArgs(interp, 1, objv, "DB BOOLEAN");
1575 return TCL_ERROR;
1576 }
1577 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1578 if( Tcl_GetBooleanFromObj(interp, objv[2], &enable) ) return TCL_ERROR;
1579 sqlite3_extended_result_codes(db, enable);
1580 return TCL_OK;
1581 }
1582
1583 /*
1584 ** Usage: sqlite3_libversion_number
1585 **
1586 */
test_libversion_number(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1587 static int SQLITE_TCLAPI test_libversion_number(
1588 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1589 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1590 int objc, /* Number of arguments */
1591 Tcl_Obj *CONST objv[] /* Command arguments */
1592 ){
1593 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_libversion_number()));
1594 return TCL_OK;
1595 }
1596
1597 /*
1598 ** Usage: sqlite3_table_column_metadata DB dbname tblname colname
1599 **
1600 */
test_table_column_metadata(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1601 static int SQLITE_TCLAPI test_table_column_metadata(
1602 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1603 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1604 int objc, /* Number of arguments */
1605 Tcl_Obj *CONST objv[] /* Command arguments */
1606 ){
1607 sqlite3 *db;
1608 const char *zDb;
1609 const char *zTbl;
1610 const char *zCol;
1611 int rc;
1612 Tcl_Obj *pRet;
1613
1614 const char *zDatatype;
1615 const char *zCollseq;
1616 int notnull;
1617 int primarykey;
1618 int autoincrement;
1619
1620 if( objc!=5 && objc!=4 ){
1621 Tcl_WrongNumArgs(interp, 1, objv, "DB dbname tblname colname");
1622 return TCL_ERROR;
1623 }
1624 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1625 zDb = Tcl_GetString(objv[2]);
1626 zTbl = Tcl_GetString(objv[3]);
1627 zCol = objc==5 ? Tcl_GetString(objv[4]) : 0;
1628
1629 if( strlen(zDb)==0 ) zDb = 0;
1630
1631 rc = sqlite3_table_column_metadata(db, zDb, zTbl, zCol,
1632 &zDatatype, &zCollseq, ¬null, &primarykey, &autoincrement);
1633
1634 if( rc!=SQLITE_OK ){
1635 Tcl_AppendResult(interp, sqlite3_errmsg(db), 0);
1636 return TCL_ERROR;
1637 }
1638
1639 pRet = Tcl_NewObj();
1640 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zDatatype, -1));
1641 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zCollseq, -1));
1642 Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(notnull));
1643 Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(primarykey));
1644 Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(autoincrement));
1645 Tcl_SetObjResult(interp, pRet);
1646
1647 return TCL_OK;
1648 }
1649
1650 #ifndef SQLITE_OMIT_INCRBLOB
1651
blobHandleFromObj(Tcl_Interp * interp,Tcl_Obj * pObj,sqlite3_blob ** ppBlob)1652 static int SQLITE_TCLAPI blobHandleFromObj(
1653 Tcl_Interp *interp,
1654 Tcl_Obj *pObj,
1655 sqlite3_blob **ppBlob
1656 ){
1657 char *z;
1658 int n;
1659
1660 z = Tcl_GetStringFromObj(pObj, &n);
1661 if( n==0 ){
1662 *ppBlob = 0;
1663 }else{
1664 int notUsed;
1665 Tcl_Channel channel;
1666 ClientData instanceData;
1667
1668 channel = Tcl_GetChannel(interp, z, ¬Used);
1669 if( !channel ) return TCL_ERROR;
1670
1671 Tcl_Flush(channel);
1672 Tcl_Seek(channel, 0, SEEK_SET);
1673
1674 instanceData = Tcl_GetChannelInstanceData(channel);
1675 *ppBlob = *((sqlite3_blob **)instanceData);
1676 }
1677
1678 return TCL_OK;
1679 }
1680
test_blob_reopen(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1681 static int SQLITE_TCLAPI test_blob_reopen(
1682 ClientData clientData, /* Not used */
1683 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1684 int objc, /* Number of arguments */
1685 Tcl_Obj *CONST objv[] /* Command arguments */
1686 ){
1687 Tcl_WideInt iRowid;
1688 sqlite3_blob *pBlob;
1689 int rc;
1690
1691 if( objc!=3 ){
1692 Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL ROWID");
1693 return TCL_ERROR;
1694 }
1695
1696 if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR;
1697 if( Tcl_GetWideIntFromObj(interp, objv[2], &iRowid) ) return TCL_ERROR;
1698
1699 rc = sqlite3_blob_reopen(pBlob, iRowid);
1700 if( rc!=SQLITE_OK ){
1701 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
1702 }
1703
1704 return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
1705 }
1706
1707 #endif
1708
1709 /*
1710 ** Usage: sqlite3_create_collation_v2 DB-HANDLE NAME CMP-PROC DEL-PROC
1711 **
1712 ** This Tcl proc is used for testing the experimental
1713 ** sqlite3_create_collation_v2() interface.
1714 */
1715 struct TestCollationX {
1716 Tcl_Interp *interp;
1717 Tcl_Obj *pCmp;
1718 Tcl_Obj *pDel;
1719 };
1720 typedef struct TestCollationX TestCollationX;
testCreateCollationDel(void * pCtx)1721 static void testCreateCollationDel(void *pCtx){
1722 TestCollationX *p = (TestCollationX *)pCtx;
1723
1724 int rc = Tcl_EvalObjEx(p->interp, p->pDel, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
1725 if( rc!=TCL_OK ){
1726 Tcl_BackgroundError(p->interp);
1727 }
1728
1729 Tcl_DecrRefCount(p->pCmp);
1730 Tcl_DecrRefCount(p->pDel);
1731 sqlite3_free((void *)p);
1732 }
testCreateCollationCmp(void * pCtx,int nLeft,const void * zLeft,int nRight,const void * zRight)1733 static int testCreateCollationCmp(
1734 void *pCtx,
1735 int nLeft,
1736 const void *zLeft,
1737 int nRight,
1738 const void *zRight
1739 ){
1740 TestCollationX *p = (TestCollationX *)pCtx;
1741 Tcl_Obj *pScript = Tcl_DuplicateObj(p->pCmp);
1742 int iRes = 0;
1743
1744 Tcl_IncrRefCount(pScript);
1745 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zLeft, nLeft));
1746 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zRight,nRight));
1747
1748 if( TCL_OK!=Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL)
1749 || TCL_OK!=Tcl_GetIntFromObj(p->interp, Tcl_GetObjResult(p->interp), &iRes)
1750 ){
1751 Tcl_BackgroundError(p->interp);
1752 }
1753 Tcl_DecrRefCount(pScript);
1754
1755 return iRes;
1756 }
test_create_collation_v2(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1757 static int SQLITE_TCLAPI test_create_collation_v2(
1758 ClientData clientData, /* Not used */
1759 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1760 int objc, /* Number of arguments */
1761 Tcl_Obj *CONST objv[] /* Command arguments */
1762 ){
1763 TestCollationX *p;
1764 sqlite3 *db;
1765 int rc;
1766
1767 if( objc!=5 ){
1768 Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE NAME CMP-PROC DEL-PROC");
1769 return TCL_ERROR;
1770 }
1771 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1772
1773 p = (TestCollationX *)sqlite3_malloc(sizeof(TestCollationX));
1774 p->pCmp = objv[3];
1775 p->pDel = objv[4];
1776 p->interp = interp;
1777 Tcl_IncrRefCount(p->pCmp);
1778 Tcl_IncrRefCount(p->pDel);
1779
1780 rc = sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), 16,
1781 (void *)p, testCreateCollationCmp, testCreateCollationDel
1782 );
1783 if( rc!=SQLITE_MISUSE ){
1784 Tcl_AppendResult(interp, "sqlite3_create_collate_v2() failed to detect "
1785 "an invalid encoding", (char*)0);
1786 return TCL_ERROR;
1787 }
1788 rc = sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), SQLITE_UTF8,
1789 (void *)p, testCreateCollationCmp, testCreateCollationDel
1790 );
1791 return TCL_OK;
1792 }
1793
1794 /*
1795 ** USAGE: sqlite3_create_function_v2 DB NAME NARG ENC ?SWITCHES?
1796 **
1797 ** Available switches are:
1798 **
1799 ** -func SCRIPT
1800 ** -step SCRIPT
1801 ** -final SCRIPT
1802 ** -destroy SCRIPT
1803 */
1804 typedef struct CreateFunctionV2 CreateFunctionV2;
1805 struct CreateFunctionV2 {
1806 Tcl_Interp *interp;
1807 Tcl_Obj *pFunc; /* Script for function invocation */
1808 Tcl_Obj *pStep; /* Script for agg. step invocation */
1809 Tcl_Obj *pFinal; /* Script for agg. finalization invocation */
1810 Tcl_Obj *pDestroy; /* Destructor script */
1811 };
cf2Func(sqlite3_context * ctx,int nArg,sqlite3_value ** aArg)1812 static void cf2Func(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){
1813 }
cf2Step(sqlite3_context * ctx,int nArg,sqlite3_value ** aArg)1814 static void cf2Step(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){
1815 }
cf2Final(sqlite3_context * ctx)1816 static void cf2Final(sqlite3_context *ctx){
1817 }
cf2Destroy(void * pUser)1818 static void cf2Destroy(void *pUser){
1819 CreateFunctionV2 *p = (CreateFunctionV2 *)pUser;
1820
1821 if( p->interp && p->pDestroy ){
1822 int rc = Tcl_EvalObjEx(p->interp, p->pDestroy, 0);
1823 if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp);
1824 }
1825
1826 if( p->pFunc ) Tcl_DecrRefCount(p->pFunc);
1827 if( p->pStep ) Tcl_DecrRefCount(p->pStep);
1828 if( p->pFinal ) Tcl_DecrRefCount(p->pFinal);
1829 if( p->pDestroy ) Tcl_DecrRefCount(p->pDestroy);
1830 sqlite3_free(p);
1831 }
test_create_function_v2(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1832 static int SQLITE_TCLAPI test_create_function_v2(
1833 ClientData clientData, /* Not used */
1834 Tcl_Interp *interp, /* The invoking TCL interpreter */
1835 int objc, /* Number of arguments */
1836 Tcl_Obj *CONST objv[] /* Command arguments */
1837 ){
1838 sqlite3 *db;
1839 const char *zFunc;
1840 int nArg;
1841 int enc;
1842 CreateFunctionV2 *p;
1843 int i;
1844 int rc;
1845
1846 struct EncTable {
1847 const char *zEnc;
1848 int enc;
1849 } aEnc[] = {
1850 {"utf8", SQLITE_UTF8 },
1851 {"utf16", SQLITE_UTF16 },
1852 {"utf16le", SQLITE_UTF16LE },
1853 {"utf16be", SQLITE_UTF16BE },
1854 {"any", SQLITE_ANY },
1855 {"0", 0 }
1856 };
1857
1858 if( objc<5 || (objc%2)==0 ){
1859 Tcl_WrongNumArgs(interp, 1, objv, "DB NAME NARG ENC SWITCHES...");
1860 return TCL_ERROR;
1861 }
1862
1863 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1864 zFunc = Tcl_GetString(objv[2]);
1865 if( Tcl_GetIntFromObj(interp, objv[3], &nArg) ) return TCL_ERROR;
1866 if( Tcl_GetIndexFromObjStruct(interp, objv[4], aEnc, sizeof(aEnc[0]),
1867 "encoding", 0, &enc)
1868 ){
1869 return TCL_ERROR;
1870 }
1871 enc = aEnc[enc].enc;
1872
1873 p = sqlite3_malloc(sizeof(CreateFunctionV2));
1874 assert( p );
1875 memset(p, 0, sizeof(CreateFunctionV2));
1876 p->interp = interp;
1877
1878 for(i=5; i<objc; i+=2){
1879 int iSwitch;
1880 const char *azSwitch[] = {"-func", "-step", "-final", "-destroy", 0};
1881 if( Tcl_GetIndexFromObj(interp, objv[i], azSwitch, "switch", 0, &iSwitch) ){
1882 sqlite3_free(p);
1883 return TCL_ERROR;
1884 }
1885
1886 switch( iSwitch ){
1887 case 0: p->pFunc = objv[i+1]; break;
1888 case 1: p->pStep = objv[i+1]; break;
1889 case 2: p->pFinal = objv[i+1]; break;
1890 case 3: p->pDestroy = objv[i+1]; break;
1891 }
1892 }
1893 if( p->pFunc ) p->pFunc = Tcl_DuplicateObj(p->pFunc);
1894 if( p->pStep ) p->pStep = Tcl_DuplicateObj(p->pStep);
1895 if( p->pFinal ) p->pFinal = Tcl_DuplicateObj(p->pFinal);
1896 if( p->pDestroy ) p->pDestroy = Tcl_DuplicateObj(p->pDestroy);
1897
1898 if( p->pFunc ) Tcl_IncrRefCount(p->pFunc);
1899 if( p->pStep ) Tcl_IncrRefCount(p->pStep);
1900 if( p->pFinal ) Tcl_IncrRefCount(p->pFinal);
1901 if( p->pDestroy ) Tcl_IncrRefCount(p->pDestroy);
1902
1903 rc = sqlite3_create_function_v2(db, zFunc, nArg, enc, (void *)p,
1904 (p->pFunc ? cf2Func : 0),
1905 (p->pStep ? cf2Step : 0),
1906 (p->pFinal ? cf2Final : 0),
1907 cf2Destroy
1908 );
1909 if( rc!=SQLITE_OK ){
1910 Tcl_ResetResult(interp);
1911 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
1912 return TCL_ERROR;
1913 }
1914 return TCL_OK;
1915 }
1916
1917 /*
1918 ** Usage: sqlite3_load_extension DB-HANDLE FILE ?PROC?
1919 */
test_load_extension(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1920 static int SQLITE_TCLAPI test_load_extension(
1921 ClientData clientData, /* Not used */
1922 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1923 int objc, /* Number of arguments */
1924 Tcl_Obj *CONST objv[] /* Command arguments */
1925 ){
1926 Tcl_CmdInfo cmdInfo;
1927 sqlite3 *db;
1928 int rc;
1929 char *zDb;
1930 char *zFile;
1931 char *zProc = 0;
1932 char *zErr = 0;
1933
1934 if( objc!=4 && objc!=3 ){
1935 Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE FILE ?PROC?");
1936 return TCL_ERROR;
1937 }
1938 zDb = Tcl_GetString(objv[1]);
1939 zFile = Tcl_GetString(objv[2]);
1940 if( objc==4 ){
1941 zProc = Tcl_GetString(objv[3]);
1942 }
1943
1944 /* Extract the C database handle from the Tcl command name */
1945 if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
1946 Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0);
1947 return TCL_ERROR;
1948 }
1949 db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
1950 assert(db);
1951
1952 /* Call the underlying C function. If an error occurs, set rc to
1953 ** TCL_ERROR and load any error string into the interpreter. If no
1954 ** error occurs, set rc to TCL_OK.
1955 */
1956 #ifdef SQLITE_OMIT_LOAD_EXTENSION
1957 rc = SQLITE_ERROR;
1958 zErr = sqlite3_mprintf("this build omits sqlite3_load_extension()");
1959 (void)zProc;
1960 (void)zFile;
1961 #else
1962 rc = sqlite3_load_extension(db, zFile, zProc, &zErr);
1963 #endif
1964 if( rc!=SQLITE_OK ){
1965 Tcl_SetResult(interp, zErr ? zErr : "", TCL_VOLATILE);
1966 rc = TCL_ERROR;
1967 }else{
1968 rc = TCL_OK;
1969 }
1970 sqlite3_free(zErr);
1971
1972 return rc;
1973 }
1974
1975 /*
1976 ** Usage: sqlite3_enable_load_extension DB-HANDLE ONOFF
1977 */
test_enable_load(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])1978 static int SQLITE_TCLAPI test_enable_load(
1979 ClientData clientData, /* Not used */
1980 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1981 int objc, /* Number of arguments */
1982 Tcl_Obj *CONST objv[] /* Command arguments */
1983 ){
1984 Tcl_CmdInfo cmdInfo;
1985 sqlite3 *db;
1986 char *zDb;
1987 int onoff;
1988
1989 if( objc!=3 ){
1990 Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE ONOFF");
1991 return TCL_ERROR;
1992 }
1993 zDb = Tcl_GetString(objv[1]);
1994
1995 /* Extract the C database handle from the Tcl command name */
1996 if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
1997 Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0);
1998 return TCL_ERROR;
1999 }
2000 db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
2001 assert(db);
2002
2003 /* Get the onoff parameter */
2004 if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){
2005 return TCL_ERROR;
2006 }
2007
2008 #ifdef SQLITE_OMIT_LOAD_EXTENSION
2009 Tcl_AppendResult(interp, "this build omits sqlite3_load_extension()");
2010 return TCL_ERROR;
2011 #else
2012 sqlite3_enable_load_extension(db, onoff);
2013 return TCL_OK;
2014 #endif
2015 }
2016
2017 /*
2018 ** Usage: sqlite_abort
2019 **
2020 ** Shutdown the process immediately. This is not a clean shutdown.
2021 ** This command is used to test the recoverability of a database in
2022 ** the event of a program crash.
2023 */
sqlite_abort(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)2024 static int SQLITE_TCLAPI sqlite_abort(
2025 void *NotUsed,
2026 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2027 int argc, /* Number of arguments */
2028 char **argv /* Text of each argument */
2029 ){
2030 #if defined(_MSC_VER)
2031 /* We do this, otherwise the test will halt with a popup message
2032 * that we have to click away before the test will continue.
2033 */
2034 _set_abort_behavior( 0, _CALL_REPORTFAULT );
2035 #endif
2036 exit(255);
2037 assert( interp==0 ); /* This will always fail */
2038 return TCL_OK;
2039 }
2040
2041 /*
2042 ** The following routine is a user-defined SQL function whose purpose
2043 ** is to test the sqlite_set_result() API.
2044 */
testFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)2045 static void testFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
2046 while( argc>=2 ){
2047 const char *zArg0 = (char*)sqlite3_value_text(argv[0]);
2048 if( zArg0 ){
2049 if( 0==sqlite3StrICmp(zArg0, "int") ){
2050 sqlite3_result_int(context, sqlite3_value_int(argv[1]));
2051 }else if( sqlite3StrICmp(zArg0,"int64")==0 ){
2052 sqlite3_result_int64(context, sqlite3_value_int64(argv[1]));
2053 }else if( sqlite3StrICmp(zArg0,"string")==0 ){
2054 sqlite3_result_text(context, (char*)sqlite3_value_text(argv[1]), -1,
2055 SQLITE_TRANSIENT);
2056 }else if( sqlite3StrICmp(zArg0,"double")==0 ){
2057 sqlite3_result_double(context, sqlite3_value_double(argv[1]));
2058 }else if( sqlite3StrICmp(zArg0,"null")==0 ){
2059 sqlite3_result_null(context);
2060 }else if( sqlite3StrICmp(zArg0,"value")==0 ){
2061 sqlite3_result_value(context, argv[sqlite3_value_int(argv[1])]);
2062 }else{
2063 goto error_out;
2064 }
2065 }else{
2066 goto error_out;
2067 }
2068 argc -= 2;
2069 argv += 2;
2070 }
2071 return;
2072
2073 error_out:
2074 sqlite3_result_error(context,"first argument should be one of: "
2075 "int int64 string double null value", -1);
2076 }
2077
2078 /*
2079 ** Usage: sqlite_register_test_function DB NAME
2080 **
2081 ** Register the test SQL function on the database DB under the name NAME.
2082 */
test_register_func(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)2083 static int SQLITE_TCLAPI test_register_func(
2084 void *NotUsed,
2085 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2086 int argc, /* Number of arguments */
2087 char **argv /* Text of each argument */
2088 ){
2089 sqlite3 *db;
2090 int rc;
2091 if( argc!=3 ){
2092 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2093 " DB FUNCTION-NAME", 0);
2094 return TCL_ERROR;
2095 }
2096 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
2097 rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0,
2098 testFunc, 0, 0);
2099 if( rc!=0 ){
2100 Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
2101 return TCL_ERROR;
2102 }
2103 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
2104 return TCL_OK;
2105 }
2106
2107 /*
2108 ** Usage: sqlite3_finalize STMT
2109 **
2110 ** Finalize a statement handle.
2111 */
test_finalize(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2112 static int SQLITE_TCLAPI test_finalize(
2113 void * clientData,
2114 Tcl_Interp *interp,
2115 int objc,
2116 Tcl_Obj *CONST objv[]
2117 ){
2118 sqlite3_stmt *pStmt;
2119 int rc;
2120 sqlite3 *db = 0;
2121
2122 if( objc!=2 ){
2123 Tcl_AppendResult(interp, "wrong # args: should be \"",
2124 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
2125 return TCL_ERROR;
2126 }
2127
2128 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2129
2130 if( pStmt ){
2131 db = StmtToDb(pStmt);
2132 }
2133 rc = sqlite3_finalize(pStmt);
2134 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
2135 if( db && sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
2136 return TCL_OK;
2137 }
2138
2139 /*
2140 ** Usage: sqlite3_stmt_status STMT CODE RESETFLAG
2141 **
2142 ** Get the value of a status counter from a statement.
2143 */
test_stmt_status(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2144 static int SQLITE_TCLAPI test_stmt_status(
2145 void * clientData,
2146 Tcl_Interp *interp,
2147 int objc,
2148 Tcl_Obj *CONST objv[]
2149 ){
2150 int iValue;
2151 int i, op = 0, resetFlag;
2152 const char *zOpName;
2153 sqlite3_stmt *pStmt;
2154
2155 static const struct {
2156 const char *zName;
2157 int op;
2158 } aOp[] = {
2159 { "SQLITE_STMTSTATUS_FULLSCAN_STEP", SQLITE_STMTSTATUS_FULLSCAN_STEP },
2160 { "SQLITE_STMTSTATUS_SORT", SQLITE_STMTSTATUS_SORT },
2161 { "SQLITE_STMTSTATUS_AUTOINDEX", SQLITE_STMTSTATUS_AUTOINDEX },
2162 { "SQLITE_STMTSTATUS_VM_STEP", SQLITE_STMTSTATUS_VM_STEP },
2163 { "SQLITE_STMTSTATUS_REPREPARE", SQLITE_STMTSTATUS_REPREPARE },
2164 { "SQLITE_STMTSTATUS_RUN", SQLITE_STMTSTATUS_RUN },
2165 { "SQLITE_STMTSTATUS_MEMUSED", SQLITE_STMTSTATUS_MEMUSED },
2166 };
2167 if( objc!=4 ){
2168 Tcl_WrongNumArgs(interp, 1, objv, "STMT PARAMETER RESETFLAG");
2169 return TCL_ERROR;
2170 }
2171 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2172 zOpName = Tcl_GetString(objv[2]);
2173 for(i=0; i<ArraySize(aOp); i++){
2174 if( strcmp(aOp[i].zName, zOpName)==0 ){
2175 op = aOp[i].op;
2176 break;
2177 }
2178 }
2179 if( i>=ArraySize(aOp) ){
2180 if( Tcl_GetIntFromObj(interp, objv[2], &op) ) return TCL_ERROR;
2181 }
2182 if( Tcl_GetBooleanFromObj(interp, objv[3], &resetFlag) ) return TCL_ERROR;
2183 iValue = sqlite3_stmt_status(pStmt, op, resetFlag);
2184 Tcl_SetObjResult(interp, Tcl_NewIntObj(iValue));
2185 return TCL_OK;
2186 }
2187
2188 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2189 /*
2190 ** Usage: sqlite3_stmt_scanstatus STMT IDX
2191 */
test_stmt_scanstatus(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2192 static int SQLITE_TCLAPI test_stmt_scanstatus(
2193 void * clientData,
2194 Tcl_Interp *interp,
2195 int objc,
2196 Tcl_Obj *CONST objv[]
2197 ){
2198 sqlite3_stmt *pStmt; /* First argument */
2199 int idx; /* Second argument */
2200
2201 const char *zName;
2202 const char *zExplain;
2203 sqlite3_int64 nLoop;
2204 sqlite3_int64 nVisit;
2205 double rEst;
2206 int res;
2207
2208 if( objc!=3 ){
2209 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX");
2210 return TCL_ERROR;
2211 }
2212 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2213 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
2214
2215 res = sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop);
2216 if( res==0 ){
2217 Tcl_Obj *pRet = Tcl_NewObj();
2218 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nLoop", -1));
2219 Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nLoop));
2220 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
2221 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nVisit", -1));
2222 Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nVisit));
2223 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_EST, (void*)&rEst);
2224 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nEst", -1));
2225 Tcl_ListObjAppendElement(0, pRet, Tcl_NewDoubleObj(rEst));
2226 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NAME, (void*)&zName);
2227 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zName", -1));
2228 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zName, -1));
2229 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
2230 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zExplain", -1));
2231 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zExplain, -1));
2232 Tcl_SetObjResult(interp, pRet);
2233 }else{
2234 Tcl_ResetResult(interp);
2235 }
2236 return TCL_OK;
2237 }
2238
2239 /*
2240 ** Usage: sqlite3_stmt_scanstatus_reset STMT
2241 */
test_stmt_scanstatus_reset(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2242 static int SQLITE_TCLAPI test_stmt_scanstatus_reset(
2243 void * clientData,
2244 Tcl_Interp *interp,
2245 int objc,
2246 Tcl_Obj *CONST objv[]
2247 ){
2248 sqlite3_stmt *pStmt; /* First argument */
2249 if( objc!=2 ){
2250 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
2251 return TCL_ERROR;
2252 }
2253 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2254 sqlite3_stmt_scanstatus_reset(pStmt);
2255 return TCL_OK;
2256 }
2257 #endif
2258
2259 #ifdef SQLITE_ENABLE_SQLLOG
2260 /*
2261 ** Usage: sqlite3_config_sqllog
2262 **
2263 ** Zero the SQLITE_CONFIG_SQLLOG configuration
2264 */
test_config_sqllog(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2265 static int SQLITE_TCLAPI test_config_sqllog(
2266 void * clientData,
2267 Tcl_Interp *interp,
2268 int objc,
2269 Tcl_Obj *CONST objv[]
2270 ){
2271 if( objc!=1 ){
2272 Tcl_WrongNumArgs(interp, 1, objv, "");
2273 return TCL_ERROR;
2274 }
2275 sqlite3_config(SQLITE_CONFIG_SQLLOG, 0, 0);
2276 return TCL_OK;
2277 }
2278 #endif
2279
2280 /*
2281 ** Usage: sqlite3_config_sorterref
2282 **
2283 ** Set the SQLITE_CONFIG_SORTERREF_SIZE configuration option
2284 */
test_config_sorterref(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2285 static int SQLITE_TCLAPI test_config_sorterref(
2286 void * clientData,
2287 Tcl_Interp *interp,
2288 int objc,
2289 Tcl_Obj *CONST objv[]
2290 ){
2291 int iVal;
2292 if( objc!=2 ){
2293 Tcl_WrongNumArgs(interp, 1, objv, "NBYTE");
2294 return TCL_ERROR;
2295 }
2296 if( Tcl_GetIntFromObj(interp, objv[1], &iVal) ) return TCL_ERROR;
2297 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, iVal);
2298 return TCL_OK;
2299 }
2300
2301 /*
2302 ** Usage: vfs_current_time_int64
2303 **
2304 ** Return the value returned by the default VFS's xCurrentTimeInt64 method.
2305 */
vfsCurrentTimeInt64(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2306 static int SQLITE_TCLAPI vfsCurrentTimeInt64(
2307 void * clientData,
2308 Tcl_Interp *interp,
2309 int objc,
2310 Tcl_Obj *CONST objv[]
2311 ){
2312 i64 t;
2313 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
2314 if( objc!=1 ){
2315 Tcl_WrongNumArgs(interp, 1, objv, "");
2316 return TCL_ERROR;
2317 }
2318 pVfs->xCurrentTimeInt64(pVfs, &t);
2319 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(t));
2320 return TCL_OK;
2321 }
2322
2323 #ifdef SQLITE_ENABLE_SNAPSHOT
2324 /*
2325 ** Usage: sqlite3_snapshot_get DB DBNAME
2326 */
test_snapshot_get(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2327 static int SQLITE_TCLAPI test_snapshot_get(
2328 void * clientData,
2329 Tcl_Interp *interp,
2330 int objc,
2331 Tcl_Obj *CONST objv[]
2332 ){
2333 int rc;
2334 sqlite3 *db;
2335 char *zName;
2336 sqlite3_snapshot *pSnapshot = 0;
2337
2338 if( objc!=3 ){
2339 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
2340 return TCL_ERROR;
2341 }
2342 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2343 zName = Tcl_GetString(objv[2]);
2344
2345 rc = sqlite3_snapshot_get(db, zName, &pSnapshot);
2346 if( rc!=SQLITE_OK ){
2347 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
2348 return TCL_ERROR;
2349 }else{
2350 char zBuf[100];
2351 if( sqlite3TestMakePointerStr(interp, zBuf, pSnapshot) ) return TCL_ERROR;
2352 Tcl_SetObjResult(interp, Tcl_NewStringObj(zBuf, -1));
2353 }
2354 return TCL_OK;
2355 }
2356 #endif /* SQLITE_ENABLE_SNAPSHOT */
2357
2358 #ifdef SQLITE_ENABLE_SNAPSHOT
2359 /*
2360 ** Usage: sqlite3_snapshot_recover DB DBNAME
2361 */
test_snapshot_recover(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2362 static int SQLITE_TCLAPI test_snapshot_recover(
2363 void * clientData,
2364 Tcl_Interp *interp,
2365 int objc,
2366 Tcl_Obj *CONST objv[]
2367 ){
2368 int rc;
2369 sqlite3 *db;
2370 char *zName;
2371
2372 if( objc!=3 ){
2373 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
2374 return TCL_ERROR;
2375 }
2376 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2377 zName = Tcl_GetString(objv[2]);
2378
2379 rc = sqlite3_snapshot_recover(db, zName);
2380 if( rc!=SQLITE_OK ){
2381 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
2382 return TCL_ERROR;
2383 }else{
2384 Tcl_ResetResult(interp);
2385 }
2386 return TCL_OK;
2387 }
2388 #endif /* SQLITE_ENABLE_SNAPSHOT */
2389
2390 #ifdef SQLITE_ENABLE_SNAPSHOT
2391 /*
2392 ** Usage: sqlite3_snapshot_open DB DBNAME SNAPSHOT
2393 */
test_snapshot_open(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2394 static int SQLITE_TCLAPI test_snapshot_open(
2395 void * clientData,
2396 Tcl_Interp *interp,
2397 int objc,
2398 Tcl_Obj *CONST objv[]
2399 ){
2400 int rc;
2401 sqlite3 *db;
2402 char *zName;
2403 sqlite3_snapshot *pSnapshot;
2404
2405 if( objc!=4 ){
2406 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SNAPSHOT");
2407 return TCL_ERROR;
2408 }
2409 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2410 zName = Tcl_GetString(objv[2]);
2411 pSnapshot = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[3]));
2412
2413 rc = sqlite3_snapshot_open(db, zName, pSnapshot);
2414 if( rc!=SQLITE_OK ){
2415 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
2416 return TCL_ERROR;
2417 }else{
2418 Tcl_ResetResult(interp);
2419 }
2420 return TCL_OK;
2421 }
2422 #endif /* SQLITE_ENABLE_SNAPSHOT */
2423
2424 #ifdef SQLITE_ENABLE_SNAPSHOT
2425 /*
2426 ** Usage: sqlite3_snapshot_free SNAPSHOT
2427 */
test_snapshot_free(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2428 static int SQLITE_TCLAPI test_snapshot_free(
2429 void * clientData,
2430 Tcl_Interp *interp,
2431 int objc,
2432 Tcl_Obj *CONST objv[]
2433 ){
2434 sqlite3_snapshot *pSnapshot;
2435 if( objc!=2 ){
2436 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT");
2437 return TCL_ERROR;
2438 }
2439 pSnapshot = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
2440 sqlite3_snapshot_free(pSnapshot);
2441 return TCL_OK;
2442 }
2443 #endif /* SQLITE_ENABLE_SNAPSHOT */
2444
2445 #ifdef SQLITE_ENABLE_SNAPSHOT
2446 /*
2447 ** Usage: sqlite3_snapshot_cmp SNAPSHOT1 SNAPSHOT2
2448 */
test_snapshot_cmp(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2449 static int SQLITE_TCLAPI test_snapshot_cmp(
2450 void * clientData,
2451 Tcl_Interp *interp,
2452 int objc,
2453 Tcl_Obj *CONST objv[]
2454 ){
2455 int res;
2456 sqlite3_snapshot *p1;
2457 sqlite3_snapshot *p2;
2458 if( objc!=3 ){
2459 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2");
2460 return TCL_ERROR;
2461 }
2462 p1 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
2463 p2 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[2]));
2464 res = sqlite3_snapshot_cmp(p1, p2);
2465 Tcl_SetObjResult(interp, Tcl_NewIntObj(res));
2466 return TCL_OK;
2467 }
2468 #endif /* SQLITE_ENABLE_SNAPSHOT */
2469
2470 #ifdef SQLITE_ENABLE_SNAPSHOT
2471 /*
2472 ** Usage: sqlite3_snapshot_get_blob DB DBNAME
2473 */
test_snapshot_get_blob(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2474 static int SQLITE_TCLAPI test_snapshot_get_blob(
2475 void * clientData,
2476 Tcl_Interp *interp,
2477 int objc,
2478 Tcl_Obj *CONST objv[]
2479 ){
2480 int rc;
2481 sqlite3 *db;
2482 char *zName;
2483 sqlite3_snapshot *pSnapshot = 0;
2484
2485 if( objc!=3 ){
2486 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
2487 return TCL_ERROR;
2488 }
2489 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2490 zName = Tcl_GetString(objv[2]);
2491
2492 rc = sqlite3_snapshot_get(db, zName, &pSnapshot);
2493 if( rc!=SQLITE_OK ){
2494 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
2495 return TCL_ERROR;
2496 }else{
2497 Tcl_SetObjResult(interp,
2498 Tcl_NewByteArrayObj((unsigned char*)pSnapshot, sizeof(sqlite3_snapshot))
2499 );
2500 sqlite3_snapshot_free(pSnapshot);
2501 }
2502 return TCL_OK;
2503 }
2504 #endif /* SQLITE_ENABLE_SNAPSHOT */
2505
2506 #ifdef SQLITE_ENABLE_SNAPSHOT
2507 /*
2508 ** Usage: sqlite3_snapshot_open_blob DB DBNAME SNAPSHOT
2509 */
test_snapshot_open_blob(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2510 static int SQLITE_TCLAPI test_snapshot_open_blob(
2511 void * clientData,
2512 Tcl_Interp *interp,
2513 int objc,
2514 Tcl_Obj *CONST objv[]
2515 ){
2516 int rc;
2517 sqlite3 *db;
2518 char *zName;
2519 unsigned char *pBlob;
2520 int nBlob;
2521
2522 if( objc!=4 ){
2523 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SNAPSHOT");
2524 return TCL_ERROR;
2525 }
2526 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2527 zName = Tcl_GetString(objv[2]);
2528 pBlob = Tcl_GetByteArrayFromObj(objv[3], &nBlob);
2529 if( nBlob!=sizeof(sqlite3_snapshot) ){
2530 Tcl_AppendResult(interp, "bad SNAPSHOT", 0);
2531 return TCL_ERROR;
2532 }
2533 rc = sqlite3_snapshot_open(db, zName, (sqlite3_snapshot*)pBlob);
2534 if( rc!=SQLITE_OK ){
2535 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
2536 return TCL_ERROR;
2537 }
2538 return TCL_OK;
2539 }
2540 #endif /* SQLITE_ENABLE_SNAPSHOT */
2541
2542 #ifdef SQLITE_ENABLE_SNAPSHOT
2543 /*
2544 ** Usage: sqlite3_snapshot_cmp_blob SNAPSHOT1 SNAPSHOT2
2545 */
test_snapshot_cmp_blob(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2546 static int SQLITE_TCLAPI test_snapshot_cmp_blob(
2547 void * clientData,
2548 Tcl_Interp *interp,
2549 int objc,
2550 Tcl_Obj *CONST objv[]
2551 ){
2552 int res;
2553 unsigned char *p1;
2554 unsigned char *p2;
2555 int n1;
2556 int n2;
2557
2558 if( objc!=3 ){
2559 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2");
2560 return TCL_ERROR;
2561 }
2562
2563 p1 = Tcl_GetByteArrayFromObj(objv[1], &n1);
2564 p2 = Tcl_GetByteArrayFromObj(objv[2], &n2);
2565
2566 if( n1!=sizeof(sqlite3_snapshot) || n1!=n2 ){
2567 Tcl_AppendResult(interp, "bad SNAPSHOT", 0);
2568 return TCL_ERROR;
2569 }
2570
2571 res = sqlite3_snapshot_cmp((sqlite3_snapshot*)p1, (sqlite3_snapshot*)p2);
2572 Tcl_SetObjResult(interp, Tcl_NewIntObj(res));
2573 return TCL_OK;
2574 }
2575 #endif /* SQLITE_ENABLE_SNAPSHOT */
2576
2577 /*
2578 ** Usage: sqlite3_delete_database FILENAME
2579 */
2580 int sqlite3_delete_database(const char*); /* in test_delete.c */
test_delete_database(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2581 static int SQLITE_TCLAPI test_delete_database(
2582 void * clientData,
2583 Tcl_Interp *interp,
2584 int objc,
2585 Tcl_Obj *CONST objv[]
2586 ){
2587 int rc;
2588 const char *zFile;
2589 if( objc!=2 ){
2590 Tcl_WrongNumArgs(interp, 1, objv, "FILE");
2591 return TCL_ERROR;
2592 }
2593 zFile = (const char*)Tcl_GetString(objv[1]);
2594 rc = sqlite3_delete_database(zFile);
2595
2596 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
2597 return TCL_OK;
2598 }
2599
2600 /*
2601 ** Usage: atomic_batch_write PATH
2602 */
test_atomic_batch_write(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2603 static int SQLITE_TCLAPI test_atomic_batch_write(
2604 void * clientData,
2605 Tcl_Interp *interp,
2606 int objc,
2607 Tcl_Obj *CONST objv[]
2608 ){
2609 char *zFile = 0; /* Path to file to test */
2610 sqlite3 *db = 0; /* Database handle */
2611 sqlite3_file *pFd = 0; /* SQLite fd open on zFile */
2612 int bRes = 0; /* Integer result of this command */
2613 int dc = 0; /* Device-characteristics mask */
2614 int rc; /* sqlite3_open() return code */
2615
2616 if( objc!=2 ){
2617 Tcl_WrongNumArgs(interp, 1, objv, "PATH");
2618 return TCL_ERROR;
2619 }
2620 zFile = Tcl_GetString(objv[1]);
2621
2622 rc = sqlite3_open(zFile, &db);
2623 if( rc!=SQLITE_OK ){
2624 Tcl_AppendResult(interp, sqlite3_errmsg(db), 0);
2625 sqlite3_close(db);
2626 return TCL_ERROR;
2627 }
2628
2629 rc = sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, (void*)&pFd);
2630 dc = pFd->pMethods->xDeviceCharacteristics(pFd);
2631 if( dc & SQLITE_IOCAP_BATCH_ATOMIC ){
2632 bRes = 1;
2633 }
2634
2635 Tcl_SetObjResult(interp, Tcl_NewIntObj(bRes));
2636 sqlite3_close(db);
2637 return TCL_OK;
2638 }
2639
2640 /*
2641 ** Usage: sqlite3_next_stmt DB STMT
2642 **
2643 ** Return the next statment in sequence after STMT.
2644 */
test_next_stmt(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2645 static int SQLITE_TCLAPI test_next_stmt(
2646 void * clientData,
2647 Tcl_Interp *interp,
2648 int objc,
2649 Tcl_Obj *CONST objv[]
2650 ){
2651 sqlite3_stmt *pStmt;
2652 sqlite3 *db = 0;
2653 char zBuf[50];
2654
2655 if( objc!=3 ){
2656 Tcl_AppendResult(interp, "wrong # args: should be \"",
2657 Tcl_GetStringFromObj(objv[0], 0), " DB STMT", 0);
2658 return TCL_ERROR;
2659 }
2660
2661 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2662 if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt) ) return TCL_ERROR;
2663 pStmt = sqlite3_next_stmt(db, pStmt);
2664 if( pStmt ){
2665 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
2666 Tcl_AppendResult(interp, zBuf, 0);
2667 }
2668 return TCL_OK;
2669 }
2670
2671 /*
2672 ** Usage: sqlite3_stmt_readonly STMT
2673 **
2674 ** Return true if STMT is a NULL pointer or a pointer to a statement
2675 ** that is guaranteed to leave the database unmodified.
2676 */
test_stmt_readonly(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2677 static int SQLITE_TCLAPI test_stmt_readonly(
2678 void * clientData,
2679 Tcl_Interp *interp,
2680 int objc,
2681 Tcl_Obj *CONST objv[]
2682 ){
2683 sqlite3_stmt *pStmt;
2684 int rc;
2685
2686 if( objc!=2 ){
2687 Tcl_AppendResult(interp, "wrong # args: should be \"",
2688 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
2689 return TCL_ERROR;
2690 }
2691
2692 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2693 rc = sqlite3_stmt_readonly(pStmt);
2694 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc));
2695 return TCL_OK;
2696 }
2697
2698 /*
2699 ** Usage: sqlite3_stmt_isexplain STMT
2700 **
2701 ** Return 1, 2, or 0 respectively if STMT is an EXPLAIN statement, an
2702 ** EXPLAIN QUERY PLAN statement or an ordinary statement or NULL pointer.
2703 */
test_stmt_isexplain(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2704 static int SQLITE_TCLAPI test_stmt_isexplain(
2705 void * clientData,
2706 Tcl_Interp *interp,
2707 int objc,
2708 Tcl_Obj *CONST objv[]
2709 ){
2710 sqlite3_stmt *pStmt;
2711 int rc;
2712
2713 if( objc!=2 ){
2714 Tcl_AppendResult(interp, "wrong # args: should be \"",
2715 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
2716 return TCL_ERROR;
2717 }
2718
2719 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2720 rc = sqlite3_stmt_isexplain(pStmt);
2721 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
2722 return TCL_OK;
2723 }
2724
2725 /*
2726 ** Usage: sqlite3_stmt_busy STMT
2727 **
2728 ** Return true if STMT is a non-NULL pointer to a statement
2729 ** that has been stepped but not to completion.
2730 */
test_stmt_busy(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2731 static int SQLITE_TCLAPI test_stmt_busy(
2732 void * clientData,
2733 Tcl_Interp *interp,
2734 int objc,
2735 Tcl_Obj *CONST objv[]
2736 ){
2737 sqlite3_stmt *pStmt;
2738 int rc;
2739
2740 if( objc!=2 ){
2741 Tcl_AppendResult(interp, "wrong # args: should be \"",
2742 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
2743 return TCL_ERROR;
2744 }
2745
2746 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2747 rc = sqlite3_stmt_busy(pStmt);
2748 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc));
2749 return TCL_OK;
2750 }
2751
2752 /*
2753 ** Usage: uses_stmt_journal STMT
2754 **
2755 ** Return true if STMT uses a statement journal.
2756 */
uses_stmt_journal(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2757 static int SQLITE_TCLAPI uses_stmt_journal(
2758 void * clientData,
2759 Tcl_Interp *interp,
2760 int objc,
2761 Tcl_Obj *CONST objv[]
2762 ){
2763 sqlite3_stmt *pStmt;
2764
2765 if( objc!=2 ){
2766 Tcl_AppendResult(interp, "wrong # args: should be \"",
2767 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
2768 return TCL_ERROR;
2769 }
2770
2771 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2772 sqlite3_stmt_readonly(pStmt);
2773 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(((Vdbe *)pStmt)->usesStmtJournal));
2774 return TCL_OK;
2775 }
2776
2777
2778 /*
2779 ** Usage: sqlite3_reset STMT
2780 **
2781 ** Reset a statement handle.
2782 */
test_reset(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2783 static int SQLITE_TCLAPI test_reset(
2784 void * clientData,
2785 Tcl_Interp *interp,
2786 int objc,
2787 Tcl_Obj *CONST objv[]
2788 ){
2789 sqlite3_stmt *pStmt;
2790 int rc;
2791
2792 if( objc!=2 ){
2793 Tcl_AppendResult(interp, "wrong # args: should be \"",
2794 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
2795 return TCL_ERROR;
2796 }
2797
2798 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2799
2800 rc = sqlite3_reset(pStmt);
2801 if( pStmt && sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ){
2802 return TCL_ERROR;
2803 }
2804 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
2805 /*
2806 if( rc ){
2807 return TCL_ERROR;
2808 }
2809 */
2810 return TCL_OK;
2811 }
2812
2813 /*
2814 ** Usage: sqlite3_expired STMT
2815 **
2816 ** Return TRUE if a recompilation of the statement is recommended.
2817 */
test_expired(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2818 static int SQLITE_TCLAPI test_expired(
2819 void * clientData,
2820 Tcl_Interp *interp,
2821 int objc,
2822 Tcl_Obj *CONST objv[]
2823 ){
2824 #ifndef SQLITE_OMIT_DEPRECATED
2825 sqlite3_stmt *pStmt;
2826 if( objc!=2 ){
2827 Tcl_AppendResult(interp, "wrong # args: should be \"",
2828 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
2829 return TCL_ERROR;
2830 }
2831 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
2832 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(sqlite3_expired(pStmt)));
2833 #endif
2834 return TCL_OK;
2835 }
2836
2837 /*
2838 ** Usage: sqlite3_transfer_bindings FROMSTMT TOSTMT
2839 **
2840 ** Transfer all bindings from FROMSTMT over to TOSTMT
2841 */
test_transfer_bind(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2842 static int SQLITE_TCLAPI test_transfer_bind(
2843 void * clientData,
2844 Tcl_Interp *interp,
2845 int objc,
2846 Tcl_Obj *CONST objv[]
2847 ){
2848 #ifndef SQLITE_OMIT_DEPRECATED
2849 sqlite3_stmt *pStmt1, *pStmt2;
2850 if( objc!=3 ){
2851 Tcl_AppendResult(interp, "wrong # args: should be \"",
2852 Tcl_GetStringFromObj(objv[0], 0), " FROM-STMT TO-STMT", 0);
2853 return TCL_ERROR;
2854 }
2855 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt1)) return TCL_ERROR;
2856 if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt2)) return TCL_ERROR;
2857 Tcl_SetObjResult(interp,
2858 Tcl_NewIntObj(sqlite3_transfer_bindings(pStmt1,pStmt2)));
2859 #endif
2860 return TCL_OK;
2861 }
2862
2863 /*
2864 ** Usage: sqlite3_changes DB
2865 **
2866 ** Return the number of changes made to the database by the last SQL
2867 ** execution.
2868 */
test_changes(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])2869 static int SQLITE_TCLAPI test_changes(
2870 void * clientData,
2871 Tcl_Interp *interp,
2872 int objc,
2873 Tcl_Obj *CONST objv[]
2874 ){
2875 sqlite3 *db;
2876 if( objc!=2 ){
2877 Tcl_AppendResult(interp, "wrong # args: should be \"",
2878 Tcl_GetString(objv[0]), " DB", 0);
2879 return TCL_ERROR;
2880 }
2881 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
2882 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_changes(db)));
2883 return TCL_OK;
2884 }
2885
2886 /*
2887 ** This is the "static_bind_value" that variables are bound to when
2888 ** the FLAG option of sqlite3_bind is "static"
2889 */
2890 static char *sqlite_static_bind_value = 0;
2891 static int sqlite_static_bind_nbyte = 0;
2892
2893 /*
2894 ** Usage: sqlite3_bind VM IDX VALUE FLAGS
2895 **
2896 ** Sets the value of the IDX-th occurrence of "?" in the original SQL
2897 ** string. VALUE is the new value. If FLAGS=="null" then VALUE is
2898 ** ignored and the value is set to NULL. If FLAGS=="static" then
2899 ** the value is set to the value of a static variable named
2900 ** "sqlite_static_bind_value". If FLAGS=="normal" then a copy
2901 ** of the VALUE is made. If FLAGS=="blob10" then a VALUE is ignored
2902 ** an a 10-byte blob "abc\000xyz\000pq" is inserted.
2903 */
test_bind(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)2904 static int SQLITE_TCLAPI test_bind(
2905 void *NotUsed,
2906 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2907 int argc, /* Number of arguments */
2908 char **argv /* Text of each argument */
2909 ){
2910 sqlite3_stmt *pStmt;
2911 int rc;
2912 int idx;
2913 if( argc!=5 ){
2914 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2915 " VM IDX VALUE (null|static|normal)\"", 0);
2916 return TCL_ERROR;
2917 }
2918 if( getStmtPointer(interp, argv[1], &pStmt) ) return TCL_ERROR;
2919 if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR;
2920 if( strcmp(argv[4],"null")==0 ){
2921 rc = sqlite3_bind_null(pStmt, idx);
2922 }else if( strcmp(argv[4],"static")==0 ){
2923 rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, -1, 0);
2924 }else if( strcmp(argv[4],"static-nbytes")==0 ){
2925 rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value,
2926 sqlite_static_bind_nbyte, 0);
2927 }else if( strcmp(argv[4],"normal")==0 ){
2928 rc = sqlite3_bind_text(pStmt, idx, argv[3], -1, SQLITE_TRANSIENT);
2929 }else if( strcmp(argv[4],"blob10")==0 ){
2930 rc = sqlite3_bind_text(pStmt, idx, "abc\000xyz\000pq", 10, SQLITE_STATIC);
2931 }else{
2932 Tcl_AppendResult(interp, "4th argument should be "
2933 "\"null\" or \"static\" or \"normal\"", 0);
2934 return TCL_ERROR;
2935 }
2936 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
2937 if( rc ){
2938 char zBuf[50];
2939 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc);
2940 Tcl_AppendResult(interp, zBuf, sqlite3ErrStr(rc), 0);
2941 return TCL_ERROR;
2942 }
2943 return TCL_OK;
2944 }
2945
2946 #ifndef SQLITE_OMIT_UTF16
2947 /*
2948 ** Usage: add_test_collate <db ptr> <utf8> <utf16le> <utf16be>
2949 **
2950 ** This function is used to test that SQLite selects the correct collation
2951 ** sequence callback when multiple versions (for different text encodings)
2952 ** are available.
2953 **
2954 ** Calling this routine registers the collation sequence "test_collate"
2955 ** with database handle <db>. The second argument must be a list of three
2956 ** boolean values. If the first is true, then a version of test_collate is
2957 ** registered for UTF-8, if the second is true, a version is registered for
2958 ** UTF-16le, if the third is true, a UTF-16be version is available.
2959 ** Previous versions of test_collate are deleted.
2960 **
2961 ** The collation sequence test_collate is implemented by calling the
2962 ** following TCL script:
2963 **
2964 ** "test_collate <enc> <lhs> <rhs>"
2965 **
2966 ** The <lhs> and <rhs> are the two values being compared, encoded in UTF-8.
2967 ** The <enc> parameter is the encoding of the collation function that
2968 ** SQLite selected to call. The TCL test script implements the
2969 ** "test_collate" proc.
2970 **
2971 ** Note that this will only work with one interpreter at a time, as the
2972 ** interp pointer to use when evaluating the TCL script is stored in
2973 ** pTestCollateInterp.
2974 */
2975 static Tcl_Interp* pTestCollateInterp;
test_collate_func(void * pCtx,int nA,const void * zA,int nB,const void * zB)2976 static int test_collate_func(
2977 void *pCtx,
2978 int nA, const void *zA,
2979 int nB, const void *zB
2980 ){
2981 Tcl_Interp *i = pTestCollateInterp;
2982 int encin = SQLITE_PTR_TO_INT(pCtx);
2983 int res;
2984 int n;
2985
2986 sqlite3_value *pVal;
2987 Tcl_Obj *pX;
2988
2989 pX = Tcl_NewStringObj("test_collate", -1);
2990 Tcl_IncrRefCount(pX);
2991
2992 switch( encin ){
2993 case SQLITE_UTF8:
2994 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-8",-1));
2995 break;
2996 case SQLITE_UTF16LE:
2997 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16LE",-1));
2998 break;
2999 case SQLITE_UTF16BE:
3000 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16BE",-1));
3001 break;
3002 default:
3003 assert(0);
3004 }
3005
3006 sqlite3BeginBenignMalloc();
3007 pVal = sqlite3ValueNew(0);
3008 if( pVal ){
3009 sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC);
3010 n = sqlite3_value_bytes(pVal);
3011 Tcl_ListObjAppendElement(i,pX,
3012 Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
3013 sqlite3ValueSetStr(pVal, nB, zB, encin, SQLITE_STATIC);
3014 n = sqlite3_value_bytes(pVal);
3015 Tcl_ListObjAppendElement(i,pX,
3016 Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
3017 sqlite3ValueFree(pVal);
3018 }
3019 sqlite3EndBenignMalloc();
3020
3021 Tcl_EvalObjEx(i, pX, 0);
3022 Tcl_DecrRefCount(pX);
3023 Tcl_GetIntFromObj(i, Tcl_GetObjResult(i), &res);
3024 return res;
3025 }
test_collate(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3026 static int SQLITE_TCLAPI test_collate(
3027 void * clientData,
3028 Tcl_Interp *interp,
3029 int objc,
3030 Tcl_Obj *CONST objv[]
3031 ){
3032 sqlite3 *db;
3033 int val;
3034 sqlite3_value *pVal;
3035 int rc;
3036
3037 if( objc!=5 ) goto bad_args;
3038 pTestCollateInterp = interp;
3039 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
3040
3041 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
3042 rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF8,
3043 (void *)SQLITE_UTF8, val?test_collate_func:0);
3044 if( rc==SQLITE_OK ){
3045 const void *zUtf16;
3046 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
3047 rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF16LE,
3048 (void *)SQLITE_UTF16LE, val?test_collate_func:0);
3049 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR;
3050
3051 #if 0
3052 if( sqlite3_iMallocFail>0 ){
3053 sqlite3_iMallocFail++;
3054 }
3055 #endif
3056 sqlite3_mutex_enter(db->mutex);
3057 pVal = sqlite3ValueNew(db);
3058 sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
3059 zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
3060 if( db->mallocFailed ){
3061 rc = SQLITE_NOMEM;
3062 }else{
3063 rc = sqlite3_create_collation16(db, zUtf16, SQLITE_UTF16BE,
3064 (void *)SQLITE_UTF16BE, val?test_collate_func:0);
3065 }
3066 sqlite3ValueFree(pVal);
3067 sqlite3_mutex_leave(db->mutex);
3068 }
3069 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
3070
3071 if( rc!=SQLITE_OK ){
3072 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
3073 return TCL_ERROR;
3074 }
3075 return TCL_OK;
3076
3077 bad_args:
3078 Tcl_AppendResult(interp, "wrong # args: should be \"",
3079 Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0);
3080 return TCL_ERROR;
3081 }
3082
3083 /*
3084 ** Usage: add_test_utf16bin_collate <db ptr>
3085 **
3086 ** Add a utf-16 collation sequence named "utf16bin" to the database
3087 ** handle. This collation sequence compares arguments in the same way as the
3088 ** built-in collation "binary".
3089 */
test_utf16bin_collate_func(void * pCtx,int nA,const void * zA,int nB,const void * zB)3090 static int test_utf16bin_collate_func(
3091 void *pCtx,
3092 int nA, const void *zA,
3093 int nB, const void *zB
3094 ){
3095 int nCmp = (nA>nB ? nB : nA);
3096 int res = memcmp(zA, zB, nCmp);
3097 if( res==0 ) res = nA - nB;
3098 return res;
3099 }
test_utf16bin_collate(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3100 static int SQLITE_TCLAPI test_utf16bin_collate(
3101 void * clientData,
3102 Tcl_Interp *interp,
3103 int objc,
3104 Tcl_Obj *CONST objv[]
3105 ){
3106 sqlite3 *db;
3107 int rc;
3108
3109 if( objc!=2 ) goto bad_args;
3110 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
3111
3112 rc = sqlite3_create_collation(db, "utf16bin", SQLITE_UTF16, 0,
3113 test_utf16bin_collate_func
3114 );
3115 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
3116 return TCL_OK;
3117
3118 bad_args:
3119 Tcl_WrongNumArgs(interp, 1, objv, "DB");
3120 return TCL_ERROR;
3121 }
3122
3123 /*
3124 ** When the collation needed callback is invoked, record the name of
3125 ** the requested collating function here. The recorded name is linked
3126 ** to a TCL variable and used to make sure that the requested collation
3127 ** name is correct.
3128 */
3129 static char zNeededCollation[200];
3130 static char *pzNeededCollation = zNeededCollation;
3131
3132
3133 /*
3134 ** Called when a collating sequence is needed. Registered using
3135 ** sqlite3_collation_needed16().
3136 */
test_collate_needed_cb(void * pCtx,sqlite3 * db,int eTextRep,const void * pName)3137 static void test_collate_needed_cb(
3138 void *pCtx,
3139 sqlite3 *db,
3140 int eTextRep,
3141 const void *pName
3142 ){
3143 int enc = ENC(db);
3144 int i;
3145 char *z;
3146 for(z = (char*)pName, i=0; *z || z[1]; z++){
3147 if( *z ) zNeededCollation[i++] = *z;
3148 }
3149 zNeededCollation[i] = 0;
3150 sqlite3_create_collation(
3151 db, "test_collate", ENC(db), SQLITE_INT_TO_PTR(enc), test_collate_func);
3152 }
3153
3154 /*
3155 ** Usage: add_test_collate_needed DB
3156 */
test_collate_needed(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3157 static int SQLITE_TCLAPI test_collate_needed(
3158 void * clientData,
3159 Tcl_Interp *interp,
3160 int objc,
3161 Tcl_Obj *CONST objv[]
3162 ){
3163 sqlite3 *db;
3164 int rc;
3165
3166 if( objc!=2 ) goto bad_args;
3167 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
3168 rc = sqlite3_collation_needed16(db, 0, test_collate_needed_cb);
3169 zNeededCollation[0] = 0;
3170 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
3171 return TCL_OK;
3172
3173 bad_args:
3174 Tcl_WrongNumArgs(interp, 1, objv, "DB");
3175 return TCL_ERROR;
3176 }
3177
3178 /*
3179 ** tclcmd: add_alignment_test_collations DB
3180 **
3181 ** Add two new collating sequences to the database DB
3182 **
3183 ** utf16_aligned
3184 ** utf16_unaligned
3185 **
3186 ** Both collating sequences use the same sort order as BINARY.
3187 ** The only difference is that the utf16_aligned collating
3188 ** sequence is declared with the SQLITE_UTF16_ALIGNED flag.
3189 ** Both collating functions increment the unaligned utf16 counter
3190 ** whenever they see a string that begins on an odd byte boundary.
3191 */
3192 static int unaligned_string_counter = 0;
alignmentCollFunc(void * NotUsed,int nKey1,const void * pKey1,int nKey2,const void * pKey2)3193 static int alignmentCollFunc(
3194 void *NotUsed,
3195 int nKey1, const void *pKey1,
3196 int nKey2, const void *pKey2
3197 ){
3198 int rc, n;
3199 n = nKey1<nKey2 ? nKey1 : nKey2;
3200 if( nKey1>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey1))) ) unaligned_string_counter++;
3201 if( nKey2>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey2))) ) unaligned_string_counter++;
3202 rc = memcmp(pKey1, pKey2, n);
3203 if( rc==0 ){
3204 rc = nKey1 - nKey2;
3205 }
3206 return rc;
3207 }
add_alignment_test_collations(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3208 static int SQLITE_TCLAPI add_alignment_test_collations(
3209 void * clientData,
3210 Tcl_Interp *interp,
3211 int objc,
3212 Tcl_Obj *CONST objv[]
3213 ){
3214 sqlite3 *db;
3215 if( objc>=2 ){
3216 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
3217 sqlite3_create_collation(db, "utf16_unaligned", SQLITE_UTF16,
3218 0, alignmentCollFunc);
3219 sqlite3_create_collation(db, "utf16_aligned", SQLITE_UTF16_ALIGNED,
3220 0, alignmentCollFunc);
3221 }
3222 return SQLITE_OK;
3223 }
3224 #endif /* !defined(SQLITE_OMIT_UTF16) */
3225
3226 /*
3227 ** Usage: add_test_function <db ptr> <utf8> <utf16le> <utf16be>
3228 **
3229 ** This function is used to test that SQLite selects the correct user
3230 ** function callback when multiple versions (for different text encodings)
3231 ** are available.
3232 **
3233 ** Calling this routine registers up to three versions of the user function
3234 ** "test_function" with database handle <db>. If the second argument is
3235 ** true, then a version of test_function is registered for UTF-8, if the
3236 ** third is true, a version is registered for UTF-16le, if the fourth is
3237 ** true, a UTF-16be version is available. Previous versions of
3238 ** test_function are deleted.
3239 **
3240 ** The user function is implemented by calling the following TCL script:
3241 **
3242 ** "test_function <enc> <arg>"
3243 **
3244 ** Where <enc> is one of UTF-8, UTF-16LE or UTF16BE, and <arg> is the
3245 ** single argument passed to the SQL function. The value returned by
3246 ** the TCL script is used as the return value of the SQL function. It
3247 ** is passed to SQLite using UTF-16BE for a UTF-8 test_function(), UTF-8
3248 ** for a UTF-16LE test_function(), and UTF-16LE for an implementation that
3249 ** prefers UTF-16BE.
3250 */
3251 #ifndef SQLITE_OMIT_UTF16
test_function_utf8(sqlite3_context * pCtx,int nArg,sqlite3_value ** argv)3252 static void test_function_utf8(
3253 sqlite3_context *pCtx,
3254 int nArg,
3255 sqlite3_value **argv
3256 ){
3257 Tcl_Interp *interp;
3258 Tcl_Obj *pX;
3259 sqlite3_value *pVal;
3260 interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
3261 pX = Tcl_NewStringObj("test_function", -1);
3262 Tcl_IncrRefCount(pX);
3263 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-8", -1));
3264 Tcl_ListObjAppendElement(interp, pX,
3265 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
3266 Tcl_EvalObjEx(interp, pX, 0);
3267 Tcl_DecrRefCount(pX);
3268 sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT);
3269 pVal = sqlite3ValueNew(0);
3270 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
3271 SQLITE_UTF8, SQLITE_STATIC);
3272 sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal),
3273 -1, SQLITE_TRANSIENT);
3274 sqlite3ValueFree(pVal);
3275 }
test_function_utf16le(sqlite3_context * pCtx,int nArg,sqlite3_value ** argv)3276 static void test_function_utf16le(
3277 sqlite3_context *pCtx,
3278 int nArg,
3279 sqlite3_value **argv
3280 ){
3281 Tcl_Interp *interp;
3282 Tcl_Obj *pX;
3283 sqlite3_value *pVal;
3284 interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
3285 pX = Tcl_NewStringObj("test_function", -1);
3286 Tcl_IncrRefCount(pX);
3287 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16LE", -1));
3288 Tcl_ListObjAppendElement(interp, pX,
3289 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
3290 Tcl_EvalObjEx(interp, pX, 0);
3291 Tcl_DecrRefCount(pX);
3292 pVal = sqlite3ValueNew(0);
3293 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
3294 SQLITE_UTF8, SQLITE_STATIC);
3295 sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT);
3296 sqlite3ValueFree(pVal);
3297 }
test_function_utf16be(sqlite3_context * pCtx,int nArg,sqlite3_value ** argv)3298 static void test_function_utf16be(
3299 sqlite3_context *pCtx,
3300 int nArg,
3301 sqlite3_value **argv
3302 ){
3303 Tcl_Interp *interp;
3304 Tcl_Obj *pX;
3305 sqlite3_value *pVal;
3306 interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
3307 pX = Tcl_NewStringObj("test_function", -1);
3308 Tcl_IncrRefCount(pX);
3309 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16BE", -1));
3310 Tcl_ListObjAppendElement(interp, pX,
3311 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
3312 Tcl_EvalObjEx(interp, pX, 0);
3313 Tcl_DecrRefCount(pX);
3314 pVal = sqlite3ValueNew(0);
3315 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
3316 SQLITE_UTF8, SQLITE_STATIC);
3317 sqlite3_result_text16(pCtx, sqlite3_value_text16le(pVal),
3318 -1, SQLITE_TRANSIENT);
3319 sqlite3_result_text16be(pCtx, sqlite3_value_text16le(pVal),
3320 -1, SQLITE_TRANSIENT);
3321 sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal),
3322 -1, SQLITE_TRANSIENT);
3323 sqlite3ValueFree(pVal);
3324 }
3325 #endif /* SQLITE_OMIT_UTF16 */
test_function(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3326 static int SQLITE_TCLAPI test_function(
3327 void * clientData,
3328 Tcl_Interp *interp,
3329 int objc,
3330 Tcl_Obj *CONST objv[]
3331 ){
3332 #ifndef SQLITE_OMIT_UTF16
3333 sqlite3 *db;
3334 int val;
3335
3336 if( objc!=5 ) goto bad_args;
3337 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
3338
3339 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
3340 if( val ){
3341 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF8,
3342 interp, test_function_utf8, 0, 0);
3343 }
3344 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
3345 if( val ){
3346 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16LE,
3347 interp, test_function_utf16le, 0, 0);
3348 }
3349 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR;
3350 if( val ){
3351 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16BE,
3352 interp, test_function_utf16be, 0, 0);
3353 }
3354
3355 return TCL_OK;
3356 bad_args:
3357 Tcl_AppendResult(interp, "wrong # args: should be \"",
3358 Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0);
3359 #endif /* SQLITE_OMIT_UTF16 */
3360 return TCL_ERROR;
3361 }
3362
3363 /*
3364 ** Usage: sqlite3_test_errstr <err code>
3365 **
3366 ** Test that the english language string equivalents for sqlite error codes
3367 ** are sane. The parameter is an integer representing an sqlite error code.
3368 ** The result is a list of two elements, the string representation of the
3369 ** error code and the english language explanation.
3370 */
test_errstr(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3371 static int SQLITE_TCLAPI test_errstr(
3372 void * clientData,
3373 Tcl_Interp *interp,
3374 int objc,
3375 Tcl_Obj *CONST objv[]
3376 ){
3377 char *zCode;
3378 int i;
3379 if( objc!=1 ){
3380 Tcl_WrongNumArgs(interp, 1, objv, "<error code>");
3381 }
3382
3383 zCode = Tcl_GetString(objv[1]);
3384 for(i=0; i<200; i++){
3385 if( 0==strcmp(t1ErrorName(i), zCode) ) break;
3386 }
3387 Tcl_SetResult(interp, (char *)sqlite3ErrStr(i), 0);
3388 return TCL_OK;
3389 }
3390
3391 /*
3392 ** Usage: breakpoint
3393 **
3394 ** This routine exists for one purpose - to provide a place to put a
3395 ** breakpoint with GDB that can be triggered using TCL code. The use
3396 ** for this is when a particular test fails on (say) the 1485th iteration.
3397 ** In the TCL test script, we can add code like this:
3398 **
3399 ** if {$i==1485} breakpoint
3400 **
3401 ** Then run testfixture in the debugger and wait for the breakpoint to
3402 ** fire. Then additional breakpoints can be set to trace down the bug.
3403 */
test_breakpoint(void * NotUsed,Tcl_Interp * interp,int argc,char ** argv)3404 static int SQLITE_TCLAPI test_breakpoint(
3405 void *NotUsed,
3406 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
3407 int argc, /* Number of arguments */
3408 char **argv /* Text of each argument */
3409 ){
3410 return TCL_OK; /* Do nothing */
3411 }
3412
3413 /*
3414 ** Usage: sqlite3_bind_zeroblob STMT IDX N
3415 **
3416 ** Test the sqlite3_bind_zeroblob interface. STMT is a prepared statement.
3417 ** IDX is the index of a wildcard in the prepared statement. This command
3418 ** binds a N-byte zero-filled BLOB to the wildcard.
3419 */
test_bind_zeroblob(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3420 static int SQLITE_TCLAPI test_bind_zeroblob(
3421 void * clientData,
3422 Tcl_Interp *interp,
3423 int objc,
3424 Tcl_Obj *CONST objv[]
3425 ){
3426 sqlite3_stmt *pStmt;
3427 int idx;
3428 int n;
3429 int rc;
3430
3431 if( objc!=4 ){
3432 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N");
3433 return TCL_ERROR;
3434 }
3435
3436 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3437 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3438 if( Tcl_GetIntFromObj(interp, objv[3], &n) ) return TCL_ERROR;
3439
3440 rc = sqlite3_bind_zeroblob(pStmt, idx, n);
3441 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3442 if( rc!=SQLITE_OK ){
3443 return TCL_ERROR;
3444 }
3445
3446 return TCL_OK;
3447 }
3448
3449 /*
3450 ** Usage: sqlite3_bind_zeroblob64 STMT IDX N
3451 **
3452 ** Test the sqlite3_bind_zeroblob64 interface. STMT is a prepared statement.
3453 ** IDX is the index of a wildcard in the prepared statement. This command
3454 ** binds a N-byte zero-filled BLOB to the wildcard.
3455 */
test_bind_zeroblob64(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3456 static int SQLITE_TCLAPI test_bind_zeroblob64(
3457 void * clientData,
3458 Tcl_Interp *interp,
3459 int objc,
3460 Tcl_Obj *CONST objv[]
3461 ){
3462 sqlite3_stmt *pStmt;
3463 int idx;
3464 Tcl_WideInt n;
3465 int rc;
3466
3467 if( objc!=4 ){
3468 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N");
3469 return TCL_ERROR;
3470 }
3471
3472 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3473 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3474 if( Tcl_GetWideIntFromObj(interp, objv[3], &n) ) return TCL_ERROR;
3475
3476 rc = sqlite3_bind_zeroblob64(pStmt, idx, n);
3477 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3478 if( rc!=SQLITE_OK ){
3479 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
3480 return TCL_ERROR;
3481 }
3482
3483 return TCL_OK;
3484 }
3485
3486 /*
3487 ** Usage: sqlite3_bind_int STMT N VALUE
3488 **
3489 ** Test the sqlite3_bind_int interface. STMT is a prepared statement.
3490 ** N is the index of a wildcard in the prepared statement. This command
3491 ** binds a 32-bit integer VALUE to that wildcard.
3492 */
test_bind_int(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3493 static int SQLITE_TCLAPI test_bind_int(
3494 void * clientData,
3495 Tcl_Interp *interp,
3496 int objc,
3497 Tcl_Obj *CONST objv[]
3498 ){
3499 sqlite3_stmt *pStmt;
3500 int idx;
3501 int value;
3502 int rc;
3503
3504 if( objc!=4 ){
3505 Tcl_AppendResult(interp, "wrong # args: should be \"",
3506 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
3507 return TCL_ERROR;
3508 }
3509
3510 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3511 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3512 if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR;
3513
3514 rc = sqlite3_bind_int(pStmt, idx, value);
3515 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3516 if( rc!=SQLITE_OK ){
3517 return TCL_ERROR;
3518 }
3519
3520 return TCL_OK;
3521 }
3522
3523
3524 /*
3525 ** Usage: intarray_addr INT ...
3526 **
3527 ** Return the address of a C-language array of 32-bit integers.
3528 **
3529 ** Space to hold the array is obtained from malloc(). Call this procedure once
3530 ** with no arguments in order to release memory. Each call to this procedure
3531 ** overwrites the previous array.
3532 */
test_intarray_addr(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3533 static int SQLITE_TCLAPI test_intarray_addr(
3534 void * clientData,
3535 Tcl_Interp *interp,
3536 int objc,
3537 Tcl_Obj *CONST objv[]
3538 ){
3539 int i;
3540 static int *p = 0;
3541
3542 sqlite3_free(p);
3543 p = 0;
3544 if( objc>1 ){
3545 p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
3546 if( p==0 ) return TCL_ERROR;
3547 for(i=0; i<objc-1; i++){
3548 if( Tcl_GetIntFromObj(interp, objv[1+i], &p[i]) ){
3549 sqlite3_free(p);
3550 p = 0;
3551 return TCL_ERROR;
3552 }
3553 }
3554 }
3555 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
3556 return TCL_OK;
3557 }
3558 /*
3559 ** Usage: intarray_addr INT ...
3560 **
3561 ** Return the address of a C-language array of 32-bit integers.
3562 **
3563 ** Space to hold the array is obtained from malloc(). Call this procedure once
3564 ** with no arguments in order to release memory. Each call to this procedure
3565 ** overwrites the previous array.
3566 */
test_int64array_addr(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3567 static int SQLITE_TCLAPI test_int64array_addr(
3568 void * clientData,
3569 Tcl_Interp *interp,
3570 int objc,
3571 Tcl_Obj *CONST objv[]
3572 ){
3573 int i;
3574 static sqlite3_int64 *p = 0;
3575
3576 sqlite3_free(p);
3577 p = 0;
3578 if( objc>1 ){
3579 p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
3580 if( p==0 ) return TCL_ERROR;
3581 for(i=0; i<objc-1; i++){
3582 Tcl_WideInt v;
3583 if( Tcl_GetWideIntFromObj(interp, objv[1+i], &v) ){
3584 sqlite3_free(p);
3585 p = 0;
3586 return TCL_ERROR;
3587 }
3588 p[i] = v;
3589 }
3590 }
3591 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
3592 return TCL_OK;
3593 }
3594 /*
3595 ** Usage: doublearray_addr INT ...
3596 **
3597 ** Return the address of a C-language array of doubles.
3598 **
3599 ** Space to hold the array is obtained from malloc(). Call this procedure once
3600 ** with no arguments in order to release memory. Each call to this procedure
3601 ** overwrites the previous array.
3602 */
test_doublearray_addr(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3603 static int SQLITE_TCLAPI test_doublearray_addr(
3604 void * clientData,
3605 Tcl_Interp *interp,
3606 int objc,
3607 Tcl_Obj *CONST objv[]
3608 ){
3609 int i;
3610 static double *p = 0;
3611
3612 sqlite3_free(p);
3613 p = 0;
3614 if( objc>1 ){
3615 p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
3616 if( p==0 ) return TCL_ERROR;
3617 for(i=0; i<objc-1; i++){
3618 if( Tcl_GetDoubleFromObj(interp, objv[1+i], &p[i]) ){
3619 sqlite3_free(p);
3620 p = 0;
3621 return TCL_ERROR;
3622 }
3623 }
3624 }
3625 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
3626 return TCL_OK;
3627 }
3628 /*
3629 ** Usage: textarray_addr TEXT ...
3630 **
3631 ** Return the address of a C-language array of strings.
3632 **
3633 ** Space to hold the array is obtained from malloc(). Call this procedure once
3634 ** with no arguments in order to release memory. Each call to this procedure
3635 ** overwrites the previous array.
3636 */
test_textarray_addr(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3637 static int SQLITE_TCLAPI test_textarray_addr(
3638 void * clientData,
3639 Tcl_Interp *interp,
3640 int objc,
3641 Tcl_Obj *CONST objv[]
3642 ){
3643 int i;
3644 static int n = 0;
3645 static char **p = 0;
3646
3647 for(i=0; i<n; i++) sqlite3_free(p[i]);
3648 sqlite3_free(p);
3649 p = 0;
3650 if( objc>1 ){
3651 p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
3652 if( p==0 ) return TCL_ERROR;
3653 for(i=0; i<objc-1; i++){
3654 p[i] = sqlite3_mprintf("%s", Tcl_GetString(objv[1+i]));
3655 }
3656 }
3657 n = objc-1;
3658 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
3659 return TCL_OK;
3660 }
3661
3662
3663 /*
3664 ** Usage: sqlite3_bind_int64 STMT N VALUE
3665 **
3666 ** Test the sqlite3_bind_int64 interface. STMT is a prepared statement.
3667 ** N is the index of a wildcard in the prepared statement. This command
3668 ** binds a 64-bit integer VALUE to that wildcard.
3669 */
test_bind_int64(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3670 static int SQLITE_TCLAPI test_bind_int64(
3671 void * clientData,
3672 Tcl_Interp *interp,
3673 int objc,
3674 Tcl_Obj *CONST objv[]
3675 ){
3676 sqlite3_stmt *pStmt;
3677 int idx;
3678 Tcl_WideInt value;
3679 int rc;
3680
3681 if( objc!=4 ){
3682 Tcl_AppendResult(interp, "wrong # args: should be \"",
3683 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
3684 return TCL_ERROR;
3685 }
3686
3687 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3688 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3689 if( Tcl_GetWideIntFromObj(interp, objv[3], &value) ) return TCL_ERROR;
3690
3691 rc = sqlite3_bind_int64(pStmt, idx, value);
3692 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3693 if( rc!=SQLITE_OK ){
3694 return TCL_ERROR;
3695 }
3696
3697 return TCL_OK;
3698 }
3699
3700
3701 /*
3702 ** Usage: sqlite3_bind_double STMT N VALUE
3703 **
3704 ** Test the sqlite3_bind_double interface. STMT is a prepared statement.
3705 ** N is the index of a wildcard in the prepared statement. This command
3706 ** binds a 64-bit integer VALUE to that wildcard.
3707 */
test_bind_double(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3708 static int SQLITE_TCLAPI test_bind_double(
3709 void * clientData,
3710 Tcl_Interp *interp,
3711 int objc,
3712 Tcl_Obj *CONST objv[]
3713 ){
3714 sqlite3_stmt *pStmt;
3715 int idx;
3716 double value = 0;
3717 int rc;
3718 const char *zVal;
3719 int i;
3720 static const struct {
3721 const char *zName; /* Name of the special floating point value */
3722 unsigned int iUpper; /* Upper 32 bits */
3723 unsigned int iLower; /* Lower 32 bits */
3724 } aSpecialFp[] = {
3725 { "NaN", 0x7fffffff, 0xffffffff },
3726 { "SNaN", 0x7ff7ffff, 0xffffffff },
3727 { "-NaN", 0xffffffff, 0xffffffff },
3728 { "-SNaN", 0xfff7ffff, 0xffffffff },
3729 { "+Inf", 0x7ff00000, 0x00000000 },
3730 { "-Inf", 0xfff00000, 0x00000000 },
3731 { "Epsilon", 0x00000000, 0x00000001 },
3732 { "-Epsilon", 0x80000000, 0x00000001 },
3733 { "NaN0", 0x7ff80000, 0x00000000 },
3734 { "-NaN0", 0xfff80000, 0x00000000 },
3735 };
3736
3737 if( objc!=4 ){
3738 Tcl_AppendResult(interp, "wrong # args: should be \"",
3739 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
3740 return TCL_ERROR;
3741 }
3742
3743 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3744 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3745
3746 /* Intercept the string "NaN" and generate a NaN value for it.
3747 ** All other strings are passed through to Tcl_GetDoubleFromObj().
3748 ** Tcl_GetDoubleFromObj() should understand "NaN" but some versions
3749 ** contain a bug.
3750 */
3751 zVal = Tcl_GetString(objv[3]);
3752 for(i=0; i<sizeof(aSpecialFp)/sizeof(aSpecialFp[0]); i++){
3753 if( strcmp(aSpecialFp[i].zName, zVal)==0 ){
3754 sqlite3_uint64 x;
3755 x = aSpecialFp[i].iUpper;
3756 x <<= 32;
3757 x |= aSpecialFp[i].iLower;
3758 assert( sizeof(value)==8 );
3759 assert( sizeof(x)==8 );
3760 memcpy(&value, &x, 8);
3761 break;
3762 }
3763 }
3764 if( i>=sizeof(aSpecialFp)/sizeof(aSpecialFp[0]) &&
3765 Tcl_GetDoubleFromObj(interp, objv[3], &value) ){
3766 return TCL_ERROR;
3767 }
3768 rc = sqlite3_bind_double(pStmt, idx, value);
3769 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3770 if( rc!=SQLITE_OK ){
3771 return TCL_ERROR;
3772 }
3773
3774 return TCL_OK;
3775 }
3776
3777 /*
3778 ** Usage: sqlite3_bind_null STMT N
3779 **
3780 ** Test the sqlite3_bind_null interface. STMT is a prepared statement.
3781 ** N is the index of a wildcard in the prepared statement. This command
3782 ** binds a NULL to the wildcard.
3783 */
test_bind_null(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3784 static int SQLITE_TCLAPI test_bind_null(
3785 void * clientData,
3786 Tcl_Interp *interp,
3787 int objc,
3788 Tcl_Obj *CONST objv[]
3789 ){
3790 sqlite3_stmt *pStmt;
3791 int idx;
3792 int rc;
3793
3794 if( objc!=3 ){
3795 Tcl_AppendResult(interp, "wrong # args: should be \"",
3796 Tcl_GetStringFromObj(objv[0], 0), " STMT N", 0);
3797 return TCL_ERROR;
3798 }
3799
3800 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3801 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3802
3803 rc = sqlite3_bind_null(pStmt, idx);
3804 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3805 if( rc!=SQLITE_OK ){
3806 return TCL_ERROR;
3807 }
3808
3809 return TCL_OK;
3810 }
3811
3812 /*
3813 ** Usage: sqlite3_bind_text STMT N STRING BYTES
3814 **
3815 ** Test the sqlite3_bind_text interface. STMT is a prepared statement.
3816 ** N is the index of a wildcard in the prepared statement. This command
3817 ** binds a UTF-8 string STRING to the wildcard. The string is BYTES bytes
3818 ** long.
3819 */
test_bind_text(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3820 static int SQLITE_TCLAPI test_bind_text(
3821 void * clientData,
3822 Tcl_Interp *interp,
3823 int objc,
3824 Tcl_Obj *CONST objv[]
3825 ){
3826 sqlite3_stmt *pStmt;
3827 int idx;
3828 int bytes;
3829 char *value;
3830 int rc;
3831
3832 if( objc!=5 ){
3833 Tcl_AppendResult(interp, "wrong # args: should be \"",
3834 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0);
3835 return TCL_ERROR;
3836 }
3837
3838 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3839 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3840 value = (char*)Tcl_GetByteArrayFromObj(objv[3], &bytes);
3841 if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
3842
3843 rc = sqlite3_bind_text(pStmt, idx, value, bytes, SQLITE_TRANSIENT);
3844 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3845 if( rc!=SQLITE_OK ){
3846 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
3847 return TCL_ERROR;
3848 }
3849
3850 return TCL_OK;
3851 }
3852
3853 /*
3854 ** Usage: sqlite3_bind_text16 ?-static? STMT N STRING BYTES
3855 **
3856 ** Test the sqlite3_bind_text16 interface. STMT is a prepared statement.
3857 ** N is the index of a wildcard in the prepared statement. This command
3858 ** binds a UTF-16 string STRING to the wildcard. The string is BYTES bytes
3859 ** long.
3860 */
test_bind_text16(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3861 static int SQLITE_TCLAPI test_bind_text16(
3862 void * clientData,
3863 Tcl_Interp *interp,
3864 int objc,
3865 Tcl_Obj *CONST objv[]
3866 ){
3867 #ifndef SQLITE_OMIT_UTF16
3868 sqlite3_stmt *pStmt;
3869 int idx;
3870 int bytes;
3871 char *value;
3872 int rc;
3873
3874 void (*xDel)(void*) = (objc==6?SQLITE_STATIC:SQLITE_TRANSIENT);
3875 Tcl_Obj *oStmt = objv[objc-4];
3876 Tcl_Obj *oN = objv[objc-3];
3877 Tcl_Obj *oString = objv[objc-2];
3878 Tcl_Obj *oBytes = objv[objc-1];
3879
3880 if( objc!=5 && objc!=6){
3881 Tcl_AppendResult(interp, "wrong # args: should be \"",
3882 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0);
3883 return TCL_ERROR;
3884 }
3885
3886 if( getStmtPointer(interp, Tcl_GetString(oStmt), &pStmt) ) return TCL_ERROR;
3887 if( Tcl_GetIntFromObj(interp, oN, &idx) ) return TCL_ERROR;
3888 value = (char*)Tcl_GetByteArrayFromObj(oString, 0);
3889 if( Tcl_GetIntFromObj(interp, oBytes, &bytes) ) return TCL_ERROR;
3890
3891 rc = sqlite3_bind_text16(pStmt, idx, (void *)value, bytes, xDel);
3892 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3893 if( rc!=SQLITE_OK ){
3894 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
3895 return TCL_ERROR;
3896 }
3897
3898 #endif /* SQLITE_OMIT_UTF16 */
3899 return TCL_OK;
3900 }
3901
3902 /*
3903 ** Usage: sqlite3_bind_blob ?-static? STMT N DATA BYTES
3904 **
3905 ** Test the sqlite3_bind_blob interface. STMT is a prepared statement.
3906 ** N is the index of a wildcard in the prepared statement. This command
3907 ** binds a BLOB to the wildcard. The BLOB is BYTES bytes in size.
3908 */
test_bind_blob(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3909 static int SQLITE_TCLAPI test_bind_blob(
3910 void * clientData,
3911 Tcl_Interp *interp,
3912 int objc,
3913 Tcl_Obj *CONST objv[]
3914 ){
3915 sqlite3_stmt *pStmt;
3916 int len, idx;
3917 int bytes;
3918 char *value;
3919 int rc;
3920 sqlite3_destructor_type xDestructor = SQLITE_TRANSIENT;
3921
3922 if( objc!=5 && objc!=6 ){
3923 Tcl_AppendResult(interp, "wrong # args: should be \"",
3924 Tcl_GetStringFromObj(objv[0], 0), " STMT N DATA BYTES", 0);
3925 return TCL_ERROR;
3926 }
3927
3928 if( objc==6 ){
3929 xDestructor = SQLITE_STATIC;
3930 objv++;
3931 }
3932
3933 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
3934 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
3935
3936 value = (char*)Tcl_GetByteArrayFromObj(objv[3], &len);
3937 if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
3938
3939 if( bytes>len ){
3940 char zBuf[200];
3941 sqlite3_snprintf(sizeof(zBuf), zBuf,
3942 "cannot use %d blob bytes, have %d", bytes, len);
3943 Tcl_AppendResult(interp, zBuf, (char*)0);
3944 return TCL_ERROR;
3945 }
3946
3947 rc = sqlite3_bind_blob(pStmt, idx, value, bytes, xDestructor);
3948 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
3949 if( rc!=SQLITE_OK ){
3950 return TCL_ERROR;
3951 }
3952
3953 return TCL_OK;
3954 }
3955
3956
3957 #ifndef SQLITE_OMIT_VIRTUALTABLE
3958 /*
3959 ** sqlite3_carray_bind [options...] STMT NAME VALUE ...
3960 **
3961 ** Options:
3962 ** -transient
3963 ** -static
3964 ** -int32
3965 ** -int64
3966 ** -double
3967 ** -text
3968 **
3969 ** Each call clears static data. Called with no options does nothing
3970 ** but clear static data.
3971 */
test_carray_bind(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])3972 static int SQLITE_TCLAPI test_carray_bind(
3973 void * clientData,
3974 Tcl_Interp *interp,
3975 int objc,
3976 Tcl_Obj *CONST objv[]
3977 ){
3978 sqlite3_stmt *pStmt;
3979 int eType = 0; /* CARRAY_INT32 */
3980 int nData = 0;
3981 void *aData = 0;
3982 int isTransient = 0;
3983 int isStatic = 0;
3984 int idx;
3985 int i, j;
3986 int rc;
3987 void (*xDel)(void*) = sqlite3_free;
3988 static void *aStaticData = 0;
3989 static int nStaticData = 0;
3990 static int eStaticType = 0;
3991 extern int sqlite3_carray_bind(
3992 sqlite3_stmt *pStmt,
3993 int i,
3994 void *aData,
3995 int nData,
3996 int mFlags,
3997 void (*xDestroy)(void*)
3998 );
3999
4000 if( aStaticData ){
4001 /* Always clear preexisting static data on every call */
4002 if( eStaticType==3 ){
4003 for(i=0; i<nStaticData; i++){
4004 sqlite3_free(((char**)aStaticData)[i]);
4005 }
4006 }
4007 sqlite3_free(aStaticData);
4008 aStaticData = 0;
4009 nStaticData = 0;
4010 eStaticType = 0;
4011 }
4012 if( objc==1 ) return TCL_OK;
4013
4014 for(i=1; i<objc && Tcl_GetString(objv[i])[0]=='-'; i++){
4015 const char *z = Tcl_GetString(objv[i]);
4016 if( strcmp(z, "-transient")==0 ){
4017 isTransient = 1;
4018 xDel = SQLITE_TRANSIENT;
4019 }else
4020 if( strcmp(z, "-static")==0 ){
4021 isStatic = 1;
4022 xDel = SQLITE_STATIC;
4023 }else
4024 if( strcmp(z, "-int32")==0 ){
4025 eType = 0; /* CARRAY_INT32 */
4026 }else
4027 if( strcmp(z, "-int64")==0 ){
4028 eType = 1; /* CARRAY_INT64 */
4029 }else
4030 if( strcmp(z, "-double")==0 ){
4031 eType = 2; /* CARRAY_DOUBLE */
4032 }else
4033 if( strcmp(z, "-text")==0 ){
4034 eType = 3; /* CARRAY_TEXT */
4035 }else
4036 if( strcmp(z, "--")==0 ){
4037 break;
4038 }else
4039 {
4040 Tcl_AppendResult(interp, "unknown option: ", z, (char*)0);
4041 return TCL_ERROR;
4042 }
4043 }
4044 if( eType==3 && !isStatic && !isTransient ){
4045 Tcl_AppendResult(interp, "text data must be either -static or -transient",
4046 (char*)0);
4047 return TCL_ERROR;
4048 }
4049 if( isStatic && isTransient ){
4050 Tcl_AppendResult(interp, "cannot be both -static and -transient",
4051 (char*)0);
4052 return TCL_ERROR;
4053 }
4054 if( objc-i < 2 ){
4055 Tcl_WrongNumArgs(interp, 1, objv, "[OPTIONS] STMT IDX VALUE ...");
4056 return TCL_ERROR;
4057 }
4058 if( getStmtPointer(interp, Tcl_GetString(objv[i]), &pStmt) ) return TCL_ERROR;
4059 i++;
4060 if( Tcl_GetIntFromObj(interp, objv[i], &idx) ) return TCL_ERROR;
4061 i++;
4062 nData = objc - i;
4063 switch( eType + 4*(nData<=0) ){
4064 case 0: { /* INT32 */
4065 int *a = sqlite3_malloc( sizeof(int)*nData );
4066 if( a==0 ){ rc = SQLITE_NOMEM; goto carray_bind_done; }
4067 for(j=0; j<nData; j++){
4068 int v;
4069 if( Tcl_GetIntFromObj(interp, objv[i+j], &v) ){
4070 sqlite3_free(a);
4071 return TCL_ERROR;
4072 }
4073 a[j] = v;
4074 }
4075 aData = a;
4076 break;
4077 }
4078 case 1: { /* INT64 */
4079 sqlite3_int64 *a = sqlite3_malloc( sizeof(sqlite3_int64)*nData );
4080 if( a==0 ){ rc = SQLITE_NOMEM; goto carray_bind_done; }
4081 for(j=0; j<nData; j++){
4082 Tcl_WideInt v;
4083 if( Tcl_GetWideIntFromObj(interp, objv[i+j], &v) ){
4084 sqlite3_free(a);
4085 return TCL_ERROR;
4086 }
4087 a[j] = v;
4088 }
4089 aData = a;
4090 break;
4091 }
4092 case 2: { /* DOUBLE */
4093 double *a = sqlite3_malloc( sizeof(double)*nData );
4094 if( a==0 ){ rc = SQLITE_NOMEM; goto carray_bind_done; }
4095 for(j=0; j<nData; j++){
4096 double v;
4097 if( Tcl_GetDoubleFromObj(interp, objv[i+j], &v) ){
4098 sqlite3_free(a);
4099 return TCL_ERROR;
4100 }
4101 a[j] = v;
4102 }
4103 aData = a;
4104 break;
4105 }
4106 case 3: { /* TEXT */
4107 char **a = sqlite3_malloc( sizeof(char*)*nData );
4108 if( a==0 ){ rc = SQLITE_NOMEM; goto carray_bind_done; }
4109 for(j=0; j<nData; j++){
4110 const char *v = Tcl_GetString(objv[i+j]);
4111 a[j] = sqlite3_mprintf("%s", v);
4112 }
4113 aData = a;
4114 break;
4115 }
4116 case 4: { /* nData==0 */
4117 aData = "";
4118 xDel = SQLITE_STATIC;
4119 isTransient = 0;
4120 isStatic = 0;
4121 break;
4122 }
4123 }
4124 if( isStatic ){
4125 aStaticData = aData;
4126 nStaticData = nData;
4127 eStaticType = eType;
4128 }
4129 rc = sqlite3_carray_bind(pStmt, idx, aData, nData, eType, xDel);
4130 if( isTransient ){
4131 if( eType==3 ){
4132 for(i=0; i<nData; i++) sqlite3_free(((char**)aData)[i]);
4133 }
4134 sqlite3_free(aData);
4135 }
4136 carray_bind_done:
4137 if( rc ){
4138 Tcl_AppendResult(interp, sqlite3_errstr(rc), (char*)0);
4139 return TCL_ERROR;
4140 }
4141 return TCL_OK;
4142 }
4143 #endif /* SQLITE_OMIT_VIRTUALTABLE */
4144
4145 /*
4146 ** Usage: sqlite3_bind_parameter_count STMT
4147 **
4148 ** Return the number of wildcards in the given statement.
4149 */
test_bind_parameter_count(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4150 static int SQLITE_TCLAPI test_bind_parameter_count(
4151 void * clientData,
4152 Tcl_Interp *interp,
4153 int objc,
4154 Tcl_Obj *CONST objv[]
4155 ){
4156 sqlite3_stmt *pStmt;
4157
4158 if( objc!=2 ){
4159 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
4160 return TCL_ERROR;
4161 }
4162 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4163 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_bind_parameter_count(pStmt)));
4164 return TCL_OK;
4165 }
4166
4167 /*
4168 ** Usage: sqlite3_bind_parameter_name STMT N
4169 **
4170 ** Return the name of the Nth wildcard. The first wildcard is 1.
4171 ** An empty string is returned if N is out of range or if the wildcard
4172 ** is nameless.
4173 */
test_bind_parameter_name(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4174 static int SQLITE_TCLAPI test_bind_parameter_name(
4175 void * clientData,
4176 Tcl_Interp *interp,
4177 int objc,
4178 Tcl_Obj *CONST objv[]
4179 ){
4180 sqlite3_stmt *pStmt;
4181 int i;
4182
4183 if( objc!=3 ){
4184 Tcl_WrongNumArgs(interp, 1, objv, "STMT N");
4185 return TCL_ERROR;
4186 }
4187 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4188 if( Tcl_GetIntFromObj(interp, objv[2], &i) ) return TCL_ERROR;
4189 Tcl_SetObjResult(interp,
4190 Tcl_NewStringObj(sqlite3_bind_parameter_name(pStmt,i),-1)
4191 );
4192 return TCL_OK;
4193 }
4194
4195 /*
4196 ** Usage: sqlite3_bind_parameter_index STMT NAME
4197 **
4198 ** Return the index of the wildcard called NAME. Return 0 if there is
4199 ** no such wildcard.
4200 */
test_bind_parameter_index(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4201 static int SQLITE_TCLAPI test_bind_parameter_index(
4202 void * clientData,
4203 Tcl_Interp *interp,
4204 int objc,
4205 Tcl_Obj *CONST objv[]
4206 ){
4207 sqlite3_stmt *pStmt;
4208
4209 if( objc!=3 ){
4210 Tcl_WrongNumArgs(interp, 1, objv, "STMT NAME");
4211 return TCL_ERROR;
4212 }
4213 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4214 Tcl_SetObjResult(interp,
4215 Tcl_NewIntObj(
4216 sqlite3_bind_parameter_index(pStmt,Tcl_GetString(objv[2]))
4217 )
4218 );
4219 return TCL_OK;
4220 }
4221
4222 /*
4223 ** Usage: sqlite3_clear_bindings STMT
4224 **
4225 */
test_clear_bindings(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4226 static int SQLITE_TCLAPI test_clear_bindings(
4227 void * clientData,
4228 Tcl_Interp *interp,
4229 int objc,
4230 Tcl_Obj *CONST objv[]
4231 ){
4232 sqlite3_stmt *pStmt;
4233
4234 if( objc!=2 ){
4235 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
4236 return TCL_ERROR;
4237 }
4238 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4239 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt)));
4240 return TCL_OK;
4241 }
4242
4243 /*
4244 ** Usage: sqlite3_sleep MILLISECONDS
4245 */
test_sleep(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4246 static int SQLITE_TCLAPI test_sleep(
4247 void * clientData,
4248 Tcl_Interp *interp,
4249 int objc,
4250 Tcl_Obj *CONST objv[]
4251 ){
4252 int ms;
4253
4254 if( objc!=2 ){
4255 Tcl_WrongNumArgs(interp, 1, objv, "MILLISECONDS");
4256 return TCL_ERROR;
4257 }
4258 if( Tcl_GetIntFromObj(interp, objv[1], &ms) ){
4259 return TCL_ERROR;
4260 }
4261 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_sleep(ms)));
4262 return TCL_OK;
4263 }
4264
4265 /*
4266 ** Usage: sqlite3_extended_errcode DB
4267 **
4268 ** Return the string representation of the most recent sqlite3_* API
4269 ** error code. e.g. "SQLITE_ERROR".
4270 */
test_ex_errcode(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4271 static int SQLITE_TCLAPI test_ex_errcode(
4272 void * clientData,
4273 Tcl_Interp *interp,
4274 int objc,
4275 Tcl_Obj *CONST objv[]
4276 ){
4277 sqlite3 *db;
4278 int rc;
4279
4280 if( objc!=2 ){
4281 Tcl_AppendResult(interp, "wrong # args: should be \"",
4282 Tcl_GetString(objv[0]), " DB", 0);
4283 return TCL_ERROR;
4284 }
4285 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4286 rc = sqlite3_extended_errcode(db);
4287 Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0);
4288 return TCL_OK;
4289 }
4290
4291
4292 /*
4293 ** Usage: sqlite3_errcode DB
4294 **
4295 ** Return the string representation of the most recent sqlite3_* API
4296 ** error code. e.g. "SQLITE_ERROR".
4297 */
test_errcode(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4298 static int SQLITE_TCLAPI test_errcode(
4299 void * clientData,
4300 Tcl_Interp *interp,
4301 int objc,
4302 Tcl_Obj *CONST objv[]
4303 ){
4304 sqlite3 *db;
4305 int rc;
4306
4307 if( objc!=2 ){
4308 Tcl_AppendResult(interp, "wrong # args: should be \"",
4309 Tcl_GetString(objv[0]), " DB", 0);
4310 return TCL_ERROR;
4311 }
4312 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4313 rc = sqlite3_errcode(db);
4314 Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0);
4315 return TCL_OK;
4316 }
4317
4318 /*
4319 ** Usage: sqlite3_errmsg DB
4320 **
4321 ** Returns the UTF-8 representation of the error message string for the
4322 ** most recent sqlite3_* API call.
4323 */
test_errmsg(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4324 static int SQLITE_TCLAPI test_errmsg(
4325 void * clientData,
4326 Tcl_Interp *interp,
4327 int objc,
4328 Tcl_Obj *CONST objv[]
4329 ){
4330 sqlite3 *db;
4331 const char *zErr;
4332
4333 if( objc!=2 ){
4334 Tcl_AppendResult(interp, "wrong # args: should be \"",
4335 Tcl_GetString(objv[0]), " DB", 0);
4336 return TCL_ERROR;
4337 }
4338 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4339
4340 zErr = sqlite3_errmsg(db);
4341 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1));
4342 return TCL_OK;
4343 }
4344
4345 /*
4346 ** Usage: test_errmsg16 DB
4347 **
4348 ** Returns the UTF-16 representation of the error message string for the
4349 ** most recent sqlite3_* API call. This is a byte array object at the TCL
4350 ** level, and it includes the 0x00 0x00 terminator bytes at the end of the
4351 ** UTF-16 string.
4352 */
test_errmsg16(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4353 static int SQLITE_TCLAPI test_errmsg16(
4354 void * clientData,
4355 Tcl_Interp *interp,
4356 int objc,
4357 Tcl_Obj *CONST objv[]
4358 ){
4359 #ifndef SQLITE_OMIT_UTF16
4360 sqlite3 *db;
4361 const void *zErr;
4362 const char *z;
4363 int bytes = 0;
4364
4365 if( objc!=2 ){
4366 Tcl_AppendResult(interp, "wrong # args: should be \"",
4367 Tcl_GetString(objv[0]), " DB", 0);
4368 return TCL_ERROR;
4369 }
4370 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4371
4372 zErr = sqlite3_errmsg16(db);
4373 if( zErr ){
4374 z = zErr;
4375 for(bytes=0; z[bytes] || z[bytes+1]; bytes+=2){}
4376 }
4377 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zErr, bytes));
4378 #endif /* SQLITE_OMIT_UTF16 */
4379 return TCL_OK;
4380 }
4381
4382 /*
4383 ** Usage: sqlite3_prepare DB sql bytes ?tailvar?
4384 **
4385 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
4386 ** database handle <DB>. The parameter <tailval> is the name of a global
4387 ** variable that is set to the unused portion of <sql> (if any). A
4388 ** STMT handle is returned.
4389 */
test_prepare(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4390 static int SQLITE_TCLAPI test_prepare(
4391 void * clientData,
4392 Tcl_Interp *interp,
4393 int objc,
4394 Tcl_Obj *CONST objv[]
4395 ){
4396 sqlite3 *db;
4397 const char *zSql;
4398 int bytes;
4399 const char *zTail = 0;
4400 sqlite3_stmt *pStmt = 0;
4401 char zBuf[50];
4402 int rc;
4403
4404 if( objc!=5 && objc!=4 ){
4405 Tcl_AppendResult(interp, "wrong # args: should be \"",
4406 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0);
4407 return TCL_ERROR;
4408 }
4409 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4410 zSql = Tcl_GetString(objv[2]);
4411 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
4412
4413 rc = sqlite3_prepare(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
4414 Tcl_ResetResult(interp);
4415 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
4416 if( zTail && objc>=5 ){
4417 if( bytes>=0 ){
4418 bytes = bytes - (int)(zTail-zSql);
4419 }
4420 if( (int)strlen(zTail)<bytes ){
4421 bytes = (int)strlen(zTail);
4422 }
4423 Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
4424 }
4425 if( rc!=SQLITE_OK ){
4426 assert( pStmt==0 );
4427 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc);
4428 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
4429 return TCL_ERROR;
4430 }
4431
4432 if( pStmt ){
4433 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
4434 Tcl_AppendResult(interp, zBuf, 0);
4435 }
4436 return TCL_OK;
4437 }
4438
4439 /*
4440 ** Usage: sqlite3_prepare_v2 DB sql bytes ?tailvar?
4441 **
4442 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
4443 ** database handle <DB>. The parameter <tailval> is the name of a global
4444 ** variable that is set to the unused portion of <sql> (if any). A
4445 ** STMT handle is returned.
4446 */
test_prepare_v2(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4447 static int SQLITE_TCLAPI test_prepare_v2(
4448 void * clientData,
4449 Tcl_Interp *interp,
4450 int objc,
4451 Tcl_Obj *CONST objv[]
4452 ){
4453 sqlite3 *db;
4454 const char *zSql;
4455 char *zCopy = 0; /* malloc() copy of zSql */
4456 int bytes;
4457 const char *zTail = 0;
4458 const char **pzTail;
4459 sqlite3_stmt *pStmt = 0;
4460 char zBuf[50];
4461 int rc;
4462
4463 if( objc!=5 && objc!=4 ){
4464 Tcl_AppendResult(interp, "wrong # args: should be \"",
4465 Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
4466 return TCL_ERROR;
4467 }
4468 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4469 zSql = Tcl_GetString(objv[2]);
4470 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
4471
4472 /* Instead of using zSql directly, make a copy into a buffer obtained
4473 ** directly from malloc(). The idea is to make it easier for valgrind
4474 ** to spot buffer overreads. */
4475 if( bytes>=0 ){
4476 zCopy = malloc(bytes);
4477 memcpy(zCopy, zSql, bytes);
4478 }else{
4479 int n = (int)strlen(zSql) + 1;
4480 zCopy = malloc(n);
4481 memcpy(zCopy, zSql, n);
4482 }
4483 pzTail = objc>=5 ? &zTail : 0;
4484 rc = sqlite3_prepare_v2(db, zCopy, bytes, &pStmt, pzTail);
4485 if( objc>=5 ){
4486 zTail = &zSql[(zTail - zCopy)];
4487 }
4488 free(zCopy);
4489
4490 assert(rc==SQLITE_OK || pStmt==0);
4491 Tcl_ResetResult(interp);
4492 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
4493 if( rc==SQLITE_OK && objc>=5 && zTail ){
4494 if( bytes>=0 ){
4495 bytes = bytes - (int)(zTail-zSql);
4496 }
4497 Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
4498 }
4499 if( rc!=SQLITE_OK ){
4500 assert( pStmt==0 );
4501 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc);
4502 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
4503 return TCL_ERROR;
4504 }
4505
4506 if( pStmt ){
4507 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
4508 Tcl_AppendResult(interp, zBuf, 0);
4509 }
4510 return TCL_OK;
4511 }
4512
4513 /*
4514 ** Usage: sqlite3_prepare_v3 DB sql bytes flags ?tailvar?
4515 **
4516 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
4517 ** database handle <DB> and flags <flags>. The parameter <tailval> is
4518 ** the name of a global variable that is set to the unused portion of
4519 ** <sql> (if any). A STMT handle is returned.
4520 */
test_prepare_v3(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4521 static int SQLITE_TCLAPI test_prepare_v3(
4522 void * clientData,
4523 Tcl_Interp *interp,
4524 int objc,
4525 Tcl_Obj *CONST objv[]
4526 ){
4527 sqlite3 *db;
4528 const char *zSql;
4529 char *zCopy = 0; /* malloc() copy of zSql */
4530 int bytes, flags;
4531 const char *zTail = 0;
4532 const char **pzTail;
4533 sqlite3_stmt *pStmt = 0;
4534 char zBuf[50];
4535 int rc;
4536
4537 if( objc!=6 && objc!=5 ){
4538 Tcl_AppendResult(interp, "wrong # args: should be \"",
4539 Tcl_GetString(objv[0]), " DB sql bytes flags tailvar", 0);
4540 return TCL_ERROR;
4541 }
4542 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4543 zSql = Tcl_GetString(objv[2]);
4544 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
4545 if( Tcl_GetIntFromObj(interp, objv[4], &flags) ) return TCL_ERROR;
4546
4547 /* Instead of using zSql directly, make a copy into a buffer obtained
4548 ** directly from malloc(). The idea is to make it easier for valgrind
4549 ** to spot buffer overreads. */
4550 if( bytes>=0 ){
4551 zCopy = malloc(bytes);
4552 memcpy(zCopy, zSql, bytes);
4553 }else{
4554 int n = (int)strlen(zSql) + 1;
4555 zCopy = malloc(n);
4556 memcpy(zCopy, zSql, n);
4557 }
4558 pzTail = objc>=6 ? &zTail : 0;
4559 rc = sqlite3_prepare_v3(db, zCopy, bytes, (unsigned int)flags,&pStmt,pzTail);
4560 free(zCopy);
4561 zTail = &zSql[(zTail - zCopy)];
4562
4563 assert(rc==SQLITE_OK || pStmt==0);
4564 Tcl_ResetResult(interp);
4565 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
4566 if( rc==SQLITE_OK && zTail && objc>=6 ){
4567 if( bytes>=0 ){
4568 bytes = bytes - (int)(zTail-zSql);
4569 }
4570 Tcl_ObjSetVar2(interp, objv[5], 0, Tcl_NewStringObj(zTail, bytes), 0);
4571 }
4572 if( rc!=SQLITE_OK ){
4573 assert( pStmt==0 );
4574 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc);
4575 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
4576 return TCL_ERROR;
4577 }
4578
4579 if( pStmt ){
4580 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
4581 Tcl_AppendResult(interp, zBuf, 0);
4582 }
4583 return TCL_OK;
4584 }
4585
4586 /*
4587 ** Usage: sqlite3_prepare_tkt3134 DB
4588 **
4589 ** Generate a prepared statement for a zero-byte string as a test
4590 ** for ticket #3134. The string should be preceded by a zero byte.
4591 */
test_prepare_tkt3134(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4592 static int SQLITE_TCLAPI test_prepare_tkt3134(
4593 void * clientData,
4594 Tcl_Interp *interp,
4595 int objc,
4596 Tcl_Obj *CONST objv[]
4597 ){
4598 sqlite3 *db;
4599 static const char zSql[] = "\000SELECT 1";
4600 sqlite3_stmt *pStmt = 0;
4601 char zBuf[50];
4602 int rc;
4603
4604 if( objc!=2 ){
4605 Tcl_AppendResult(interp, "wrong # args: should be \"",
4606 Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
4607 return TCL_ERROR;
4608 }
4609 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4610 rc = sqlite3_prepare_v2(db, &zSql[1], 0, &pStmt, 0);
4611 assert(rc==SQLITE_OK || pStmt==0);
4612 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
4613 if( rc!=SQLITE_OK ){
4614 assert( pStmt==0 );
4615 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc);
4616 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
4617 return TCL_ERROR;
4618 }
4619
4620 if( pStmt ){
4621 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
4622 Tcl_AppendResult(interp, zBuf, 0);
4623 }
4624 return TCL_OK;
4625 }
4626
4627 /*
4628 ** Usage: sqlite3_prepare16 DB sql bytes tailvar
4629 **
4630 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
4631 ** database handle <DB>. The parameter <tailval> is the name of a global
4632 ** variable that is set to the unused portion of <sql> (if any). A
4633 ** STMT handle is returned.
4634 */
test_prepare16(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4635 static int SQLITE_TCLAPI test_prepare16(
4636 void * clientData,
4637 Tcl_Interp *interp,
4638 int objc,
4639 Tcl_Obj *CONST objv[]
4640 ){
4641 #ifndef SQLITE_OMIT_UTF16
4642 sqlite3 *db;
4643 const void *zSql;
4644 const void *zTail = 0;
4645 Tcl_Obj *pTail = 0;
4646 sqlite3_stmt *pStmt = 0;
4647 char zBuf[50];
4648 int rc;
4649 int bytes; /* The integer specified as arg 3 */
4650 int objlen; /* The byte-array length of arg 2 */
4651
4652 if( objc!=5 && objc!=4 ){
4653 Tcl_AppendResult(interp, "wrong # args: should be \"",
4654 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0);
4655 return TCL_ERROR;
4656 }
4657 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4658 zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen);
4659 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
4660
4661 rc = sqlite3_prepare16(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
4662 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
4663 if( rc ){
4664 return TCL_ERROR;
4665 }
4666
4667 if( objc>=5 ){
4668 if( zTail ){
4669 objlen = objlen - (int)((u8 *)zTail-(u8 *)zSql);
4670 }else{
4671 objlen = 0;
4672 }
4673 pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen);
4674 Tcl_IncrRefCount(pTail);
4675 Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
4676 Tcl_DecrRefCount(pTail);
4677 }
4678
4679 if( pStmt ){
4680 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
4681 }
4682 Tcl_AppendResult(interp, zBuf, 0);
4683 #endif /* SQLITE_OMIT_UTF16 */
4684 return TCL_OK;
4685 }
4686
4687 /*
4688 ** Usage: sqlite3_prepare16_v2 DB sql bytes ?tailvar?
4689 **
4690 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
4691 ** database handle <DB>. The parameter <tailval> is the name of a global
4692 ** variable that is set to the unused portion of <sql> (if any). A
4693 ** STMT handle is returned.
4694 */
test_prepare16_v2(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4695 static int SQLITE_TCLAPI test_prepare16_v2(
4696 void * clientData,
4697 Tcl_Interp *interp,
4698 int objc,
4699 Tcl_Obj *CONST objv[]
4700 ){
4701 #ifndef SQLITE_OMIT_UTF16
4702 sqlite3 *db;
4703 const void *zSql;
4704 const void *zTail = 0;
4705 Tcl_Obj *pTail = 0;
4706 sqlite3_stmt *pStmt = 0;
4707 char zBuf[50];
4708 int rc;
4709 int bytes; /* The integer specified as arg 3 */
4710 int objlen; /* The byte-array length of arg 2 */
4711
4712 if( objc!=5 && objc!=4 ){
4713 Tcl_AppendResult(interp, "wrong # args: should be \"",
4714 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0);
4715 return TCL_ERROR;
4716 }
4717 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
4718 zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen);
4719 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
4720
4721 rc = sqlite3_prepare16_v2(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
4722 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
4723 if( rc ){
4724 return TCL_ERROR;
4725 }
4726
4727 if( objc>=5 ){
4728 if( zTail ){
4729 objlen = objlen - (int)((u8 *)zTail-(u8 *)zSql);
4730 }else{
4731 objlen = 0;
4732 }
4733 pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen);
4734 Tcl_IncrRefCount(pTail);
4735 Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
4736 Tcl_DecrRefCount(pTail);
4737 }
4738
4739 if( pStmt ){
4740 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
4741 }
4742 Tcl_AppendResult(interp, zBuf, 0);
4743 #endif /* SQLITE_OMIT_UTF16 */
4744 return TCL_OK;
4745 }
4746
4747 /*
4748 ** Usage: sqlite3_open filename ?options-list?
4749 */
test_open(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4750 static int SQLITE_TCLAPI test_open(
4751 void * clientData,
4752 Tcl_Interp *interp,
4753 int objc,
4754 Tcl_Obj *CONST objv[]
4755 ){
4756 const char *zFilename;
4757 sqlite3 *db;
4758 char zBuf[100];
4759
4760 if( objc!=3 && objc!=2 && objc!=1 ){
4761 Tcl_AppendResult(interp, "wrong # args: should be \"",
4762 Tcl_GetString(objv[0]), " filename options-list", 0);
4763 return TCL_ERROR;
4764 }
4765
4766 zFilename = objc>1 ? Tcl_GetString(objv[1]) : 0;
4767 sqlite3_open(zFilename, &db);
4768
4769 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
4770 Tcl_AppendResult(interp, zBuf, 0);
4771 return TCL_OK;
4772 }
4773
4774 /*
4775 ** Usage: sqlite3_open_v2 FILENAME FLAGS VFS
4776 */
test_open_v2(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4777 static int SQLITE_TCLAPI test_open_v2(
4778 void * clientData,
4779 Tcl_Interp *interp,
4780 int objc,
4781 Tcl_Obj *CONST objv[]
4782 ){
4783 const char *zFilename;
4784 const char *zVfs;
4785 int flags = 0;
4786 sqlite3 *db;
4787 int rc;
4788 char zBuf[100];
4789
4790 int nFlag;
4791 Tcl_Obj **apFlag;
4792 int i;
4793
4794 if( objc!=4 ){
4795 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME FLAGS VFS");
4796 return TCL_ERROR;
4797 }
4798 zFilename = Tcl_GetString(objv[1]);
4799 zVfs = Tcl_GetString(objv[3]);
4800 if( zVfs[0]==0x00 ) zVfs = 0;
4801
4802 rc = Tcl_ListObjGetElements(interp, objv[2], &nFlag, &apFlag);
4803 if( rc!=TCL_OK ) return rc;
4804 for(i=0; i<nFlag; i++){
4805 int iFlag;
4806 struct OpenFlag {
4807 const char *zFlag;
4808 int flag;
4809 } aFlag[] = {
4810 { "SQLITE_OPEN_READONLY", SQLITE_OPEN_READONLY },
4811 { "SQLITE_OPEN_READWRITE", SQLITE_OPEN_READWRITE },
4812 { "SQLITE_OPEN_CREATE", SQLITE_OPEN_CREATE },
4813 { "SQLITE_OPEN_DELETEONCLOSE", SQLITE_OPEN_DELETEONCLOSE },
4814 { "SQLITE_OPEN_EXCLUSIVE", SQLITE_OPEN_EXCLUSIVE },
4815 { "SQLITE_OPEN_AUTOPROXY", SQLITE_OPEN_AUTOPROXY },
4816 { "SQLITE_OPEN_MAIN_DB", SQLITE_OPEN_MAIN_DB },
4817 { "SQLITE_OPEN_TEMP_DB", SQLITE_OPEN_TEMP_DB },
4818 { "SQLITE_OPEN_TRANSIENT_DB", SQLITE_OPEN_TRANSIENT_DB },
4819 { "SQLITE_OPEN_MAIN_JOURNAL", SQLITE_OPEN_MAIN_JOURNAL },
4820 { "SQLITE_OPEN_TEMP_JOURNAL", SQLITE_OPEN_TEMP_JOURNAL },
4821 { "SQLITE_OPEN_SUBJOURNAL", SQLITE_OPEN_SUBJOURNAL },
4822 { "SQLITE_OPEN_SUPER_JOURNAL", SQLITE_OPEN_SUPER_JOURNAL },
4823 { "SQLITE_OPEN_NOMUTEX", SQLITE_OPEN_NOMUTEX },
4824 { "SQLITE_OPEN_FULLMUTEX", SQLITE_OPEN_FULLMUTEX },
4825 { "SQLITE_OPEN_SHAREDCACHE", SQLITE_OPEN_SHAREDCACHE },
4826 { "SQLITE_OPEN_PRIVATECACHE", SQLITE_OPEN_PRIVATECACHE },
4827 { "SQLITE_OPEN_WAL", SQLITE_OPEN_WAL },
4828 { "SQLITE_OPEN_URI", SQLITE_OPEN_URI },
4829 { 0, 0 }
4830 };
4831 rc = Tcl_GetIndexFromObjStruct(interp, apFlag[i], aFlag, sizeof(aFlag[0]),
4832 "flag", 0, &iFlag
4833 );
4834 if( rc!=TCL_OK ) return rc;
4835 flags |= aFlag[iFlag].flag;
4836 }
4837
4838 rc = sqlite3_open_v2(zFilename, &db, flags, zVfs);
4839 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
4840 Tcl_AppendResult(interp, zBuf, 0);
4841 return TCL_OK;
4842 }
4843
4844 /*
4845 ** Usage: sqlite3_open16 filename options
4846 */
test_open16(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4847 static int SQLITE_TCLAPI test_open16(
4848 void * clientData,
4849 Tcl_Interp *interp,
4850 int objc,
4851 Tcl_Obj *CONST objv[]
4852 ){
4853 #ifndef SQLITE_OMIT_UTF16
4854 const void *zFilename;
4855 sqlite3 *db;
4856 char zBuf[100];
4857
4858 if( objc!=3 ){
4859 Tcl_AppendResult(interp, "wrong # args: should be \"",
4860 Tcl_GetString(objv[0]), " filename options-list", 0);
4861 return TCL_ERROR;
4862 }
4863
4864 zFilename = Tcl_GetByteArrayFromObj(objv[1], 0);
4865 sqlite3_open16(zFilename, &db);
4866
4867 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
4868 Tcl_AppendResult(interp, zBuf, 0);
4869 #endif /* SQLITE_OMIT_UTF16 */
4870 return TCL_OK;
4871 }
4872
4873 /*
4874 ** Usage: sqlite3_complete16 <UTF-16 string>
4875 **
4876 ** Return 1 if the supplied argument is a complete SQL statement, or zero
4877 ** otherwise.
4878 */
test_complete16(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4879 static int SQLITE_TCLAPI test_complete16(
4880 void * clientData,
4881 Tcl_Interp *interp,
4882 int objc,
4883 Tcl_Obj *CONST objv[]
4884 ){
4885 #if !defined(SQLITE_OMIT_COMPLETE) && !defined(SQLITE_OMIT_UTF16)
4886 char *zBuf;
4887
4888 if( objc!=2 ){
4889 Tcl_WrongNumArgs(interp, 1, objv, "<utf-16 sql>");
4890 return TCL_ERROR;
4891 }
4892
4893 zBuf = (char*)Tcl_GetByteArrayFromObj(objv[1], 0);
4894 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_complete16(zBuf)));
4895 #endif /* SQLITE_OMIT_COMPLETE && SQLITE_OMIT_UTF16 */
4896 return TCL_OK;
4897 }
4898
4899 /*
4900 ** Usage: sqlite3_normalize SQL
4901 **
4902 ** Return the normalized value for an SQL statement.
4903 */
test_normalize(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4904 static int SQLITE_TCLAPI test_normalize(
4905 void * clientData,
4906 Tcl_Interp *interp,
4907 int objc,
4908 Tcl_Obj *CONST objv[]
4909 ){
4910 char *zSql;
4911 char *zNorm;
4912 extern char *sqlite3_normalize(const char*);
4913
4914 if( objc!=2 ){
4915 Tcl_WrongNumArgs(interp, 1, objv, "SQL");
4916 return TCL_ERROR;
4917 }
4918
4919 zSql = (char*)Tcl_GetString(objv[1]);
4920 zNorm = sqlite3_normalize(zSql);
4921 if( zNorm ){
4922 Tcl_SetObjResult(interp, Tcl_NewStringObj(zNorm, -1));
4923 sqlite3_free(zNorm);
4924 }
4925 return TCL_OK;
4926 }
4927
4928 /*
4929 ** Usage: sqlite3_step STMT
4930 **
4931 ** Advance the statement to the next row.
4932 */
test_step(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4933 static int SQLITE_TCLAPI test_step(
4934 void * clientData,
4935 Tcl_Interp *interp,
4936 int objc,
4937 Tcl_Obj *CONST objv[]
4938 ){
4939 sqlite3_stmt *pStmt;
4940 int rc;
4941
4942 if( objc!=2 ){
4943 Tcl_AppendResult(interp, "wrong # args: should be \"",
4944 Tcl_GetString(objv[0]), " STMT", 0);
4945 return TCL_ERROR;
4946 }
4947
4948 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4949 rc = sqlite3_step(pStmt);
4950
4951 /* if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; */
4952 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
4953 return TCL_OK;
4954 }
4955
test_sql(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4956 static int SQLITE_TCLAPI test_sql(
4957 void * clientData,
4958 Tcl_Interp *interp,
4959 int objc,
4960 Tcl_Obj *CONST objv[]
4961 ){
4962 sqlite3_stmt *pStmt;
4963
4964 if( objc!=2 ){
4965 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
4966 return TCL_ERROR;
4967 }
4968
4969 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4970 Tcl_SetResult(interp, (char *)sqlite3_sql(pStmt), TCL_VOLATILE);
4971 return TCL_OK;
4972 }
test_ex_sql(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4973 static int SQLITE_TCLAPI test_ex_sql(
4974 void * clientData,
4975 Tcl_Interp *interp,
4976 int objc,
4977 Tcl_Obj *CONST objv[]
4978 ){
4979 sqlite3_stmt *pStmt;
4980 char *z;
4981
4982 if( objc!=2 ){
4983 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
4984 return TCL_ERROR;
4985 }
4986
4987 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
4988 z = sqlite3_expanded_sql(pStmt);
4989 Tcl_SetResult(interp, z, TCL_VOLATILE);
4990 sqlite3_free(z);
4991 return TCL_OK;
4992 }
4993 #ifdef SQLITE_ENABLE_NORMALIZE
test_norm_sql(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])4994 static int SQLITE_TCLAPI test_norm_sql(
4995 void * clientData,
4996 Tcl_Interp *interp,
4997 int objc,
4998 Tcl_Obj *CONST objv[]
4999 ){
5000 sqlite3_stmt *pStmt;
5001
5002 if( objc!=2 ){
5003 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
5004 return TCL_ERROR;
5005 }
5006
5007 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5008 Tcl_SetResult(interp, (char *)sqlite3_normalized_sql(pStmt), TCL_VOLATILE);
5009 return TCL_OK;
5010 }
5011 #endif /* SQLITE_ENABLE_NORMALIZE */
5012
5013 /*
5014 ** Usage: sqlite3_column_count STMT
5015 **
5016 ** Return the number of columns returned by the sql statement STMT.
5017 */
test_column_count(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5018 static int SQLITE_TCLAPI test_column_count(
5019 void * clientData,
5020 Tcl_Interp *interp,
5021 int objc,
5022 Tcl_Obj *CONST objv[]
5023 ){
5024 sqlite3_stmt *pStmt;
5025
5026 if( objc!=2 ){
5027 Tcl_AppendResult(interp, "wrong # args: should be \"",
5028 Tcl_GetString(objv[0]), " STMT column", 0);
5029 return TCL_ERROR;
5030 }
5031
5032 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5033
5034 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_column_count(pStmt)));
5035 return TCL_OK;
5036 }
5037
5038 /*
5039 ** Usage: sqlite3_column_type STMT column
5040 **
5041 ** Return the type of the data in column 'column' of the current row.
5042 */
test_column_type(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5043 static int SQLITE_TCLAPI test_column_type(
5044 void * clientData,
5045 Tcl_Interp *interp,
5046 int objc,
5047 Tcl_Obj *CONST objv[]
5048 ){
5049 sqlite3_stmt *pStmt;
5050 int col;
5051 int tp;
5052
5053 if( objc!=3 ){
5054 Tcl_AppendResult(interp, "wrong # args: should be \"",
5055 Tcl_GetString(objv[0]), " STMT column", 0);
5056 return TCL_ERROR;
5057 }
5058
5059 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5060 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5061
5062 tp = sqlite3_column_type(pStmt, col);
5063 switch( tp ){
5064 case SQLITE_INTEGER:
5065 Tcl_SetResult(interp, "INTEGER", TCL_STATIC);
5066 break;
5067 case SQLITE_NULL:
5068 Tcl_SetResult(interp, "NULL", TCL_STATIC);
5069 break;
5070 case SQLITE_FLOAT:
5071 Tcl_SetResult(interp, "FLOAT", TCL_STATIC);
5072 break;
5073 case SQLITE_TEXT:
5074 Tcl_SetResult(interp, "TEXT", TCL_STATIC);
5075 break;
5076 case SQLITE_BLOB:
5077 Tcl_SetResult(interp, "BLOB", TCL_STATIC);
5078 break;
5079 default:
5080 assert(0);
5081 }
5082
5083 return TCL_OK;
5084 }
5085
5086 /*
5087 ** Usage: sqlite3_column_int64 STMT column
5088 **
5089 ** Return the data in column 'column' of the current row cast as an
5090 ** wide (64-bit) integer.
5091 */
test_column_int64(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5092 static int SQLITE_TCLAPI test_column_int64(
5093 void * clientData,
5094 Tcl_Interp *interp,
5095 int objc,
5096 Tcl_Obj *CONST objv[]
5097 ){
5098 sqlite3_stmt *pStmt;
5099 int col;
5100 i64 iVal;
5101
5102 if( objc!=3 ){
5103 Tcl_AppendResult(interp, "wrong # args: should be \"",
5104 Tcl_GetString(objv[0]), " STMT column", 0);
5105 return TCL_ERROR;
5106 }
5107
5108 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5109 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5110
5111 iVal = sqlite3_column_int64(pStmt, col);
5112 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal));
5113 return TCL_OK;
5114 }
5115
5116 /*
5117 ** Usage: sqlite3_column_blob STMT column
5118 */
test_column_blob(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5119 static int SQLITE_TCLAPI test_column_blob(
5120 void * clientData,
5121 Tcl_Interp *interp,
5122 int objc,
5123 Tcl_Obj *CONST objv[]
5124 ){
5125 sqlite3_stmt *pStmt;
5126 int col;
5127
5128 int len;
5129 const void *pBlob;
5130
5131 if( objc!=3 ){
5132 Tcl_AppendResult(interp, "wrong # args: should be \"",
5133 Tcl_GetString(objv[0]), " STMT column", 0);
5134 return TCL_ERROR;
5135 }
5136
5137 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5138 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5139
5140 len = sqlite3_column_bytes(pStmt, col);
5141 pBlob = sqlite3_column_blob(pStmt, col);
5142 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len));
5143 return TCL_OK;
5144 }
5145
5146 /*
5147 ** Usage: sqlite3_column_double STMT column
5148 **
5149 ** Return the data in column 'column' of the current row cast as a double.
5150 */
test_column_double(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5151 static int SQLITE_TCLAPI test_column_double(
5152 void * clientData,
5153 Tcl_Interp *interp,
5154 int objc,
5155 Tcl_Obj *CONST objv[]
5156 ){
5157 sqlite3_stmt *pStmt;
5158 int col;
5159 double rVal;
5160
5161 if( objc!=3 ){
5162 Tcl_AppendResult(interp, "wrong # args: should be \"",
5163 Tcl_GetString(objv[0]), " STMT column", 0);
5164 return TCL_ERROR;
5165 }
5166
5167 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5168 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5169
5170 rVal = sqlite3_column_double(pStmt, col);
5171 Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal));
5172 return TCL_OK;
5173 }
5174
5175 /*
5176 ** Usage: sqlite3_data_count STMT
5177 **
5178 ** Return the number of columns returned by the sql statement STMT.
5179 */
test_data_count(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5180 static int SQLITE_TCLAPI test_data_count(
5181 void * clientData,
5182 Tcl_Interp *interp,
5183 int objc,
5184 Tcl_Obj *CONST objv[]
5185 ){
5186 sqlite3_stmt *pStmt;
5187
5188 if( objc!=2 ){
5189 Tcl_AppendResult(interp, "wrong # args: should be \"",
5190 Tcl_GetString(objv[0]), " STMT column", 0);
5191 return TCL_ERROR;
5192 }
5193
5194 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5195
5196 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_data_count(pStmt)));
5197 return TCL_OK;
5198 }
5199
5200 /*
5201 ** Usage: sqlite3_column_text STMT column
5202 **
5203 ** Usage: sqlite3_column_decltype STMT column
5204 **
5205 ** Usage: sqlite3_column_name STMT column
5206 */
test_stmt_utf8(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5207 static int SQLITE_TCLAPI test_stmt_utf8(
5208 void * clientData, /* Pointer to SQLite API function to be invoke */
5209 Tcl_Interp *interp,
5210 int objc,
5211 Tcl_Obj *CONST objv[]
5212 ){
5213 sqlite3_stmt *pStmt;
5214 int col;
5215 const char *(*xFunc)(sqlite3_stmt*, int);
5216 const char *zRet;
5217
5218 xFunc = (const char *(*)(sqlite3_stmt*, int))clientData;
5219 if( objc!=3 ){
5220 Tcl_AppendResult(interp, "wrong # args: should be \"",
5221 Tcl_GetString(objv[0]), " STMT column", 0);
5222 return TCL_ERROR;
5223 }
5224
5225 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5226 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5227 zRet = xFunc(pStmt, col);
5228 if( zRet ){
5229 Tcl_SetResult(interp, (char *)zRet, 0);
5230 }
5231 return TCL_OK;
5232 }
5233
test_global_recover(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5234 static int SQLITE_TCLAPI test_global_recover(
5235 void * clientData,
5236 Tcl_Interp *interp,
5237 int objc,
5238 Tcl_Obj *CONST objv[]
5239 ){
5240 #ifndef SQLITE_OMIT_DEPRECATED
5241 int rc;
5242 if( objc!=1 ){
5243 Tcl_WrongNumArgs(interp, 1, objv, "");
5244 return TCL_ERROR;
5245 }
5246 rc = sqlite3_global_recover();
5247 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
5248 #endif
5249 return TCL_OK;
5250 }
5251
5252 /*
5253 ** Usage: sqlite3_column_text STMT column
5254 **
5255 ** Usage: sqlite3_column_decltype STMT column
5256 **
5257 ** Usage: sqlite3_column_name STMT column
5258 */
test_stmt_utf16(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5259 static int SQLITE_TCLAPI test_stmt_utf16(
5260 void * clientData, /* Pointer to SQLite API function to be invoked */
5261 Tcl_Interp *interp,
5262 int objc,
5263 Tcl_Obj *CONST objv[]
5264 ){
5265 #ifndef SQLITE_OMIT_UTF16
5266 sqlite3_stmt *pStmt;
5267 int col;
5268 Tcl_Obj *pRet;
5269 const void *zName16;
5270 const void *(*xFunc)(sqlite3_stmt*, int);
5271
5272 xFunc = (const void *(*)(sqlite3_stmt*, int))clientData;
5273 if( objc!=3 ){
5274 Tcl_AppendResult(interp, "wrong # args: should be \"",
5275 Tcl_GetString(objv[0]), " STMT column", 0);
5276 return TCL_ERROR;
5277 }
5278
5279 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5280 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5281
5282 zName16 = xFunc(pStmt, col);
5283 if( zName16 ){
5284 int n;
5285 const char *z = zName16;
5286 for(n=0; z[n] || z[n+1]; n+=2){}
5287 pRet = Tcl_NewByteArrayObj(zName16, n+2);
5288 Tcl_SetObjResult(interp, pRet);
5289 }
5290 #endif /* SQLITE_OMIT_UTF16 */
5291
5292 return TCL_OK;
5293 }
5294
5295 /*
5296 ** Usage: sqlite3_column_int STMT column
5297 **
5298 ** Usage: sqlite3_column_bytes STMT column
5299 **
5300 ** Usage: sqlite3_column_bytes16 STMT column
5301 **
5302 */
test_stmt_int(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5303 static int SQLITE_TCLAPI test_stmt_int(
5304 void * clientData, /* Pointer to SQLite API function to be invoked */
5305 Tcl_Interp *interp,
5306 int objc,
5307 Tcl_Obj *CONST objv[]
5308 ){
5309 sqlite3_stmt *pStmt;
5310 int col;
5311 int (*xFunc)(sqlite3_stmt*, int);
5312
5313 xFunc = (int (*)(sqlite3_stmt*, int))clientData;
5314 if( objc!=3 ){
5315 Tcl_AppendResult(interp, "wrong # args: should be \"",
5316 Tcl_GetString(objv[0]), " STMT column", 0);
5317 return TCL_ERROR;
5318 }
5319
5320 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
5321 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
5322
5323 Tcl_SetObjResult(interp, Tcl_NewIntObj(xFunc(pStmt, col)));
5324 return TCL_OK;
5325 }
5326
5327 /*
5328 ** Usage: sqlite_set_magic DB MAGIC-NUMBER
5329 **
5330 ** Set the db->magic value. This is used to test error recovery logic.
5331 */
sqlite_set_magic(void * clientData,Tcl_Interp * interp,int argc,char ** argv)5332 static int SQLITE_TCLAPI sqlite_set_magic(
5333 void * clientData,
5334 Tcl_Interp *interp,
5335 int argc,
5336 char **argv
5337 ){
5338 sqlite3 *db;
5339 if( argc!=3 ){
5340 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
5341 " DB MAGIC", 0);
5342 return TCL_ERROR;
5343 }
5344 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
5345 if( strcmp(argv[2], "SQLITE_MAGIC_OPEN")==0 ){
5346 db->magic = SQLITE_MAGIC_OPEN;
5347 }else if( strcmp(argv[2], "SQLITE_MAGIC_CLOSED")==0 ){
5348 db->magic = SQLITE_MAGIC_CLOSED;
5349 }else if( strcmp(argv[2], "SQLITE_MAGIC_BUSY")==0 ){
5350 db->magic = SQLITE_MAGIC_BUSY;
5351 }else if( strcmp(argv[2], "SQLITE_MAGIC_ERROR")==0 ){
5352 db->magic = SQLITE_MAGIC_ERROR;
5353 }else if( Tcl_GetInt(interp, argv[2], (int*)&db->magic) ){
5354 return TCL_ERROR;
5355 }
5356 return TCL_OK;
5357 }
5358
5359 /*
5360 ** Usage: sqlite3_interrupt DB
5361 **
5362 ** Trigger an interrupt on DB
5363 */
test_interrupt(void * clientData,Tcl_Interp * interp,int argc,char ** argv)5364 static int SQLITE_TCLAPI test_interrupt(
5365 void * clientData,
5366 Tcl_Interp *interp,
5367 int argc,
5368 char **argv
5369 ){
5370 sqlite3 *db;
5371 if( argc!=2 ){
5372 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB", 0);
5373 return TCL_ERROR;
5374 }
5375 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
5376 sqlite3_interrupt(db);
5377 return TCL_OK;
5378 }
5379
5380 /*
5381 ** Usage: sqlite_delete_function DB function-name
5382 **
5383 ** Delete the user function 'function-name' from database handle DB. It
5384 ** is assumed that the user function was created as UTF8, any number of
5385 ** arguments (the way the TCL interface does it).
5386 */
delete_function(void * clientData,Tcl_Interp * interp,int argc,char ** argv)5387 static int SQLITE_TCLAPI delete_function(
5388 void * clientData,
5389 Tcl_Interp *interp,
5390 int argc,
5391 char **argv
5392 ){
5393 int rc;
5394 sqlite3 *db;
5395 if( argc!=3 ){
5396 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
5397 " DB function-name", 0);
5398 return TCL_ERROR;
5399 }
5400 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
5401 rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 0, 0, 0);
5402 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
5403 return TCL_OK;
5404 }
5405
5406 /*
5407 ** Usage: sqlite_delete_collation DB collation-name
5408 **
5409 ** Delete the collation sequence 'collation-name' from database handle
5410 ** DB. It is assumed that the collation sequence was created as UTF8 (the
5411 ** way the TCL interface does it).
5412 */
delete_collation(void * clientData,Tcl_Interp * interp,int argc,char ** argv)5413 static int SQLITE_TCLAPI delete_collation(
5414 void * clientData,
5415 Tcl_Interp *interp,
5416 int argc,
5417 char **argv
5418 ){
5419 int rc;
5420 sqlite3 *db;
5421 if( argc!=3 ){
5422 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
5423 " DB function-name", 0);
5424 return TCL_ERROR;
5425 }
5426 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
5427 rc = sqlite3_create_collation(db, argv[2], SQLITE_UTF8, 0, 0);
5428 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
5429 return TCL_OK;
5430 }
5431
5432 /*
5433 ** Usage: sqlite3_get_autocommit DB
5434 **
5435 ** Return true if the database DB is currently in auto-commit mode.
5436 ** Return false if not.
5437 */
get_autocommit(void * clientData,Tcl_Interp * interp,int argc,char ** argv)5438 static int SQLITE_TCLAPI get_autocommit(
5439 void * clientData,
5440 Tcl_Interp *interp,
5441 int argc,
5442 char **argv
5443 ){
5444 char zBuf[30];
5445 sqlite3 *db;
5446 if( argc!=2 ){
5447 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
5448 " DB", 0);
5449 return TCL_ERROR;
5450 }
5451 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
5452 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3_get_autocommit(db));
5453 Tcl_AppendResult(interp, zBuf, 0);
5454 return TCL_OK;
5455 }
5456
5457 /*
5458 ** Usage: sqlite3_busy_timeout DB MS
5459 **
5460 ** Set the busy timeout. This is more easily done using the timeout
5461 ** method of the TCL interface. But we need a way to test the case
5462 ** where it returns SQLITE_MISUSE.
5463 */
test_busy_timeout(void * clientData,Tcl_Interp * interp,int argc,char ** argv)5464 static int SQLITE_TCLAPI test_busy_timeout(
5465 void * clientData,
5466 Tcl_Interp *interp,
5467 int argc,
5468 char **argv
5469 ){
5470 int rc, ms;
5471 sqlite3 *db;
5472 if( argc!=3 ){
5473 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
5474 " DB", 0);
5475 return TCL_ERROR;
5476 }
5477 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
5478 if( Tcl_GetInt(interp, argv[2], &ms) ) return TCL_ERROR;
5479 rc = sqlite3_busy_timeout(db, ms);
5480 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
5481 return TCL_OK;
5482 }
5483
5484 /*
5485 ** Usage: tcl_variable_type VARIABLENAME
5486 **
5487 ** Return the name of the internal representation for the
5488 ** value of the given variable.
5489 */
tcl_variable_type(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5490 static int SQLITE_TCLAPI tcl_variable_type(
5491 void * clientData,
5492 Tcl_Interp *interp,
5493 int objc,
5494 Tcl_Obj *CONST objv[]
5495 ){
5496 Tcl_Obj *pVar;
5497 if( objc!=2 ){
5498 Tcl_WrongNumArgs(interp, 1, objv, "VARIABLE");
5499 return TCL_ERROR;
5500 }
5501 pVar = Tcl_GetVar2Ex(interp, Tcl_GetString(objv[1]), 0, TCL_LEAVE_ERR_MSG);
5502 if( pVar==0 ) return TCL_ERROR;
5503 if( pVar->typePtr ){
5504 Tcl_SetObjResult(interp, Tcl_NewStringObj(pVar->typePtr->name, -1));
5505 }
5506 return TCL_OK;
5507 }
5508
5509 /*
5510 ** Usage: sqlite3_release_memory ?N?
5511 **
5512 ** Attempt to release memory currently held but not actually required.
5513 ** The integer N is the number of bytes we are trying to release. The
5514 ** return value is the amount of memory actually released.
5515 */
test_release_memory(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5516 static int SQLITE_TCLAPI test_release_memory(
5517 void * clientData,
5518 Tcl_Interp *interp,
5519 int objc,
5520 Tcl_Obj *CONST objv[]
5521 ){
5522 #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)
5523 int N;
5524 int amt;
5525 if( objc!=1 && objc!=2 ){
5526 Tcl_WrongNumArgs(interp, 1, objv, "?N?");
5527 return TCL_ERROR;
5528 }
5529 if( objc==2 ){
5530 if( Tcl_GetIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
5531 }else{
5532 N = -1;
5533 }
5534 amt = sqlite3_release_memory(N);
5535 Tcl_SetObjResult(interp, Tcl_NewIntObj(amt));
5536 #endif
5537 return TCL_OK;
5538 }
5539
5540
5541 /*
5542 ** Usage: sqlite3_db_release_memory DB
5543 **
5544 ** Attempt to release memory currently held by database DB. Return the
5545 ** result code (which in the current implementation is always zero).
5546 */
test_db_release_memory(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5547 static int SQLITE_TCLAPI test_db_release_memory(
5548 void * clientData,
5549 Tcl_Interp *interp,
5550 int objc,
5551 Tcl_Obj *CONST objv[]
5552 ){
5553 sqlite3 *db;
5554 int rc;
5555 if( objc!=2 ){
5556 Tcl_WrongNumArgs(interp, 1, objv, "DB");
5557 return TCL_ERROR;
5558 }
5559 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5560 rc = sqlite3_db_release_memory(db);
5561 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
5562 return TCL_OK;
5563 }
5564
5565 /*
5566 ** Usage: sqlite3_db_cacheflush DB
5567 **
5568 ** Attempt to flush any dirty pages to disk.
5569 */
test_db_cacheflush(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5570 static int SQLITE_TCLAPI test_db_cacheflush(
5571 void * clientData,
5572 Tcl_Interp *interp,
5573 int objc,
5574 Tcl_Obj *CONST objv[]
5575 ){
5576 sqlite3 *db;
5577 int rc;
5578 if( objc!=2 ){
5579 Tcl_WrongNumArgs(interp, 1, objv, "DB");
5580 return TCL_ERROR;
5581 }
5582 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5583 rc = sqlite3_db_cacheflush(db);
5584 if( rc ){
5585 Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC);
5586 return TCL_ERROR;
5587 }
5588
5589 Tcl_ResetResult(interp);
5590 return TCL_OK;
5591 }
5592
5593 /*
5594 ** Usage: sqlite3_system_errno DB
5595 **
5596 ** Return the low-level system errno value.
5597 */
test_system_errno(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5598 static int SQLITE_TCLAPI test_system_errno(
5599 void * clientData,
5600 Tcl_Interp *interp,
5601 int objc,
5602 Tcl_Obj *CONST objv[]
5603 ){
5604 sqlite3 *db;
5605 int iErrno;
5606 if( objc!=2 ){
5607 Tcl_WrongNumArgs(interp, 1, objv, "DB");
5608 return TCL_ERROR;
5609 }
5610 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5611 iErrno = sqlite3_system_errno(db);
5612 Tcl_SetObjResult(interp, Tcl_NewIntObj(iErrno));
5613 return TCL_OK;
5614 }
5615
5616 /*
5617 ** Usage: sqlite3_db_filename DB DBNAME
5618 **
5619 ** Return the name of a file associated with a database.
5620 */
test_db_filename(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5621 static int SQLITE_TCLAPI test_db_filename(
5622 void * clientData,
5623 Tcl_Interp *interp,
5624 int objc,
5625 Tcl_Obj *CONST objv[]
5626 ){
5627 sqlite3 *db;
5628 const char *zDbName;
5629 if( objc!=3 ){
5630 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
5631 return TCL_ERROR;
5632 }
5633 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5634 zDbName = Tcl_GetString(objv[2]);
5635 Tcl_AppendResult(interp, sqlite3_db_filename(db, zDbName), (void*)0);
5636 return TCL_OK;
5637 }
5638
5639 /*
5640 ** Usage: sqlite3_db_readonly DB DBNAME
5641 **
5642 ** Return 1 or 0 if DBNAME is readonly or not. Return -1 if DBNAME does
5643 ** not exist.
5644 */
test_db_readonly(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5645 static int SQLITE_TCLAPI test_db_readonly(
5646 void * clientData,
5647 Tcl_Interp *interp,
5648 int objc,
5649 Tcl_Obj *CONST objv[]
5650 ){
5651 sqlite3 *db;
5652 const char *zDbName;
5653 if( objc!=3 ){
5654 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
5655 return TCL_ERROR;
5656 }
5657 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5658 zDbName = Tcl_GetString(objv[2]);
5659 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_db_readonly(db, zDbName)));
5660 return TCL_OK;
5661 }
5662
5663 /*
5664 ** Usage: sqlite3_soft_heap_limit ?N?
5665 **
5666 ** Query or set the soft heap limit for the current thread. The
5667 ** limit is only changed if the N is present. The previous limit
5668 ** is returned.
5669 */
test_soft_heap_limit(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5670 static int SQLITE_TCLAPI test_soft_heap_limit(
5671 void * clientData,
5672 Tcl_Interp *interp,
5673 int objc,
5674 Tcl_Obj *CONST objv[]
5675 ){
5676 sqlite3_int64 amt;
5677 Tcl_WideInt N = -1;
5678 if( objc!=1 && objc!=2 ){
5679 Tcl_WrongNumArgs(interp, 1, objv, "?N?");
5680 return TCL_ERROR;
5681 }
5682 if( objc==2 ){
5683 if( Tcl_GetWideIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
5684 }
5685 amt = sqlite3_soft_heap_limit64(N);
5686 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(amt));
5687 return TCL_OK;
5688 }
5689
5690 /*
5691 ** Usage: sqlite3_hard_heap_limit ?N?
5692 **
5693 ** Query or set the hard heap limit for the current thread. The
5694 ** limit is only changed if the N is present. The previous limit
5695 ** is returned.
5696 */
test_hard_heap_limit(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5697 static int SQLITE_TCLAPI test_hard_heap_limit(
5698 void * clientData,
5699 Tcl_Interp *interp,
5700 int objc,
5701 Tcl_Obj *CONST objv[]
5702 ){
5703 sqlite3_int64 amt;
5704 Tcl_WideInt N = -1;
5705 if( objc!=1 && objc!=2 ){
5706 Tcl_WrongNumArgs(interp, 1, objv, "?N?");
5707 return TCL_ERROR;
5708 }
5709 if( objc==2 ){
5710 if( Tcl_GetWideIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
5711 }
5712 amt = sqlite3_hard_heap_limit64(N);
5713 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(amt));
5714 return TCL_OK;
5715 }
5716
5717 /*
5718 ** Usage: sqlite3_thread_cleanup
5719 **
5720 ** Call the sqlite3_thread_cleanup API.
5721 */
test_thread_cleanup(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5722 static int SQLITE_TCLAPI test_thread_cleanup(
5723 void * clientData,
5724 Tcl_Interp *interp,
5725 int objc,
5726 Tcl_Obj *CONST objv[]
5727 ){
5728 #ifndef SQLITE_OMIT_DEPRECATED
5729 sqlite3_thread_cleanup();
5730 #endif
5731 return TCL_OK;
5732 }
5733
5734 /*
5735 ** Usage: sqlite3_pager_refcounts DB
5736 **
5737 ** Return a list of numbers which are the PagerRefcount for all
5738 ** pagers on each database connection.
5739 */
test_pager_refcounts(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5740 static int SQLITE_TCLAPI test_pager_refcounts(
5741 void * clientData,
5742 Tcl_Interp *interp,
5743 int objc,
5744 Tcl_Obj *CONST objv[]
5745 ){
5746 sqlite3 *db;
5747 int i;
5748 int v, *a;
5749 Tcl_Obj *pResult;
5750
5751 if( objc!=2 ){
5752 Tcl_AppendResult(interp, "wrong # args: should be \"",
5753 Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
5754 return TCL_ERROR;
5755 }
5756 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5757 pResult = Tcl_NewObj();
5758 for(i=0; i<db->nDb; i++){
5759 if( db->aDb[i].pBt==0 ){
5760 v = -1;
5761 }else{
5762 sqlite3_mutex_enter(db->mutex);
5763 a = sqlite3PagerStats(sqlite3BtreePager(db->aDb[i].pBt));
5764 v = a[0];
5765 sqlite3_mutex_leave(db->mutex);
5766 }
5767 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(v));
5768 }
5769 Tcl_SetObjResult(interp, pResult);
5770 return TCL_OK;
5771 }
5772
5773
5774 /*
5775 ** tclcmd: working_64bit_int
5776 **
5777 ** Some TCL builds (ex: cygwin) do not support 64-bit integers. This
5778 ** leads to a number of test failures. The present command checks the
5779 ** TCL build to see whether or not it supports 64-bit integers. It
5780 ** returns TRUE if it does and FALSE if not.
5781 **
5782 ** This command is used to warn users that their TCL build is defective
5783 ** and that the errors they are seeing in the test scripts might be
5784 ** a result of their defective TCL rather than problems in SQLite.
5785 */
working_64bit_int(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5786 static int SQLITE_TCLAPI working_64bit_int(
5787 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
5788 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
5789 int objc, /* Number of arguments */
5790 Tcl_Obj *CONST objv[] /* Command arguments */
5791 ){
5792 Tcl_Obj *pTestObj;
5793 int working = 0;
5794
5795 pTestObj = Tcl_NewWideIntObj(1000000*(i64)1234567890);
5796 working = strcmp(Tcl_GetString(pTestObj), "1234567890000000")==0;
5797 Tcl_DecrRefCount(pTestObj);
5798 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(working));
5799 return TCL_OK;
5800 }
5801
5802
5803 /*
5804 ** tclcmd: vfs_unlink_test
5805 **
5806 ** This TCL command unregisters the primary VFS and then registers
5807 ** it back again. This is used to test the ability to register a
5808 ** VFS when none are previously registered, and the ability to
5809 ** unregister the only available VFS. Ticket #2738
5810 */
vfs_unlink_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5811 static int SQLITE_TCLAPI vfs_unlink_test(
5812 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
5813 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
5814 int objc, /* Number of arguments */
5815 Tcl_Obj *CONST objv[] /* Command arguments */
5816 ){
5817 int i;
5818 sqlite3_vfs *pMain;
5819 sqlite3_vfs *apVfs[20];
5820 sqlite3_vfs one, two;
5821
5822 sqlite3_vfs_unregister(0); /* Unregister of NULL is harmless */
5823 one.zName = "__one";
5824 two.zName = "__two";
5825
5826 /* Calling sqlite3_vfs_register with 2nd argument of 0 does not
5827 ** change the default VFS
5828 */
5829 pMain = sqlite3_vfs_find(0);
5830 sqlite3_vfs_register(&one, 0);
5831 assert( pMain==0 || pMain==sqlite3_vfs_find(0) );
5832 sqlite3_vfs_register(&two, 0);
5833 assert( pMain==0 || pMain==sqlite3_vfs_find(0) );
5834
5835 /* We can find a VFS by its name */
5836 assert( sqlite3_vfs_find("__one")==&one );
5837 assert( sqlite3_vfs_find("__two")==&two );
5838
5839 /* Calling sqlite_vfs_register with non-zero second parameter changes the
5840 ** default VFS, even if the 1st parameter is an existig VFS that is
5841 ** previously registered as the non-default.
5842 */
5843 sqlite3_vfs_register(&one, 1);
5844 assert( sqlite3_vfs_find("__one")==&one );
5845 assert( sqlite3_vfs_find("__two")==&two );
5846 assert( sqlite3_vfs_find(0)==&one );
5847 sqlite3_vfs_register(&two, 1);
5848 assert( sqlite3_vfs_find("__one")==&one );
5849 assert( sqlite3_vfs_find("__two")==&two );
5850 assert( sqlite3_vfs_find(0)==&two );
5851 if( pMain ){
5852 sqlite3_vfs_register(pMain, 1);
5853 assert( sqlite3_vfs_find("__one")==&one );
5854 assert( sqlite3_vfs_find("__two")==&two );
5855 assert( sqlite3_vfs_find(0)==pMain );
5856 }
5857
5858 /* Unlink the default VFS. Repeat until there are no more VFSes
5859 ** registered.
5860 */
5861 for(i=0; i<sizeof(apVfs)/sizeof(apVfs[0]); i++){
5862 apVfs[i] = sqlite3_vfs_find(0);
5863 if( apVfs[i] ){
5864 assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) );
5865 sqlite3_vfs_unregister(apVfs[i]);
5866 assert( 0==sqlite3_vfs_find(apVfs[i]->zName) );
5867 }
5868 }
5869 assert( 0==sqlite3_vfs_find(0) );
5870
5871 /* Register the main VFS as non-default (will be made default, since
5872 ** it'll be the only one in existence).
5873 */
5874 sqlite3_vfs_register(pMain, 0);
5875 assert( sqlite3_vfs_find(0)==pMain );
5876
5877 /* Un-register the main VFS again to restore an empty VFS list */
5878 sqlite3_vfs_unregister(pMain);
5879 assert( 0==sqlite3_vfs_find(0) );
5880
5881 /* Relink all VFSes in reverse order. */
5882 for(i=sizeof(apVfs)/sizeof(apVfs[0])-1; i>=0; i--){
5883 if( apVfs[i] ){
5884 sqlite3_vfs_register(apVfs[i], 1);
5885 assert( apVfs[i]==sqlite3_vfs_find(0) );
5886 assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) );
5887 }
5888 }
5889
5890 /* Unregister out sample VFSes. */
5891 sqlite3_vfs_unregister(&one);
5892 sqlite3_vfs_unregister(&two);
5893
5894 /* Unregistering a VFS that is not currently registered is harmless */
5895 sqlite3_vfs_unregister(&one);
5896 sqlite3_vfs_unregister(&two);
5897 assert( sqlite3_vfs_find("__one")==0 );
5898 assert( sqlite3_vfs_find("__two")==0 );
5899
5900 /* We should be left with the original default VFS back as the
5901 ** original */
5902 assert( sqlite3_vfs_find(0)==pMain );
5903
5904 return TCL_OK;
5905 }
5906
5907 /*
5908 ** tclcmd: vfs_initfail_test
5909 **
5910 ** This TCL command attempts to vfs_find and vfs_register when the
5911 ** sqlite3_initialize() interface is failing. All calls should fail.
5912 */
vfs_initfail_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5913 static int SQLITE_TCLAPI vfs_initfail_test(
5914 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
5915 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
5916 int objc, /* Number of arguments */
5917 Tcl_Obj *CONST objv[] /* Command arguments */
5918 ){
5919 sqlite3_vfs one;
5920 one.zName = "__one";
5921
5922 if( sqlite3_vfs_find(0) ) return TCL_ERROR;
5923 sqlite3_vfs_register(&one, 0);
5924 if( sqlite3_vfs_find(0) ) return TCL_ERROR;
5925 sqlite3_vfs_register(&one, 1);
5926 if( sqlite3_vfs_find(0) ) return TCL_ERROR;
5927 return TCL_OK;
5928 }
5929
5930 /*
5931 ** Saved VFSes
5932 */
5933 static sqlite3_vfs *apVfs[20];
5934 static int nVfs = 0;
5935
5936 /*
5937 ** tclcmd: vfs_unregister_all
5938 **
5939 ** Unregister all VFSes.
5940 */
vfs_unregister_all(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5941 static int SQLITE_TCLAPI vfs_unregister_all(
5942 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
5943 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
5944 int objc, /* Number of arguments */
5945 Tcl_Obj *CONST objv[] /* Command arguments */
5946 ){
5947 int i;
5948 for(i=0; i<ArraySize(apVfs); i++){
5949 apVfs[i] = sqlite3_vfs_find(0);
5950 if( apVfs[i]==0 ) break;
5951 sqlite3_vfs_unregister(apVfs[i]);
5952 }
5953 nVfs = i;
5954 return TCL_OK;
5955 }
5956 /*
5957 ** tclcmd: vfs_reregister_all
5958 **
5959 ** Restore all VFSes that were removed using vfs_unregister_all. Taking
5960 ** care to put the linked list back together in the same order as it was
5961 ** in before vfs_unregister_all was invoked.
5962 */
vfs_reregister_all(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5963 static int SQLITE_TCLAPI vfs_reregister_all(
5964 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
5965 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
5966 int objc, /* Number of arguments */
5967 Tcl_Obj *CONST objv[] /* Command arguments */
5968 ){
5969 int i;
5970 for(i=nVfs-1; i>=0; i--){
5971 sqlite3_vfs_register(apVfs[i], 1);
5972 }
5973 return TCL_OK;
5974 }
5975
5976
5977 /*
5978 ** tclcmd: file_control_test DB
5979 **
5980 ** This TCL command runs the sqlite3_file_control interface and
5981 ** verifies correct operation of the same.
5982 */
file_control_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])5983 static int SQLITE_TCLAPI file_control_test(
5984 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
5985 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
5986 int objc, /* Number of arguments */
5987 Tcl_Obj *CONST objv[] /* Command arguments */
5988 ){
5989 int iArg = 0;
5990 sqlite3 *db;
5991 int rc;
5992
5993 if( objc!=2 ){
5994 Tcl_AppendResult(interp, "wrong # args: should be \"",
5995 Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
5996 return TCL_ERROR;
5997 }
5998 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
5999 rc = sqlite3_file_control(db, 0, 0, &iArg);
6000 assert( rc==SQLITE_NOTFOUND );
6001 rc = sqlite3_file_control(db, "notadatabase", SQLITE_FCNTL_LOCKSTATE, &iArg);
6002 assert( rc==SQLITE_ERROR );
6003 rc = sqlite3_file_control(db, "main", -1, &iArg);
6004 assert( rc==SQLITE_NOTFOUND );
6005 rc = sqlite3_file_control(db, "temp", -1, &iArg);
6006 assert( rc==SQLITE_NOTFOUND || rc==SQLITE_ERROR );
6007
6008 return TCL_OK;
6009 }
6010
6011
6012 /*
6013 ** tclcmd: file_control_lasterrno_test DB
6014 **
6015 ** This TCL command runs the sqlite3_file_control interface and
6016 ** verifies correct operation of the SQLITE_LAST_ERRNO verb.
6017 */
file_control_lasterrno_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6018 static int SQLITE_TCLAPI file_control_lasterrno_test(
6019 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6020 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6021 int objc, /* Number of arguments */
6022 Tcl_Obj *CONST objv[] /* Command arguments */
6023 ){
6024 int iArg = 0;
6025 sqlite3 *db;
6026 int rc;
6027
6028 if( objc!=2 ){
6029 Tcl_AppendResult(interp, "wrong # args: should be \"",
6030 Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
6031 return TCL_ERROR;
6032 }
6033 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6034 return TCL_ERROR;
6035 }
6036 rc = sqlite3_file_control(db, NULL, SQLITE_LAST_ERRNO, &iArg);
6037 if( rc ){
6038 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
6039 return TCL_ERROR;
6040 }
6041 if( iArg!=0 ) {
6042 Tcl_AppendResult(interp, "Unexpected non-zero errno: ",
6043 Tcl_GetStringFromObj(Tcl_NewIntObj(iArg), 0), " ", 0);
6044 return TCL_ERROR;
6045 }
6046 return TCL_OK;
6047 }
6048
6049 /*
6050 ** tclcmd: file_control_data_version DB DBNAME
6051 **
6052 ** This TCL command runs the sqlite3_file_control with the
6053 ** SQLITE_FCNTL_DATA_VERSION opcode, returning the result.
6054 */
file_control_data_version(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6055 static int SQLITE_TCLAPI file_control_data_version(
6056 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6057 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6058 int objc, /* Number of arguments */
6059 Tcl_Obj *CONST objv[] /* Command arguments */
6060 ){
6061 unsigned int iVers; /* data version */
6062 char *zDb; /* Db name ("main", "temp" etc.) */
6063 sqlite3 *db; /* Database handle */
6064 int rc; /* file_control() return code */
6065 char zBuf[100];
6066
6067 if( objc!=3 && objc!=2 ){
6068 Tcl_WrongNumArgs(interp, 1, objv, "DB [DBNAME]");
6069 return TCL_ERROR;
6070 }
6071 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6072 return TCL_ERROR;
6073 }
6074 zDb = objc==3 ? Tcl_GetString(objv[2]) : NULL;
6075
6076 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_DATA_VERSION, (void *)&iVers);
6077 if( rc ){
6078 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
6079 return TCL_ERROR;
6080 }else{
6081 sqlite3_snprintf(sizeof(zBuf),zBuf,"%u",iVers);
6082 Tcl_SetResult(interp, (char *)zBuf, TCL_VOLATILE);
6083 return TCL_OK;
6084 }
6085 }
6086
6087 /*
6088 ** tclcmd: file_control_chunksize_test DB DBNAME SIZE
6089 **
6090 ** This TCL command runs the sqlite3_file_control interface and
6091 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
6092 ** SQLITE_SET_LOCKPROXYFILE verbs.
6093 */
file_control_chunksize_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6094 static int SQLITE_TCLAPI file_control_chunksize_test(
6095 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6096 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6097 int objc, /* Number of arguments */
6098 Tcl_Obj *CONST objv[] /* Command arguments */
6099 ){
6100 int nSize; /* New chunk size */
6101 char *zDb; /* Db name ("main", "temp" etc.) */
6102 sqlite3 *db; /* Database handle */
6103 int rc; /* file_control() return code */
6104
6105 if( objc!=4 ){
6106 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE");
6107 return TCL_ERROR;
6108 }
6109 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
6110 || Tcl_GetIntFromObj(interp, objv[3], &nSize)
6111 ){
6112 return TCL_ERROR;
6113 }
6114 zDb = Tcl_GetString(objv[2]);
6115 if( zDb[0]=='\0' ) zDb = NULL;
6116
6117 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_CHUNK_SIZE, (void *)&nSize);
6118 if( rc ){
6119 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
6120 return TCL_ERROR;
6121 }
6122 return TCL_OK;
6123 }
6124
6125 /*
6126 ** tclcmd: file_control_sizehint_test DB DBNAME SIZE
6127 **
6128 ** This TCL command runs the sqlite3_file_control interface
6129 ** with SQLITE_FCNTL_SIZE_HINT
6130 */
file_control_sizehint_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6131 static int SQLITE_TCLAPI file_control_sizehint_test(
6132 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6133 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6134 int objc, /* Number of arguments */
6135 Tcl_Obj *CONST objv[] /* Command arguments */
6136 ){
6137 Tcl_WideInt nSize; /* Hinted size */
6138 char *zDb; /* Db name ("main", "temp" etc.) */
6139 sqlite3 *db; /* Database handle */
6140 int rc; /* file_control() return code */
6141
6142 if( objc!=4 ){
6143 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE");
6144 return TCL_ERROR;
6145 }
6146 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
6147 || Tcl_GetWideIntFromObj(interp, objv[3], &nSize)
6148 ){
6149 return TCL_ERROR;
6150 }
6151 zDb = Tcl_GetString(objv[2]);
6152 if( zDb[0]=='\0' ) zDb = NULL;
6153
6154 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_SIZE_HINT, (void *)&nSize);
6155 if( rc ){
6156 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
6157 return TCL_ERROR;
6158 }
6159 return TCL_OK;
6160 }
6161
6162 /*
6163 ** tclcmd: file_control_lockproxy_test DB PWD
6164 **
6165 ** This TCL command runs the sqlite3_file_control interface and
6166 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
6167 ** SQLITE_SET_LOCKPROXYFILE verbs.
6168 */
file_control_lockproxy_test(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6169 static int SQLITE_TCLAPI file_control_lockproxy_test(
6170 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6171 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6172 int objc, /* Number of arguments */
6173 Tcl_Obj *CONST objv[] /* Command arguments */
6174 ){
6175 sqlite3 *db;
6176
6177 if( objc!=3 ){
6178 Tcl_AppendResult(interp, "wrong # args: should be \"",
6179 Tcl_GetStringFromObj(objv[0], 0), " DB PWD", 0);
6180 return TCL_ERROR;
6181 }
6182 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6183 return TCL_ERROR;
6184 }
6185
6186 #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
6187 # if defined(__APPLE__)
6188 # define SQLITE_ENABLE_LOCKING_STYLE 1
6189 # else
6190 # define SQLITE_ENABLE_LOCKING_STYLE 0
6191 # endif
6192 #endif
6193 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
6194 {
6195 char *testPath;
6196 int rc;
6197 int nPwd;
6198 const char *zPwd;
6199 char proxyPath[400];
6200
6201 zPwd = Tcl_GetStringFromObj(objv[2], &nPwd);
6202 if( sizeof(proxyPath)<nPwd+20 ){
6203 Tcl_AppendResult(interp, "PWD too big", (void*)0);
6204 return TCL_ERROR;
6205 }
6206 sqlite3_snprintf(sizeof(proxyPath), proxyPath, "%s/test.proxy", zPwd);
6207 rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath);
6208 if( rc ){
6209 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
6210 return TCL_ERROR;
6211 }
6212 rc = sqlite3_file_control(db, NULL, SQLITE_GET_LOCKPROXYFILE, &testPath);
6213 if( strncmp(proxyPath,testPath,11) ){
6214 Tcl_AppendResult(interp, "Lock proxy file did not match the "
6215 "previously assigned value", 0);
6216 return TCL_ERROR;
6217 }
6218 if( rc ){
6219 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
6220 return TCL_ERROR;
6221 }
6222 rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath);
6223 if( rc ){
6224 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
6225 return TCL_ERROR;
6226 }
6227 }
6228 #endif
6229 return TCL_OK;
6230 }
6231
6232 #if SQLITE_OS_WIN
6233 /*
6234 ** tclcmd: file_control_win32_av_retry DB NRETRY DELAY
6235 **
6236 ** This TCL command runs the sqlite3_file_control interface with
6237 ** the SQLITE_FCNTL_WIN32_AV_RETRY opcode.
6238 */
file_control_win32_av_retry(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6239 static int SQLITE_TCLAPI file_control_win32_av_retry(
6240 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6241 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6242 int objc, /* Number of arguments */
6243 Tcl_Obj *CONST objv[] /* Command arguments */
6244 ){
6245 sqlite3 *db;
6246 int rc;
6247 int a[2];
6248 char z[100];
6249
6250 if( objc!=4 ){
6251 Tcl_AppendResult(interp, "wrong # args: should be \"",
6252 Tcl_GetStringFromObj(objv[0], 0), " DB NRETRY DELAY", 0);
6253 return TCL_ERROR;
6254 }
6255 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6256 return TCL_ERROR;
6257 }
6258 if( Tcl_GetIntFromObj(interp, objv[2], &a[0]) ) return TCL_ERROR;
6259 if( Tcl_GetIntFromObj(interp, objv[3], &a[1]) ) return TCL_ERROR;
6260 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_AV_RETRY, (void*)a);
6261 sqlite3_snprintf(sizeof(z), z, "%d %d %d", rc, a[0], a[1]);
6262 Tcl_AppendResult(interp, z, (char*)0);
6263 return TCL_OK;
6264 }
6265
6266 /*
6267 ** tclcmd: file_control_win32_get_handle DB
6268 **
6269 ** This TCL command runs the sqlite3_file_control interface with
6270 ** the SQLITE_FCNTL_WIN32_GET_HANDLE opcode.
6271 */
file_control_win32_get_handle(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6272 static int file_control_win32_get_handle(
6273 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6274 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6275 int objc, /* Number of arguments */
6276 Tcl_Obj *CONST objv[] /* Command arguments */
6277 ){
6278 sqlite3 *db;
6279 int rc;
6280 HANDLE hFile = NULL;
6281 char z[100];
6282
6283 if( objc!=2 ){
6284 Tcl_AppendResult(interp, "wrong # args: should be \"",
6285 Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
6286 return TCL_ERROR;
6287 }
6288 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6289 return TCL_ERROR;
6290 }
6291 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_GET_HANDLE,
6292 (void*)&hFile);
6293 sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile);
6294 Tcl_AppendResult(interp, z, (char*)0);
6295 return TCL_OK;
6296 }
6297
6298 /*
6299 ** tclcmd: file_control_win32_set_handle DB HANDLE
6300 **
6301 ** This TCL command runs the sqlite3_file_control interface with
6302 ** the SQLITE_FCNTL_WIN32_SET_HANDLE opcode.
6303 */
file_control_win32_set_handle(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6304 static int SQLITE_TCLAPI file_control_win32_set_handle(
6305 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6306 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6307 int objc, /* Number of arguments */
6308 Tcl_Obj *CONST objv[] /* Command arguments */
6309 ){
6310 sqlite3 *db;
6311 int rc;
6312 HANDLE hFile = NULL;
6313 char z[100];
6314
6315 if( objc!=3 ){
6316 Tcl_AppendResult(interp, "wrong # args: should be \"",
6317 Tcl_GetStringFromObj(objv[0], 0), " DB HANDLE", 0);
6318 return TCL_ERROR;
6319 }
6320 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6321 return TCL_ERROR;
6322 }
6323 if( getWin32Handle(interp, Tcl_GetString(objv[2]), &hFile) ){
6324 return TCL_ERROR;
6325 }
6326 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_SET_HANDLE,
6327 (void*)&hFile);
6328 sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile);
6329 Tcl_AppendResult(interp, z, (char*)0);
6330 return TCL_OK;
6331 }
6332 #endif
6333
6334 /*
6335 ** tclcmd: file_control_persist_wal DB PERSIST-FLAG
6336 **
6337 ** This TCL command runs the sqlite3_file_control interface with
6338 ** the SQLITE_FCNTL_PERSIST_WAL opcode.
6339 */
file_control_persist_wal(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6340 static int SQLITE_TCLAPI file_control_persist_wal(
6341 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6342 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6343 int objc, /* Number of arguments */
6344 Tcl_Obj *CONST objv[] /* Command arguments */
6345 ){
6346 sqlite3 *db;
6347 int rc;
6348 int bPersist;
6349 char z[100];
6350
6351 if( objc!=3 ){
6352 Tcl_AppendResult(interp, "wrong # args: should be \"",
6353 Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0);
6354 return TCL_ERROR;
6355 }
6356 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6357 return TCL_ERROR;
6358 }
6359 if( Tcl_GetIntFromObj(interp, objv[2], &bPersist) ) return TCL_ERROR;
6360 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_PERSIST_WAL, (void*)&bPersist);
6361 sqlite3_snprintf(sizeof(z), z, "%d %d", rc, bPersist);
6362 Tcl_AppendResult(interp, z, (char*)0);
6363 return TCL_OK;
6364 }
6365
6366 /*
6367 ** tclcmd: file_control_powersafe_overwrite DB PSOW-FLAG
6368 **
6369 ** This TCL command runs the sqlite3_file_control interface with
6370 ** the SQLITE_FCNTL_POWERSAFE_OVERWRITE opcode.
6371 */
file_control_powersafe_overwrite(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6372 static int SQLITE_TCLAPI file_control_powersafe_overwrite(
6373 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6374 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6375 int objc, /* Number of arguments */
6376 Tcl_Obj *CONST objv[] /* Command arguments */
6377 ){
6378 sqlite3 *db;
6379 int rc;
6380 int b;
6381 char z[100];
6382
6383 if( objc!=3 ){
6384 Tcl_AppendResult(interp, "wrong # args: should be \"",
6385 Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0);
6386 return TCL_ERROR;
6387 }
6388 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6389 return TCL_ERROR;
6390 }
6391 if( Tcl_GetIntFromObj(interp, objv[2], &b) ) return TCL_ERROR;
6392 rc = sqlite3_file_control(db,NULL,SQLITE_FCNTL_POWERSAFE_OVERWRITE,(void*)&b);
6393 sqlite3_snprintf(sizeof(z), z, "%d %d", rc, b);
6394 Tcl_AppendResult(interp, z, (char*)0);
6395 return TCL_OK;
6396 }
6397
6398
6399 /*
6400 ** tclcmd: file_control_vfsname DB ?AUXDB?
6401 **
6402 ** Return a string that describes the stack of VFSes.
6403 */
file_control_vfsname(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6404 static int SQLITE_TCLAPI file_control_vfsname(
6405 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6406 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6407 int objc, /* Number of arguments */
6408 Tcl_Obj *CONST objv[] /* Command arguments */
6409 ){
6410 sqlite3 *db;
6411 const char *zDbName = "main";
6412 char *zVfsName = 0;
6413
6414 if( objc!=2 && objc!=3 ){
6415 Tcl_AppendResult(interp, "wrong # args: should be \"",
6416 Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0);
6417 return TCL_ERROR;
6418 }
6419 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6420 return TCL_ERROR;
6421 }
6422 if( objc==3 ){
6423 zDbName = Tcl_GetString(objv[2]);
6424 }
6425 sqlite3_file_control(db, zDbName, SQLITE_FCNTL_VFSNAME,(void*)&zVfsName);
6426 Tcl_AppendResult(interp, zVfsName, (char*)0);
6427 sqlite3_free(zVfsName);
6428 return TCL_OK;
6429 }
6430
6431 /*
6432 ** tclcmd: file_control_reservebytes DB N
6433 */
file_control_reservebytes(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6434 static int SQLITE_TCLAPI file_control_reservebytes(
6435 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6436 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6437 int objc, /* Number of arguments */
6438 Tcl_Obj *CONST objv[] /* Command arguments */
6439 ){
6440 sqlite3 *db;
6441 const char *zDbName = "main";
6442 int n = 0;
6443 int rc;
6444
6445 if( objc!=3 ){
6446 Tcl_WrongNumArgs(interp, 1, objv, "DB N");
6447 return TCL_ERROR;
6448 }
6449 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
6450 || Tcl_GetIntFromObj(interp, objv[2], &n)
6451 ){
6452 return TCL_ERROR;
6453 }
6454
6455 rc = sqlite3_file_control(db, zDbName, SQLITE_FCNTL_RESERVE_BYTES, (void*)&n);
6456 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
6457 return TCL_OK;
6458 }
6459
6460
6461 /*
6462 ** tclcmd: file_control_tempfilename DB ?AUXDB?
6463 **
6464 ** Return a string that is a temporary filename
6465 */
file_control_tempfilename(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6466 static int SQLITE_TCLAPI file_control_tempfilename(
6467 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6468 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6469 int objc, /* Number of arguments */
6470 Tcl_Obj *CONST objv[] /* Command arguments */
6471 ){
6472 sqlite3 *db;
6473 const char *zDbName = "main";
6474 char *zTName = 0;
6475
6476 if( objc!=2 && objc!=3 ){
6477 Tcl_AppendResult(interp, "wrong # args: should be \"",
6478 Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0);
6479 return TCL_ERROR;
6480 }
6481 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6482 return TCL_ERROR;
6483 }
6484 if( objc==3 ){
6485 zDbName = Tcl_GetString(objv[2]);
6486 }
6487 sqlite3_file_control(db, zDbName, SQLITE_FCNTL_TEMPFILENAME, (void*)&zTName);
6488 Tcl_AppendResult(interp, zTName, (char*)0);
6489 sqlite3_free(zTName);
6490 return TCL_OK;
6491 }
6492
6493
6494 /*
6495 ** tclcmd: sqlite3_vfs_list
6496 **
6497 ** Return a tcl list containing the names of all registered vfs's.
6498 */
vfs_list(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6499 static int SQLITE_TCLAPI vfs_list(
6500 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6501 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6502 int objc, /* Number of arguments */
6503 Tcl_Obj *CONST objv[] /* Command arguments */
6504 ){
6505 sqlite3_vfs *pVfs;
6506 Tcl_Obj *pRet = Tcl_NewObj();
6507 if( objc!=1 ){
6508 Tcl_WrongNumArgs(interp, 1, objv, "");
6509 return TCL_ERROR;
6510 }
6511 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
6512 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(pVfs->zName, -1));
6513 }
6514 Tcl_SetObjResult(interp, pRet);
6515 return TCL_OK;
6516 }
6517
6518 /*
6519 ** tclcmd: sqlite3_limit DB ID VALUE
6520 **
6521 ** This TCL command runs the sqlite3_limit interface and
6522 ** verifies correct operation of the same.
6523 */
test_limit(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6524 static int SQLITE_TCLAPI test_limit(
6525 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6526 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6527 int objc, /* Number of arguments */
6528 Tcl_Obj *CONST objv[] /* Command arguments */
6529 ){
6530 sqlite3 *db;
6531 int rc;
6532 static const struct {
6533 char *zName;
6534 int id;
6535 } aId[] = {
6536 { "SQLITE_LIMIT_LENGTH", SQLITE_LIMIT_LENGTH },
6537 { "SQLITE_LIMIT_SQL_LENGTH", SQLITE_LIMIT_SQL_LENGTH },
6538 { "SQLITE_LIMIT_COLUMN", SQLITE_LIMIT_COLUMN },
6539 { "SQLITE_LIMIT_EXPR_DEPTH", SQLITE_LIMIT_EXPR_DEPTH },
6540 { "SQLITE_LIMIT_COMPOUND_SELECT", SQLITE_LIMIT_COMPOUND_SELECT },
6541 { "SQLITE_LIMIT_VDBE_OP", SQLITE_LIMIT_VDBE_OP },
6542 { "SQLITE_LIMIT_FUNCTION_ARG", SQLITE_LIMIT_FUNCTION_ARG },
6543 { "SQLITE_LIMIT_ATTACHED", SQLITE_LIMIT_ATTACHED },
6544 { "SQLITE_LIMIT_LIKE_PATTERN_LENGTH", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
6545 { "SQLITE_LIMIT_VARIABLE_NUMBER", SQLITE_LIMIT_VARIABLE_NUMBER },
6546 { "SQLITE_LIMIT_TRIGGER_DEPTH", SQLITE_LIMIT_TRIGGER_DEPTH },
6547 { "SQLITE_LIMIT_WORKER_THREADS", SQLITE_LIMIT_WORKER_THREADS },
6548
6549 /* Out of range test cases */
6550 { "SQLITE_LIMIT_TOOSMALL", -1, },
6551 { "SQLITE_LIMIT_TOOBIG", SQLITE_LIMIT_WORKER_THREADS+1 },
6552 };
6553 int i, id = 0;
6554 int val;
6555 const char *zId;
6556
6557 if( objc!=4 ){
6558 Tcl_AppendResult(interp, "wrong # args: should be \"",
6559 Tcl_GetStringFromObj(objv[0], 0), " DB ID VALUE", 0);
6560 return TCL_ERROR;
6561 }
6562 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
6563 zId = Tcl_GetString(objv[2]);
6564 for(i=0; i<sizeof(aId)/sizeof(aId[0]); i++){
6565 if( strcmp(zId, aId[i].zName)==0 ){
6566 id = aId[i].id;
6567 break;
6568 }
6569 }
6570 if( i>=sizeof(aId)/sizeof(aId[0]) ){
6571 Tcl_AppendResult(interp, "unknown limit type: ", zId, (char*)0);
6572 return TCL_ERROR;
6573 }
6574 if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR;
6575 rc = sqlite3_limit(db, id, val);
6576 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
6577 return TCL_OK;
6578 }
6579
6580 /*
6581 ** tclcmd: save_prng_state
6582 **
6583 ** Save the state of the pseudo-random number generator.
6584 ** At the same time, verify that sqlite3_test_control works even when
6585 ** called with an out-of-range opcode.
6586 */
save_prng_state(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6587 static int SQLITE_TCLAPI save_prng_state(
6588 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6589 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6590 int objc, /* Number of arguments */
6591 Tcl_Obj *CONST objv[] /* Command arguments */
6592 ){
6593 int rc = sqlite3_test_control(9999);
6594 assert( rc==0 );
6595 rc = sqlite3_test_control(-1);
6596 assert( rc==0 );
6597 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SAVE);
6598 return TCL_OK;
6599 }
6600 /*
6601 ** tclcmd: restore_prng_state
6602 */
restore_prng_state(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6603 static int SQLITE_TCLAPI restore_prng_state(
6604 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6605 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6606 int objc, /* Number of arguments */
6607 Tcl_Obj *CONST objv[] /* Command arguments */
6608 ){
6609 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESTORE);
6610 return TCL_OK;
6611 }
6612 /*
6613 ** tclcmd: reset_prng_state
6614 */
reset_prng_state(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6615 static int SQLITE_TCLAPI reset_prng_state(
6616 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6617 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6618 int objc, /* Number of arguments */
6619 Tcl_Obj *CONST objv[] /* Command arguments */
6620 ){
6621 sqlite3_randomness(0,0);
6622 return TCL_OK;
6623 }
6624 /*
6625 ** tclcmd: prng_seed INT ?DB?
6626 **
6627 ** Set up the SQLITE_TESTCTRL_PRNG_SEED pragma with parameter INT and DB.
6628 ** INT is an integer. DB is a database connection, or a NULL pointer if
6629 ** omitted.
6630 **
6631 ** When INT!=0 and DB!=0, set the PRNG seed to the value of the schema
6632 ** cookie for DB, or to INT if the schema cookie happens to be zero.
6633 **
6634 ** When INT!=0 and DB==0, set the PRNG seed to just INT.
6635 **
6636 ** If INT==0 and DB==0 then use the default procedure of calling the
6637 ** xRandomness method on the default VFS to get the PRNG seed.
6638 */
prng_seed(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6639 static int SQLITE_TCLAPI prng_seed(
6640 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6641 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6642 int objc, /* Number of arguments */
6643 Tcl_Obj *CONST objv[] /* Command arguments */
6644 ){
6645 int i = 0;
6646 sqlite3 *db = 0;
6647 if( objc!=2 && objc!=3 ){
6648 Tcl_WrongNumArgs(interp, 1, objv, "SEED ?DB?");
6649 return TCL_ERROR;
6650 }
6651 if( Tcl_GetIntFromObj(interp,objv[0],&i) ) return TCL_ERROR;
6652 if( objc==3 && getDbPointer(interp, Tcl_GetString(objv[2]), &db) ){
6653 return TCL_ERROR;
6654 }
6655 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, i, db);
6656 return TCL_OK;
6657 }
6658
6659 /*
6660 ** tclcmd: extra_schema_checks BOOLEAN
6661 **
6662 ** Enable or disable schema checks when parsing the sqlite_schema file.
6663 ** This is always enabled in production, but it is sometimes useful to
6664 ** disable the checks in order to make some internal error states reachable
6665 ** for testing.
6666 */
extra_schema_checks(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6667 static int SQLITE_TCLAPI extra_schema_checks(
6668 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6669 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6670 int objc, /* Number of arguments */
6671 Tcl_Obj *CONST objv[] /* Command arguments */
6672 ){
6673 int i = 0;
6674 if( objc!=2 ){
6675 Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
6676 return TCL_ERROR;
6677 }
6678 if( Tcl_GetBooleanFromObj(interp,objv[1],&i) ) return TCL_ERROR;
6679 sqlite3_test_control(SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, i);
6680 return TCL_OK;
6681 }
6682
6683 /*
6684 ** tclcmd: database_may_be_corrupt
6685 **
6686 ** Indicate that database files might be corrupt. In other words, set the normal
6687 ** state of operation.
6688 */
database_may_be_corrupt(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6689 static int SQLITE_TCLAPI database_may_be_corrupt(
6690 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6691 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6692 int objc, /* Number of arguments */
6693 Tcl_Obj *CONST objv[] /* Command arguments */
6694 ){
6695 sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 0);
6696 return TCL_OK;
6697 }
6698 /*
6699 ** tclcmd: database_never_corrupt
6700 **
6701 ** Indicate that database files are always well-formed. This enables
6702 ** extra assert() statements that test conditions that are always true
6703 ** for well-formed databases.
6704 */
database_never_corrupt(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6705 static int SQLITE_TCLAPI database_never_corrupt(
6706 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6707 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6708 int objc, /* Number of arguments */
6709 Tcl_Obj *CONST objv[] /* Command arguments */
6710 ){
6711 sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 1);
6712 return TCL_OK;
6713 }
6714
6715 /*
6716 ** tclcmd: pcache_stats
6717 */
test_pcache_stats(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6718 static int SQLITE_TCLAPI test_pcache_stats(
6719 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
6720 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6721 int objc, /* Number of arguments */
6722 Tcl_Obj *CONST objv[] /* Command arguments */
6723 ){
6724 int nMin;
6725 int nMax;
6726 int nCurrent;
6727 int nRecyclable;
6728 Tcl_Obj *pRet;
6729
6730 sqlite3PcacheStats(&nCurrent, &nMax, &nMin, &nRecyclable);
6731
6732 pRet = Tcl_NewObj();
6733 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("current", -1));
6734 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCurrent));
6735 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("max", -1));
6736 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMax));
6737 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("min", -1));
6738 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMin));
6739 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("recyclable", -1));
6740 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nRecyclable));
6741
6742 Tcl_SetObjResult(interp, pRet);
6743
6744 return TCL_OK;
6745 }
6746
6747 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
test_unlock_notify_cb(void ** aArg,int nArg)6748 static void test_unlock_notify_cb(void **aArg, int nArg){
6749 int ii;
6750 for(ii=0; ii<nArg; ii++){
6751 Tcl_EvalEx((Tcl_Interp *)aArg[ii], "unlock_notify", -1, TCL_EVAL_GLOBAL);
6752 }
6753 }
6754 #endif /* SQLITE_ENABLE_UNLOCK_NOTIFY */
6755
6756 /*
6757 ** tclcmd: sqlite3_unlock_notify db
6758 */
6759 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
test_unlock_notify(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6760 static int SQLITE_TCLAPI test_unlock_notify(
6761 ClientData clientData, /* Unused */
6762 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6763 int objc, /* Number of arguments */
6764 Tcl_Obj *CONST objv[] /* Command arguments */
6765 ){
6766 sqlite3 *db;
6767 int rc;
6768
6769 if( objc!=2 ){
6770 Tcl_WrongNumArgs(interp, 1, objv, "DB");
6771 return TCL_ERROR;
6772 }
6773
6774 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6775 return TCL_ERROR;
6776 }
6777 rc = sqlite3_unlock_notify(db, test_unlock_notify_cb, (void *)interp);
6778 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
6779 return TCL_OK;
6780 }
6781 #endif
6782
6783 /*
6784 ** tclcmd: sqlite3_wal_checkpoint db ?NAME?
6785 */
test_wal_checkpoint(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6786 static int SQLITE_TCLAPI test_wal_checkpoint(
6787 ClientData clientData, /* Unused */
6788 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6789 int objc, /* Number of arguments */
6790 Tcl_Obj *CONST objv[] /* Command arguments */
6791 ){
6792 char *zDb = 0;
6793 sqlite3 *db;
6794 int rc;
6795
6796 if( objc!=3 && objc!=2 ){
6797 Tcl_WrongNumArgs(interp, 1, objv, "DB ?NAME?");
6798 return TCL_ERROR;
6799 }
6800
6801 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
6802 return TCL_ERROR;
6803 }
6804 if( objc==3 ){
6805 zDb = Tcl_GetString(objv[2]);
6806 }
6807 rc = sqlite3_wal_checkpoint(db, zDb);
6808 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
6809 return TCL_OK;
6810 }
6811
6812 /*
6813 ** tclcmd: sqlite3_wal_checkpoint_v2 db MODE ?NAME?
6814 **
6815 ** This command calls the wal_checkpoint_v2() function with the specified
6816 ** mode argument (passive, full or restart). If present, the database name
6817 ** NAME is passed as the second argument to wal_checkpoint_v2(). If it the
6818 ** NAME argument is not present, a NULL pointer is passed instead.
6819 **
6820 ** If wal_checkpoint_v2() returns any value other than SQLITE_BUSY or
6821 ** SQLITE_OK, then this command returns TCL_ERROR. The Tcl result is set
6822 ** to the error message obtained from sqlite3_errmsg().
6823 **
6824 ** Otherwise, this command returns a list of three integers. The first integer
6825 ** is 1 if SQLITE_BUSY was returned, or 0 otherwise. The following two integers
6826 ** are the values returned via the output parameters by wal_checkpoint_v2() -
6827 ** the number of frames in the log and the number of frames in the log
6828 ** that have been checkpointed.
6829 */
test_wal_checkpoint_v2(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6830 static int SQLITE_TCLAPI test_wal_checkpoint_v2(
6831 ClientData clientData, /* Unused */
6832 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6833 int objc, /* Number of arguments */
6834 Tcl_Obj *CONST objv[] /* Command arguments */
6835 ){
6836 char *zDb = 0;
6837 sqlite3 *db;
6838 int rc;
6839
6840 int eMode;
6841 int nLog = -555;
6842 int nCkpt = -555;
6843 Tcl_Obj *pRet;
6844
6845 const char * aMode[] = { "passive", "full", "restart", "truncate", 0 };
6846 assert( SQLITE_CHECKPOINT_PASSIVE==0 );
6847 assert( SQLITE_CHECKPOINT_FULL==1 );
6848 assert( SQLITE_CHECKPOINT_RESTART==2 );
6849 assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
6850
6851 if( objc!=3 && objc!=4 ){
6852 Tcl_WrongNumArgs(interp, 1, objv, "DB MODE ?NAME?");
6853 return TCL_ERROR;
6854 }
6855
6856 if( objc==4 ){
6857 zDb = Tcl_GetString(objv[3]);
6858 }
6859 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) || (
6860 TCL_OK!=Tcl_GetIntFromObj(0, objv[2], &eMode)
6861 && TCL_OK!=Tcl_GetIndexFromObj(interp, objv[2], aMode, "mode", 0, &eMode)
6862 )){
6863 return TCL_ERROR;
6864 }
6865
6866 rc = sqlite3_wal_checkpoint_v2(db, zDb, eMode, &nLog, &nCkpt);
6867 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
6868 const char *zErrCode = sqlite3ErrName(rc);
6869 Tcl_ResetResult(interp);
6870 Tcl_AppendResult(interp, zErrCode, " - ", (char *)sqlite3_errmsg(db), 0);
6871 return TCL_ERROR;
6872 }
6873
6874 pRet = Tcl_NewObj();
6875 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(rc==SQLITE_BUSY?1:0));
6876 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nLog));
6877 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCkpt));
6878 Tcl_SetObjResult(interp, pRet);
6879
6880 return TCL_OK;
6881 }
6882
6883 /*
6884 ** tclcmd: sqlite3_wal_autocheckpoint db VALUE
6885 */
test_wal_autocheckpoint(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6886 static int SQLITE_TCLAPI test_wal_autocheckpoint(
6887 ClientData clientData, /* Unused */
6888 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6889 int objc, /* Number of arguments */
6890 Tcl_Obj *CONST objv[] /* Command arguments */
6891 ){
6892 sqlite3 *db;
6893 int rc;
6894 int iVal;
6895
6896
6897 if( objc!=3 ){
6898 Tcl_WrongNumArgs(interp, 1, objv, "DB VALUE");
6899 return TCL_ERROR;
6900 }
6901
6902 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
6903 || Tcl_GetIntFromObj(0, objv[2], &iVal)
6904 ){
6905 return TCL_ERROR;
6906 }
6907
6908 rc = sqlite3_wal_autocheckpoint(db, iVal);
6909 Tcl_ResetResult(interp);
6910 if( rc!=SQLITE_OK ){
6911 const char *zErrCode = sqlite3ErrName(rc);
6912 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErrCode, -1));
6913 return TCL_ERROR;
6914 }
6915
6916 return TCL_OK;
6917 }
6918
6919
6920 /*
6921 ** tclcmd: test_sqlite3_log ?SCRIPT?
6922 */
6923 static struct LogCallback {
6924 Tcl_Interp *pInterp;
6925 Tcl_Obj *pObj;
6926 } logcallback = {0, 0};
xLogcallback(void * unused,int err,char * zMsg)6927 static void xLogcallback(void *unused, int err, char *zMsg){
6928 Tcl_Obj *pNew = Tcl_DuplicateObj(logcallback.pObj);
6929 Tcl_IncrRefCount(pNew);
6930 Tcl_ListObjAppendElement(
6931 0, pNew, Tcl_NewStringObj(sqlite3ErrName(err), -1)
6932 );
6933 Tcl_ListObjAppendElement(0, pNew, Tcl_NewStringObj(zMsg, -1));
6934 Tcl_EvalObjEx(logcallback.pInterp, pNew, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
6935 Tcl_DecrRefCount(pNew);
6936 }
test_sqlite3_log(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6937 static int SQLITE_TCLAPI test_sqlite3_log(
6938 ClientData clientData,
6939 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
6940 int objc, /* Number of arguments */
6941 Tcl_Obj *CONST objv[] /* Command arguments */
6942 ){
6943 if( objc>2 ){
6944 Tcl_WrongNumArgs(interp, 1, objv, "SCRIPT");
6945 return TCL_ERROR;
6946 }
6947 if( logcallback.pObj ){
6948 Tcl_DecrRefCount(logcallback.pObj);
6949 logcallback.pObj = 0;
6950 logcallback.pInterp = 0;
6951 sqlite3_config(SQLITE_CONFIG_LOG, (void*)0, (void*)0);
6952 }
6953 if( objc>1 ){
6954 logcallback.pObj = objv[1];
6955 Tcl_IncrRefCount(logcallback.pObj);
6956 logcallback.pInterp = interp;
6957 sqlite3_config(SQLITE_CONFIG_LOG, xLogcallback, (void*)0);
6958 }
6959 return TCL_OK;
6960 }
6961
6962 /*
6963 ** tcl_objproc COMMANDNAME ARGS...
6964 **
6965 ** Run a TCL command using its objProc interface. Throw an error if
6966 ** the command has no objProc interface.
6967 */
runAsObjProc(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])6968 static int SQLITE_TCLAPI runAsObjProc(
6969 void * clientData,
6970 Tcl_Interp *interp,
6971 int objc,
6972 Tcl_Obj *CONST objv[]
6973 ){
6974 Tcl_CmdInfo cmdInfo;
6975 if( objc<2 ){
6976 Tcl_WrongNumArgs(interp, 1, objv, "COMMAND ...");
6977 return TCL_ERROR;
6978 }
6979 if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
6980 Tcl_AppendResult(interp, "command not found: ",
6981 Tcl_GetString(objv[1]), (char*)0);
6982 return TCL_ERROR;
6983 }
6984 if( cmdInfo.objProc==0 ){
6985 Tcl_AppendResult(interp, "command has no objProc: ",
6986 Tcl_GetString(objv[1]), (char*)0);
6987 return TCL_ERROR;
6988 }
6989 return cmdInfo.objProc(cmdInfo.objClientData, interp, objc-1, objv+1);
6990 }
6991
6992 #ifndef SQLITE_OMIT_EXPLAIN
6993 /*
6994 ** WARNING: The following function, printExplainQueryPlan() is an exact
6995 ** copy of example code from eqp.in (eqp.html). If this code is modified,
6996 ** then the documentation copy needs to be modified as well.
6997 */
6998 /*
6999 ** Argument pStmt is a prepared SQL statement. This function compiles
7000 ** an EXPLAIN QUERY PLAN command to report on the prepared statement,
7001 ** and prints the report to stdout using printf().
7002 */
printExplainQueryPlan(sqlite3_stmt * pStmt)7003 int printExplainQueryPlan(sqlite3_stmt *pStmt){
7004 const char *zSql; /* Input SQL */
7005 char *zExplain; /* SQL with EXPLAIN QUERY PLAN prepended */
7006 sqlite3_stmt *pExplain; /* Compiled EXPLAIN QUERY PLAN command */
7007 int rc; /* Return code from sqlite3_prepare_v2() */
7008
7009 zSql = sqlite3_sql(pStmt);
7010 if( zSql==0 ) return SQLITE_ERROR;
7011
7012 zExplain = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zSql);
7013 if( zExplain==0 ) return SQLITE_NOMEM;
7014
7015 rc = sqlite3_prepare_v2(sqlite3_db_handle(pStmt), zExplain, -1, &pExplain, 0);
7016 sqlite3_free(zExplain);
7017 if( rc!=SQLITE_OK ) return rc;
7018
7019 while( SQLITE_ROW==sqlite3_step(pExplain) ){
7020 int iSelectid = sqlite3_column_int(pExplain, 0);
7021 int iOrder = sqlite3_column_int(pExplain, 1);
7022 int iFrom = sqlite3_column_int(pExplain, 2);
7023 const char *zDetail = (const char *)sqlite3_column_text(pExplain, 3);
7024
7025 printf("%d %d %d %s\n", iSelectid, iOrder, iFrom, zDetail);
7026 }
7027
7028 return sqlite3_finalize(pExplain);
7029 }
7030
test_print_eqp(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7031 static int SQLITE_TCLAPI test_print_eqp(
7032 void * clientData,
7033 Tcl_Interp *interp,
7034 int objc,
7035 Tcl_Obj *CONST objv[]
7036 ){
7037 int rc;
7038 sqlite3_stmt *pStmt;
7039
7040 if( objc!=2 ){
7041 Tcl_WrongNumArgs(interp, 1, objv, "STMT");
7042 return TCL_ERROR;
7043 }
7044 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
7045 rc = printExplainQueryPlan(pStmt);
7046 /* This is needed on Windows so that a test case using this
7047 ** function can open a read pipe and get the output of
7048 ** printExplainQueryPlan() immediately.
7049 */
7050 fflush(stdout);
7051 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
7052 return TCL_OK;
7053 }
7054 #endif /* SQLITE_OMIT_EXPLAIN */
7055
7056 /*
7057 ** sqlite3_test_control VERB ARGS...
7058 */
test_test_control(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7059 static int SQLITE_TCLAPI test_test_control(
7060 void * clientData,
7061 Tcl_Interp *interp,
7062 int objc,
7063 Tcl_Obj *CONST objv[]
7064 ){
7065 struct Verb {
7066 const char *zName;
7067 int i;
7068 } aVerb[] = {
7069 { "SQLITE_TESTCTRL_LOCALTIME_FAULT", SQLITE_TESTCTRL_LOCALTIME_FAULT },
7070 { "SQLITE_TESTCTRL_SORTER_MMAP", SQLITE_TESTCTRL_SORTER_MMAP },
7071 { "SQLITE_TESTCTRL_IMPOSTER", SQLITE_TESTCTRL_IMPOSTER },
7072 { "SQLITE_TESTCTRL_INTERNAL_FUNCTIONS", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS},
7073 };
7074 int iVerb;
7075 int iFlag;
7076 int rc;
7077
7078 if( objc<2 ){
7079 Tcl_WrongNumArgs(interp, 1, objv, "VERB ARGS...");
7080 return TCL_ERROR;
7081 }
7082
7083 rc = Tcl_GetIndexFromObjStruct(
7084 interp, objv[1], aVerb, sizeof(aVerb[0]), "VERB", 0, &iVerb
7085 );
7086 if( rc!=TCL_OK ) return rc;
7087
7088 iFlag = aVerb[iVerb].i;
7089 switch( iFlag ){
7090 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
7091 sqlite3 *db = 0;
7092 if( objc!=3 ){
7093 Tcl_WrongNumArgs(interp, 2, objv, "DB");
7094 return TCL_ERROR;
7095 }
7096 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR;
7097 sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, db);
7098 break;
7099 }
7100 case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
7101 int val;
7102 if( objc!=3 ){
7103 Tcl_WrongNumArgs(interp, 2, objv, "ONOFF");
7104 return TCL_ERROR;
7105 }
7106 if( Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
7107 sqlite3_test_control(iFlag, val);
7108 break;
7109 }
7110
7111 case SQLITE_TESTCTRL_SORTER_MMAP: {
7112 int val;
7113 sqlite3 *db;
7114 if( objc!=4 ){
7115 Tcl_WrongNumArgs(interp, 2, objv, "DB LIMIT");
7116 return TCL_ERROR;
7117 }
7118 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR;
7119 if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR;
7120 sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, val);
7121 break;
7122 }
7123
7124 case SQLITE_TESTCTRL_IMPOSTER: {
7125 int onOff, tnum;
7126 const char *zDbName;
7127 sqlite3 *db;
7128 if( objc!=6 ){
7129 Tcl_WrongNumArgs(interp, 2, objv, "DB dbName onOff tnum");
7130 return TCL_ERROR;
7131 }
7132 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR;
7133 zDbName = Tcl_GetString(objv[3]);
7134 if( Tcl_GetIntFromObj(interp, objv[4], &onOff) ) return TCL_ERROR;
7135 if( Tcl_GetIntFromObj(interp, objv[5], &tnum) ) return TCL_ERROR;
7136 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, zDbName, onOff, tnum);
7137 break;
7138 }
7139 }
7140
7141 Tcl_ResetResult(interp);
7142 return TCL_OK;
7143 }
7144
7145 #if SQLITE_OS_UNIX
7146 #include <sys/time.h>
7147 #include <sys/resource.h>
7148
test_getrusage(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7149 static int SQLITE_TCLAPI test_getrusage(
7150 void * clientData,
7151 Tcl_Interp *interp,
7152 int objc,
7153 Tcl_Obj *CONST objv[]
7154 ){
7155 char buf[1024];
7156 struct rusage r;
7157 memset(&r, 0, sizeof(r));
7158 getrusage(RUSAGE_SELF, &r);
7159
7160 sqlite3_snprintf(sizeof(buf), buf,
7161 "ru_utime=%d.%06d ru_stime=%d.%06d ru_minflt=%d ru_majflt=%d",
7162 (int)r.ru_utime.tv_sec, (int)r.ru_utime.tv_usec,
7163 (int)r.ru_stime.tv_sec, (int)r.ru_stime.tv_usec,
7164 (int)r.ru_minflt, (int)r.ru_majflt
7165 );
7166 Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, -1));
7167 return TCL_OK;
7168 }
7169 #endif
7170
7171 #if SQLITE_OS_WIN
7172 /*
7173 ** Information passed from the main thread into the windows file locker
7174 ** background thread.
7175 */
7176 struct win32FileLocker {
7177 char *evName; /* Name of event to signal thread startup */
7178 HANDLE h; /* Handle of the file to be locked */
7179 int delay1; /* Delay before locking */
7180 int delay2; /* Delay before unlocking */
7181 int ok; /* Finished ok */
7182 int err; /* True if an error occurs */
7183 };
7184 #endif
7185
7186
7187 #if SQLITE_OS_WIN
7188 #include <process.h>
7189 /*
7190 ** The background thread that does file locking.
7191 */
win32_file_locker(void * pAppData)7192 static void SQLITE_CDECL win32_file_locker(void *pAppData){
7193 struct win32FileLocker *p = (struct win32FileLocker*)pAppData;
7194 if( p->evName ){
7195 HANDLE ev = OpenEvent(EVENT_MODIFY_STATE, FALSE, p->evName);
7196 if ( ev ){
7197 SetEvent(ev);
7198 CloseHandle(ev);
7199 }
7200 }
7201 if( p->delay1 ) Sleep(p->delay1);
7202 if( LockFile(p->h, 0, 0, 100000000, 0) ){
7203 Sleep(p->delay2);
7204 UnlockFile(p->h, 0, 0, 100000000, 0);
7205 p->ok = 1;
7206 }else{
7207 p->err = 1;
7208 }
7209 CloseHandle(p->h);
7210 p->h = 0;
7211 p->delay1 = 0;
7212 p->delay2 = 0;
7213 }
7214 #endif
7215
7216 #if SQLITE_OS_WIN
7217 /*
7218 ** lock_win32_file FILENAME DELAY1 DELAY2
7219 **
7220 ** Get an exclusive manditory lock on file for DELAY2 milliseconds.
7221 ** Wait DELAY1 milliseconds before acquiring the lock.
7222 */
win32_file_lock(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7223 static int SQLITE_TCLAPI win32_file_lock(
7224 void * clientData,
7225 Tcl_Interp *interp,
7226 int objc,
7227 Tcl_Obj *CONST objv[]
7228 ){
7229 static struct win32FileLocker x = { "win32_file_lock", 0, 0, 0, 0, 0 };
7230 const char *zFilename;
7231 char zBuf[200];
7232 int retry = 0;
7233 HANDLE ev;
7234 DWORD wResult;
7235
7236 if( objc!=4 && objc!=1 ){
7237 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME DELAY1 DELAY2");
7238 return TCL_ERROR;
7239 }
7240 if( objc==1 ){
7241 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d %d %d %d %d",
7242 x.ok, x.err, x.delay1, x.delay2, x.h);
7243 Tcl_AppendResult(interp, zBuf, (char*)0);
7244 return TCL_OK;
7245 }
7246 while( x.h && retry<30 ){
7247 retry++;
7248 Sleep(100);
7249 }
7250 if( x.h ){
7251 Tcl_AppendResult(interp, "busy", (char*)0);
7252 return TCL_ERROR;
7253 }
7254 if( Tcl_GetIntFromObj(interp, objv[2], &x.delay1) ) return TCL_ERROR;
7255 if( Tcl_GetIntFromObj(interp, objv[3], &x.delay2) ) return TCL_ERROR;
7256 zFilename = Tcl_GetString(objv[1]);
7257 x.h = CreateFile(zFilename, GENERIC_READ|GENERIC_WRITE,
7258 FILE_SHARE_READ|FILE_SHARE_WRITE, 0, OPEN_ALWAYS,
7259 FILE_ATTRIBUTE_NORMAL, 0);
7260 if( !x.h ){
7261 Tcl_AppendResult(interp, "cannot open file: ", zFilename, (char*)0);
7262 return TCL_ERROR;
7263 }
7264 ev = CreateEvent(NULL, TRUE, FALSE, x.evName);
7265 if ( !ev ){
7266 Tcl_AppendResult(interp, "cannot create event: ", x.evName, (char*)0);
7267 return TCL_ERROR;
7268 }
7269 _beginthread(win32_file_locker, 0, (void*)&x);
7270 Sleep(0);
7271 if ( (wResult = WaitForSingleObject(ev, 10000))!=WAIT_OBJECT_0 ){
7272 sqlite3_snprintf(sizeof(zBuf), zBuf, "0x%x", wResult);
7273 Tcl_AppendResult(interp, "wait failed: ", zBuf, (char*)0);
7274 CloseHandle(ev);
7275 return TCL_ERROR;
7276 }
7277 CloseHandle(ev);
7278 return TCL_OK;
7279 }
7280
7281 /*
7282 ** exists_win32_path PATH
7283 **
7284 ** Returns non-zero if the specified path exists, whose fully qualified name
7285 ** may exceed 260 characters if it is prefixed with "\\?\".
7286 */
win32_exists_path(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7287 static int SQLITE_TCLAPI win32_exists_path(
7288 void *clientData,
7289 Tcl_Interp *interp,
7290 int objc,
7291 Tcl_Obj *CONST objv[]
7292 ){
7293 if( objc!=2 ){
7294 Tcl_WrongNumArgs(interp, 1, objv, "PATH");
7295 return TCL_ERROR;
7296 }
7297 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(
7298 GetFileAttributesW( Tcl_GetUnicode(objv[1]))!=INVALID_FILE_ATTRIBUTES ));
7299 return TCL_OK;
7300 }
7301
7302 /*
7303 ** find_win32_file PATTERN
7304 **
7305 ** Returns a list of entries in a directory that match the specified pattern,
7306 ** whose fully qualified name may exceed 248 characters if it is prefixed with
7307 ** "\\?\".
7308 */
win32_find_file(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7309 static int SQLITE_TCLAPI win32_find_file(
7310 void *clientData,
7311 Tcl_Interp *interp,
7312 int objc,
7313 Tcl_Obj *CONST objv[]
7314 ){
7315 HANDLE hFindFile = INVALID_HANDLE_VALUE;
7316 WIN32_FIND_DATAW findData;
7317 Tcl_Obj *listObj;
7318 DWORD lastErrno;
7319 if( objc!=2 ){
7320 Tcl_WrongNumArgs(interp, 1, objv, "PATTERN");
7321 return TCL_ERROR;
7322 }
7323 hFindFile = FindFirstFileW(Tcl_GetUnicode(objv[1]), &findData);
7324 if( hFindFile==INVALID_HANDLE_VALUE ){
7325 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
7326 return TCL_ERROR;
7327 }
7328 listObj = Tcl_NewObj();
7329 Tcl_IncrRefCount(listObj);
7330 do {
7331 Tcl_ListObjAppendElement(interp, listObj, Tcl_NewUnicodeObj(
7332 findData.cFileName, -1));
7333 Tcl_ListObjAppendElement(interp, listObj, Tcl_NewWideIntObj(
7334 findData.dwFileAttributes));
7335 } while( FindNextFileW(hFindFile, &findData) );
7336 lastErrno = GetLastError();
7337 if( lastErrno!=NO_ERROR && lastErrno!=ERROR_NO_MORE_FILES ){
7338 FindClose(hFindFile);
7339 Tcl_DecrRefCount(listObj);
7340 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
7341 return TCL_ERROR;
7342 }
7343 FindClose(hFindFile);
7344 Tcl_SetObjResult(interp, listObj);
7345 return TCL_OK;
7346 }
7347
7348 /*
7349 ** delete_win32_file FILENAME
7350 **
7351 ** Deletes the specified file, whose fully qualified name may exceed 260
7352 ** characters if it is prefixed with "\\?\".
7353 */
win32_delete_file(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7354 static int SQLITE_TCLAPI win32_delete_file(
7355 void *clientData,
7356 Tcl_Interp *interp,
7357 int objc,
7358 Tcl_Obj *CONST objv[]
7359 ){
7360 if( objc!=2 ){
7361 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
7362 return TCL_ERROR;
7363 }
7364 if( !DeleteFileW(Tcl_GetUnicode(objv[1])) ){
7365 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
7366 return TCL_ERROR;
7367 }
7368 Tcl_ResetResult(interp);
7369 return TCL_OK;
7370 }
7371
7372 /*
7373 ** make_win32_dir DIRECTORY
7374 **
7375 ** Creates the specified directory, whose fully qualified name may exceed 248
7376 ** characters if it is prefixed with "\\?\".
7377 */
win32_mkdir(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7378 static int SQLITE_TCLAPI win32_mkdir(
7379 void *clientData,
7380 Tcl_Interp *interp,
7381 int objc,
7382 Tcl_Obj *CONST objv[]
7383 ){
7384 if( objc!=2 ){
7385 Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY");
7386 return TCL_ERROR;
7387 }
7388 if( !CreateDirectoryW(Tcl_GetUnicode(objv[1]), NULL) ){
7389 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
7390 return TCL_ERROR;
7391 }
7392 Tcl_ResetResult(interp);
7393 return TCL_OK;
7394 }
7395
7396 /*
7397 ** remove_win32_dir DIRECTORY
7398 **
7399 ** Removes the specified directory, whose fully qualified name may exceed 248
7400 ** characters if it is prefixed with "\\?\".
7401 */
win32_rmdir(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7402 static int SQLITE_TCLAPI win32_rmdir(
7403 void *clientData,
7404 Tcl_Interp *interp,
7405 int objc,
7406 Tcl_Obj *CONST objv[]
7407 ){
7408 if( objc!=2 ){
7409 Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY");
7410 return TCL_ERROR;
7411 }
7412 if( !RemoveDirectoryW(Tcl_GetUnicode(objv[1])) ){
7413 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
7414 return TCL_ERROR;
7415 }
7416 Tcl_ResetResult(interp);
7417 return TCL_OK;
7418 }
7419 #endif
7420
7421
7422 /*
7423 ** optimization_control DB OPT BOOLEAN
7424 **
7425 ** Enable or disable query optimizations using the sqlite3_test_control()
7426 ** interface. Disable if BOOLEAN is false and enable if BOOLEAN is true.
7427 ** OPT is the name of the optimization to be disabled.
7428 */
optimization_control(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7429 static int SQLITE_TCLAPI optimization_control(
7430 void * clientData,
7431 Tcl_Interp *interp,
7432 int objc,
7433 Tcl_Obj *CONST objv[]
7434 ){
7435 int i;
7436 sqlite3 *db;
7437 const char *zOpt;
7438 int onoff;
7439 int mask = 0;
7440 static const struct {
7441 const char *zOptName;
7442 int mask;
7443 } aOpt[] = {
7444 { "all", SQLITE_AllOpts },
7445 { "none", 0 },
7446 { "query-flattener", SQLITE_QueryFlattener },
7447 { "groupby-order", SQLITE_GroupByOrder },
7448 { "factor-constants", SQLITE_FactorOutConst },
7449 { "distinct-opt", SQLITE_DistinctOpt },
7450 { "cover-idx-scan", SQLITE_CoverIdxScan },
7451 { "order-by-idx-join", SQLITE_OrderByIdxJoin },
7452 { "transitive", SQLITE_Transitive },
7453 { "omit-noop-join", SQLITE_OmitNoopJoin },
7454 { "stat4", SQLITE_Stat4 },
7455 { "skip-scan", SQLITE_SkipScan },
7456 { "push-down", SQLITE_PushDown },
7457 };
7458
7459 if( objc!=4 ){
7460 Tcl_WrongNumArgs(interp, 1, objv, "DB OPT BOOLEAN");
7461 return TCL_ERROR;
7462 }
7463 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
7464 if( Tcl_GetBooleanFromObj(interp, objv[3], &onoff) ) return TCL_ERROR;
7465 zOpt = Tcl_GetString(objv[2]);
7466 for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){
7467 if( strcmp(zOpt, aOpt[i].zOptName)==0 ){
7468 mask = aOpt[i].mask;
7469 break;
7470 }
7471 }
7472 if( onoff ) mask = ~mask;
7473 if( i>=sizeof(aOpt)/sizeof(aOpt[0]) ){
7474 Tcl_AppendResult(interp, "unknown optimization - should be one of:",
7475 (char*)0);
7476 for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){
7477 Tcl_AppendResult(interp, " ", aOpt[i].zOptName, (char*)0);
7478 }
7479 return TCL_ERROR;
7480 }
7481 sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, db, mask);
7482 return TCL_OK;
7483 }
7484
7485 /*
7486 ** load_static_extension DB NAME ...
7487 **
7488 ** Load one or more statically linked extensions.
7489 */
tclLoadStaticExtensionCmd(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7490 static int SQLITE_TCLAPI tclLoadStaticExtensionCmd(
7491 void * clientData,
7492 Tcl_Interp *interp,
7493 int objc,
7494 Tcl_Obj *CONST objv[]
7495 ){
7496 extern int sqlite3_amatch_init(sqlite3*,char**,const sqlite3_api_routines*);
7497 extern int sqlite3_carray_init(sqlite3*,char**,const sqlite3_api_routines*);
7498 extern int sqlite3_closure_init(sqlite3*,char**,const sqlite3_api_routines*);
7499 extern int sqlite3_csv_init(sqlite3*,char**,const sqlite3_api_routines*);
7500 extern int sqlite3_eval_init(sqlite3*,char**,const sqlite3_api_routines*);
7501 extern int sqlite3_explain_init(sqlite3*,char**,const sqlite3_api_routines*);
7502 extern int sqlite3_fileio_init(sqlite3*,char**,const sqlite3_api_routines*);
7503 extern int sqlite3_decimal_init(sqlite3*,char**,const sqlite3_api_routines*);
7504 extern int sqlite3_fuzzer_init(sqlite3*,char**,const sqlite3_api_routines*);
7505 extern int sqlite3_ieee_init(sqlite3*,char**,const sqlite3_api_routines*);
7506 extern int sqlite3_nextchar_init(sqlite3*,char**,const sqlite3_api_routines*);
7507 extern int sqlite3_percentile_init(sqlite3*,char**,const sqlite3_api_routines*);
7508 #ifndef SQLITE_OMIT_VIRTUALTABLE
7509 extern int sqlite3_prefixes_init(sqlite3*,char**,const sqlite3_api_routines*);
7510 #endif
7511 extern int sqlite3_regexp_init(sqlite3*,char**,const sqlite3_api_routines*);
7512 extern int sqlite3_remember_init(sqlite3*,char**,const sqlite3_api_routines*);
7513 extern int sqlite3_series_init(sqlite3*,char**,const sqlite3_api_routines*);
7514 extern int sqlite3_spellfix_init(sqlite3*,char**,const sqlite3_api_routines*);
7515 extern int sqlite3_totype_init(sqlite3*,char**,const sqlite3_api_routines*);
7516 extern int sqlite3_wholenumber_init(sqlite3*,char**,const sqlite3_api_routines*);
7517 extern int sqlite3_unionvtab_init(sqlite3*,char**,const sqlite3_api_routines*);
7518 #ifdef SQLITE_HAVE_ZLIB
7519 extern int sqlite3_zipfile_init(sqlite3*,char**,const sqlite3_api_routines*);
7520 #endif
7521 static const struct {
7522 const char *zExtName;
7523 int (*pInit)(sqlite3*,char**,const sqlite3_api_routines*);
7524 } aExtension[] = {
7525 { "amatch", sqlite3_amatch_init },
7526 { "carray", sqlite3_carray_init },
7527 { "closure", sqlite3_closure_init },
7528 { "csv", sqlite3_csv_init },
7529 { "decimal", sqlite3_decimal_init },
7530 { "eval", sqlite3_eval_init },
7531 { "explain", sqlite3_explain_init },
7532 { "fileio", sqlite3_fileio_init },
7533 { "fuzzer", sqlite3_fuzzer_init },
7534 { "ieee754", sqlite3_ieee_init },
7535 { "nextchar", sqlite3_nextchar_init },
7536 { "percentile", sqlite3_percentile_init },
7537 #ifndef SQLITE_OMIT_VIRTUALTABLE
7538 { "prefixes", sqlite3_prefixes_init },
7539 #endif
7540 { "regexp", sqlite3_regexp_init },
7541 { "remember", sqlite3_remember_init },
7542 { "series", sqlite3_series_init },
7543 { "spellfix", sqlite3_spellfix_init },
7544 { "totype", sqlite3_totype_init },
7545 { "unionvtab", sqlite3_unionvtab_init },
7546 { "wholenumber", sqlite3_wholenumber_init },
7547 #ifdef SQLITE_HAVE_ZLIB
7548 { "zipfile", sqlite3_zipfile_init },
7549 #endif
7550 };
7551 sqlite3 *db;
7552 const char *zName;
7553 int i, j, rc;
7554 char *zErrMsg = 0;
7555 if( objc<3 ){
7556 Tcl_WrongNumArgs(interp, 1, objv, "DB NAME ...");
7557 return TCL_ERROR;
7558 }
7559 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
7560 for(j=2; j<objc; j++){
7561 zName = Tcl_GetString(objv[j]);
7562 for(i=0; i<ArraySize(aExtension); i++){
7563 if( strcmp(zName, aExtension[i].zExtName)==0 ) break;
7564 }
7565 if( i>=ArraySize(aExtension) ){
7566 Tcl_AppendResult(interp, "no such extension: ", zName, (char*)0);
7567 return TCL_ERROR;
7568 }
7569 if( aExtension[i].pInit ){
7570 rc = aExtension[i].pInit(db, &zErrMsg, 0);
7571 }else{
7572 rc = SQLITE_OK;
7573 }
7574 if( rc!=SQLITE_OK || zErrMsg ){
7575 Tcl_AppendResult(interp, "initialization of ", zName, " failed: ", zErrMsg,
7576 (char*)0);
7577 sqlite3_free(zErrMsg);
7578 return TCL_ERROR;
7579 }
7580 }
7581 return TCL_OK;
7582 }
7583
7584 /*
7585 ** sorter_test_fakeheap BOOL
7586 **
7587 */
sorter_test_fakeheap(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7588 static int SQLITE_TCLAPI sorter_test_fakeheap(
7589 void * clientData,
7590 Tcl_Interp *interp,
7591 int objc,
7592 Tcl_Obj *CONST objv[]
7593 ){
7594 int bArg;
7595 if( objc!=2 ){
7596 Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
7597 return TCL_ERROR;
7598 }
7599
7600 if( Tcl_GetBooleanFromObj(interp, objv[1], &bArg) ){
7601 return TCL_ERROR;
7602 }
7603
7604 if( bArg ){
7605 if( sqlite3GlobalConfig.pHeap==0 ){
7606 sqlite3GlobalConfig.pHeap = SQLITE_INT_TO_PTR(-1);
7607 }
7608 }else{
7609 if( sqlite3GlobalConfig.pHeap==SQLITE_INT_TO_PTR(-1) ){
7610 sqlite3GlobalConfig.pHeap = 0;
7611 }
7612 }
7613
7614 Tcl_ResetResult(interp);
7615 return TCL_OK;
7616 }
7617
7618 /*
7619 ** sorter_test_sort4_helper DB SQL1 NSTEP SQL2
7620 **
7621 ** Compile SQL statement $SQL1 and step it $NSTEP times. For each row,
7622 ** check that the leftmost and rightmost columns returned are both integers,
7623 ** and that both contain the same value.
7624 **
7625 ** Then execute statement $SQL2. Check that the statement returns the same
7626 ** set of integers in the same order as in the previous step (using $SQL1).
7627 */
sorter_test_sort4_helper(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7628 static int SQLITE_TCLAPI sorter_test_sort4_helper(
7629 void * clientData,
7630 Tcl_Interp *interp,
7631 int objc,
7632 Tcl_Obj *CONST objv[]
7633 ){
7634 const char *zSql1;
7635 const char *zSql2;
7636 int nStep;
7637 int iStep;
7638 unsigned int iCksum1 = 0;
7639 unsigned int iCksum2 = 0;
7640 int rc;
7641 int iB;
7642 sqlite3 *db;
7643 sqlite3_stmt *pStmt;
7644
7645 if( objc!=5 ){
7646 Tcl_WrongNumArgs(interp, 1, objv, "DB SQL1 NSTEP SQL2");
7647 return TCL_ERROR;
7648 }
7649
7650 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
7651 zSql1 = Tcl_GetString(objv[2]);
7652 if( Tcl_GetIntFromObj(interp, objv[3], &nStep) ) return TCL_ERROR;
7653 zSql2 = Tcl_GetString(objv[4]);
7654
7655 rc = sqlite3_prepare_v2(db, zSql1, -1, &pStmt, 0);
7656 if( rc!=SQLITE_OK ) goto sql_error;
7657
7658 iB = sqlite3_column_count(pStmt)-1;
7659 for(iStep=0; iStep<nStep && SQLITE_ROW==sqlite3_step(pStmt); iStep++){
7660 int a = sqlite3_column_int(pStmt, 0);
7661 if( a!=sqlite3_column_int(pStmt, iB) ){
7662 Tcl_AppendResult(interp, "data error: (a!=b)", 0);
7663 return TCL_ERROR;
7664 }
7665
7666 iCksum1 += (iCksum1 << 3) + (unsigned int)a;
7667 }
7668 rc = sqlite3_finalize(pStmt);
7669 if( rc!=SQLITE_OK ) goto sql_error;
7670
7671 rc = sqlite3_prepare_v2(db, zSql2, -1, &pStmt, 0);
7672 if( rc!=SQLITE_OK ) goto sql_error;
7673 for(iStep=0; SQLITE_ROW==sqlite3_step(pStmt); iStep++){
7674 int a = sqlite3_column_int(pStmt, 0);
7675 iCksum2 += (iCksum2 << 3) + (unsigned int)a;
7676 }
7677 rc = sqlite3_finalize(pStmt);
7678 if( rc!=SQLITE_OK ) goto sql_error;
7679
7680 if( iCksum1!=iCksum2 ){
7681 Tcl_AppendResult(interp, "checksum mismatch", 0);
7682 return TCL_ERROR;
7683 }
7684
7685 return TCL_OK;
7686 sql_error:
7687 Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0);
7688 return TCL_ERROR;
7689 }
7690
7691
7692 #ifdef SQLITE_USER_AUTHENTICATION
7693 #include "sqlite3userauth.h"
7694 /*
7695 ** tclcmd: sqlite3_user_authenticate DB USERNAME PASSWORD
7696 */
test_user_authenticate(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7697 static int SQLITE_TCLAPI test_user_authenticate(
7698 ClientData clientData, /* Unused */
7699 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
7700 int objc, /* Number of arguments */
7701 Tcl_Obj *CONST objv[] /* Command arguments */
7702 ){
7703 char *zUser = 0;
7704 char *zPasswd = 0;
7705 int nPasswd = 0;
7706 sqlite3 *db;
7707 int rc;
7708
7709 if( objc!=4 ){
7710 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD");
7711 return TCL_ERROR;
7712 }
7713 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
7714 return TCL_ERROR;
7715 }
7716 zUser = Tcl_GetString(objv[2]);
7717 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd);
7718 rc = sqlite3_user_authenticate(db, zUser, zPasswd, nPasswd);
7719 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
7720 return TCL_OK;
7721 }
7722 #endif /* SQLITE_USER_AUTHENTICATION */
7723
7724 #ifdef SQLITE_USER_AUTHENTICATION
7725 /*
7726 ** tclcmd: sqlite3_user_add DB USERNAME PASSWORD ISADMIN
7727 */
test_user_add(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7728 static int SQLITE_TCLAPI test_user_add(
7729 ClientData clientData, /* Unused */
7730 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
7731 int objc, /* Number of arguments */
7732 Tcl_Obj *CONST objv[] /* Command arguments */
7733 ){
7734 char *zUser = 0;
7735 char *zPasswd = 0;
7736 int nPasswd = 0;
7737 int isAdmin = 0;
7738 sqlite3 *db;
7739 int rc;
7740
7741 if( objc!=5 ){
7742 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN");
7743 return TCL_ERROR;
7744 }
7745 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
7746 return TCL_ERROR;
7747 }
7748 zUser = Tcl_GetString(objv[2]);
7749 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd);
7750 Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin);
7751 rc = sqlite3_user_add(db, zUser, zPasswd, nPasswd, isAdmin);
7752 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
7753 return TCL_OK;
7754 }
7755 #endif /* SQLITE_USER_AUTHENTICATION */
7756
7757 #ifdef SQLITE_USER_AUTHENTICATION
7758 /*
7759 ** tclcmd: sqlite3_user_change DB USERNAME PASSWORD ISADMIN
7760 */
test_user_change(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7761 static int SQLITE_TCLAPI test_user_change(
7762 ClientData clientData, /* Unused */
7763 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
7764 int objc, /* Number of arguments */
7765 Tcl_Obj *CONST objv[] /* Command arguments */
7766 ){
7767 char *zUser = 0;
7768 char *zPasswd = 0;
7769 int nPasswd = 0;
7770 int isAdmin = 0;
7771 sqlite3 *db;
7772 int rc;
7773
7774 if( objc!=5 ){
7775 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN");
7776 return TCL_ERROR;
7777 }
7778 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
7779 return TCL_ERROR;
7780 }
7781 zUser = Tcl_GetString(objv[2]);
7782 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd);
7783 Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin);
7784 rc = sqlite3_user_change(db, zUser, zPasswd, nPasswd, isAdmin);
7785 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
7786 return TCL_OK;
7787 }
7788 #endif /* SQLITE_USER_AUTHENTICATION */
7789
7790 #ifdef SQLITE_USER_AUTHENTICATION
7791 /*
7792 ** tclcmd: sqlite3_user_delete DB USERNAME
7793 */
test_user_delete(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7794 static int SQLITE_TCLAPI test_user_delete(
7795 ClientData clientData, /* Unused */
7796 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
7797 int objc, /* Number of arguments */
7798 Tcl_Obj *CONST objv[] /* Command arguments */
7799 ){
7800 char *zUser = 0;
7801 sqlite3 *db;
7802 int rc;
7803
7804 if( objc!=3 ){
7805 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME");
7806 return TCL_ERROR;
7807 }
7808 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
7809 return TCL_ERROR;
7810 }
7811 zUser = Tcl_GetString(objv[2]);
7812 rc = sqlite3_user_delete(db, zUser);
7813 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
7814 return TCL_OK;
7815 }
7816 #endif /* SQLITE_USER_AUTHENTICATION */
7817
7818 /*
7819 ** tclcmd: bad_behavior TYPE
7820 **
7821 ** Do some things that should trigger a valgrind or -fsanitize=undefined
7822 ** warning. This is used to verify that errors and warnings output by those
7823 ** tools are detected by the test scripts.
7824 **
7825 ** TYPE BEHAVIOR
7826 ** 1 Overflow a signed integer
7827 ** 2 Jump based on an uninitialized variable
7828 ** 3 Read after free
7829 ** 4 Panic
7830 */
test_bad_behavior(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7831 static int SQLITE_TCLAPI test_bad_behavior(
7832 ClientData clientData, /* Pointer to an integer containing zero */
7833 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
7834 int objc, /* Number of arguments */
7835 Tcl_Obj *CONST objv[] /* Command arguments */
7836 ){
7837 int iType;
7838 int xyz;
7839 int i = *(int*)clientData;
7840 int j;
7841 int w[10];
7842 int *a;
7843 if( objc!=2 ){
7844 Tcl_WrongNumArgs(interp, 1, objv, "TYPE");
7845 return TCL_ERROR;
7846 }
7847 if( Tcl_GetIntFromObj(interp, objv[1], &iType) ) return TCL_ERROR;
7848 switch( iType ){
7849 case 1: {
7850 xyz = 0x7fffff00 - i;
7851 xyz += 0x100;
7852 Tcl_SetObjResult(interp, Tcl_NewIntObj(xyz));
7853 break;
7854 }
7855 case 2: {
7856 w[1] = 5;
7857 if( w[i]>0 ) w[1]++;
7858 Tcl_SetObjResult(interp, Tcl_NewIntObj(w[1]));
7859 break;
7860 }
7861 case 3: {
7862 a = malloc( sizeof(int)*10 );
7863 for(j=0; j<10; j++) a[j] = j;
7864 free(a);
7865 Tcl_SetObjResult(interp, Tcl_NewIntObj(a[i]));
7866 break;
7867 }
7868 case 4: {
7869 Tcl_Panic("Deliberate panic");
7870 break;
7871 }
7872 }
7873 return TCL_OK;
7874 }
7875
7876 /*
7877 ** tclcmd: register_dbstat_vtab DB
7878 **
7879 ** Cause the dbstat virtual table to be available on the connection DB
7880 */
test_register_dbstat_vtab(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7881 static int SQLITE_TCLAPI test_register_dbstat_vtab(
7882 void *clientData,
7883 Tcl_Interp *interp,
7884 int objc,
7885 Tcl_Obj *CONST objv[]
7886 ){
7887 #ifdef SQLITE_OMIT_VIRTUALTABLE
7888 Tcl_AppendResult(interp, "dbstat not available because of "
7889 "SQLITE_OMIT_VIRTUALTABLE", (void*)0);
7890 return TCL_ERROR;
7891 #else
7892 struct SqliteDb { sqlite3 *db; };
7893 char *zDb;
7894 Tcl_CmdInfo cmdInfo;
7895
7896 if( objc!=2 ){
7897 Tcl_WrongNumArgs(interp, 1, objv, "DB");
7898 return TCL_ERROR;
7899 }
7900
7901 zDb = Tcl_GetString(objv[1]);
7902 if( Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
7903 sqlite3* db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
7904 sqlite3DbstatRegister(db);
7905 }
7906 return TCL_OK;
7907 #endif /* SQLITE_OMIT_VIRTUALTABLE */
7908 }
7909
7910 /*
7911 ** tclcmd: sqlite3_db_config DB SETTING VALUE
7912 **
7913 ** Invoke sqlite3_db_config() for one of the setting values.
7914 */
test_sqlite3_db_config(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7915 static int SQLITE_TCLAPI test_sqlite3_db_config(
7916 void *clientData,
7917 Tcl_Interp *interp,
7918 int objc,
7919 Tcl_Obj *CONST objv[]
7920 ){
7921 static const struct {
7922 const char *zName;
7923 int eVal;
7924 } aSetting[] = {
7925 { "FKEY", SQLITE_DBCONFIG_ENABLE_FKEY },
7926 { "TRIGGER", SQLITE_DBCONFIG_ENABLE_TRIGGER },
7927 { "FTS3_TOKENIZER", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
7928 { "LOAD_EXTENSION", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
7929 { "NO_CKPT_ON_CLOSE", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE },
7930 { "QPSG", SQLITE_DBCONFIG_ENABLE_QPSG },
7931 { "TRIGGER_EQP", SQLITE_DBCONFIG_TRIGGER_EQP },
7932 { "RESET_DB", SQLITE_DBCONFIG_RESET_DATABASE },
7933 { "DEFENSIVE", SQLITE_DBCONFIG_DEFENSIVE },
7934 { "WRITABLE_SCHEMA", SQLITE_DBCONFIG_WRITABLE_SCHEMA },
7935 { "LEGACY_ALTER_TABLE", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE },
7936 { "DQS_DML", SQLITE_DBCONFIG_DQS_DML },
7937 { "DQS_DDL", SQLITE_DBCONFIG_DQS_DDL },
7938 { "LEGACY_FILE_FORMAT", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT },
7939 };
7940 int i;
7941 int v = 0;
7942 const char *zSetting;
7943 sqlite3 *db;
7944
7945 if( objc!=4 && objc!=3 ){
7946 Tcl_WrongNumArgs(interp, 1, objv, "DB SETTING [VALUE]");
7947 return TCL_ERROR;
7948 }
7949 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
7950 zSetting = Tcl_GetString(objv[2]);
7951 if( sqlite3_strglob("SQLITE_*", zSetting)==0 ) zSetting += 7;
7952 if( sqlite3_strglob("DBCONFIG_*", zSetting)==0 ) zSetting += 9;
7953 if( sqlite3_strglob("ENABLE_*", zSetting)==0 ) zSetting += 7;
7954 for(i=0; i<ArraySize(aSetting); i++){
7955 if( strcmp(zSetting, aSetting[i].zName)==0 ) break;
7956 }
7957 if( i>=ArraySize(aSetting) ){
7958 Tcl_SetObjResult(interp,
7959 Tcl_NewStringObj("unknown sqlite3_db_config setting", -1));
7960 return TCL_ERROR;
7961 }
7962 if( objc==4 ){
7963 if( Tcl_GetIntFromObj(interp, objv[3], &v) ) return TCL_ERROR;
7964 }else{
7965 v = -1;
7966 }
7967 sqlite3_db_config(db, aSetting[i].eVal, v, &v);
7968 Tcl_SetObjResult(interp, Tcl_NewIntObj(v));
7969 return TCL_OK;
7970 }
7971 /*
7972 ** tclcmd: sqlite3_txn_state DB ?SCHEMA?
7973 **
7974 ** Invoke sqlite3_txn_state(DB,SCHEMA) and return the
7975 ** numeric value that results. Use NULL for SCHEMA if the 3 argument
7976 ** is omitted.
7977 */
test_sqlite3_txn_state(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])7978 static int SQLITE_TCLAPI test_sqlite3_txn_state(
7979 void *clientData,
7980 Tcl_Interp *interp,
7981 int objc,
7982 Tcl_Obj *CONST objv[]
7983 ){
7984 sqlite3 *db;
7985 const char *zSchema;
7986 int iTxn;
7987
7988 if( objc!=2 && objc!=3 ){
7989 Tcl_WrongNumArgs(interp, 1, objv, "DB ?SCHEMA?");
7990 return TCL_ERROR;
7991 }
7992 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
7993 zSchema = objc==3 ? Tcl_GetString(objv[2]) : 0;
7994 iTxn = sqlite3_txn_state(db, zSchema);
7995 Tcl_SetObjResult(interp, Tcl_NewIntObj(iTxn));
7996 return TCL_OK;
7997 }
7998
7999 /*
8000 ** Change the name of the main database schema from "main" to "icecube".
8001 */
test_dbconfig_maindbname_icecube(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])8002 static int SQLITE_TCLAPI test_dbconfig_maindbname_icecube(
8003 void * clientData,
8004 Tcl_Interp *interp,
8005 int objc,
8006 Tcl_Obj *CONST objv[]
8007 ){
8008 int rc;
8009 sqlite3 *db;
8010 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
8011 if( objc!=2 ){
8012 Tcl_WrongNumArgs(interp, 1, objv, "DB");
8013 return TCL_ERROR;
8014 }else{
8015 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
8016 rc = sqlite3_db_config(db, SQLITE_DBCONFIG_MAINDBNAME, "icecube");
8017 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
8018 return TCL_OK;
8019 }
8020 }
8021
8022 /*
8023 ** Usage: sqlite3_mmap_warm DB DBNAME
8024 */
test_mmap_warm(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])8025 static int SQLITE_TCLAPI test_mmap_warm(
8026 void * clientData,
8027 Tcl_Interp *interp,
8028 int objc,
8029 Tcl_Obj *CONST objv[]
8030 ){
8031 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
8032 extern int sqlite3_mmap_warm(sqlite3 *db, const char *);
8033
8034 if( objc!=2 && objc!=3 ){
8035 Tcl_WrongNumArgs(interp, 1, objv, "DB ?DBNAME?");
8036 return TCL_ERROR;
8037 }else{
8038 int rc;
8039 sqlite3 *db;
8040 const char *zDb = 0;
8041 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
8042 if( objc==3 ){
8043 zDb = Tcl_GetString(objv[2]);
8044 }
8045 rc = sqlite3_mmap_warm(db, zDb);
8046 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
8047 return TCL_OK;
8048 }
8049 }
8050
8051 /*
8052 ** Usage: test_write_db DB OFFSET DATA
8053 **
8054 ** Obtain the sqlite3_file* object for the database file for the "main" db
8055 ** of handle DB. Then invoke its xWrite method to write data DATA to offset
8056 ** OFFSET.
8057 */
test_write_db(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])8058 static int SQLITE_TCLAPI test_write_db(
8059 void * clientData,
8060 Tcl_Interp *interp,
8061 int objc,
8062 Tcl_Obj *CONST objv[]
8063 ){
8064 sqlite3 *db = 0;
8065 Tcl_WideInt iOff = 0;
8066 const unsigned char *aData = 0;
8067 int nData = 0;
8068 sqlite3_file *pFile = 0;
8069 int rc;
8070
8071 if( objc!=4 ){
8072 Tcl_WrongNumArgs(interp, 1, objv, "DB OFFSET DATA");
8073 return TCL_ERROR;
8074 }
8075 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
8076 if( Tcl_GetWideIntFromObj(interp, objv[2], &iOff) ) return TCL_ERROR;
8077 aData = Tcl_GetByteArrayFromObj(objv[3], &nData);
8078
8079 sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, (void*)&pFile);
8080 rc = pFile->pMethods->xWrite(pFile, aData, nData, iOff);
8081
8082 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
8083 return TCL_OK;
8084 }
8085
8086 /*
8087 ** Usage: sqlite3_register_cksumvfs
8088 **
8089 */
test_register_cksumvfs(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])8090 static int SQLITE_TCLAPI test_register_cksumvfs(
8091 void * clientData,
8092 Tcl_Interp *interp,
8093 int objc,
8094 Tcl_Obj *CONST objv[]
8095 ){
8096 if( objc!=1 ){
8097 Tcl_WrongNumArgs(interp, 1, objv, "");
8098 return TCL_ERROR;
8099 }else{
8100 extern int sqlite3_register_cksumvfs(const char*);
8101 int rc = sqlite3_register_cksumvfs(0);
8102 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
8103 }
8104 return TCL_OK;
8105 }
8106
8107 /*
8108 ** Usage: sqlite3_unregister_cksumvfs
8109 **
8110 */
test_unregister_cksumvfs(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])8111 static int SQLITE_TCLAPI test_unregister_cksumvfs(
8112 void * clientData,
8113 Tcl_Interp *interp,
8114 int objc,
8115 Tcl_Obj *CONST objv[]
8116 ){
8117 if( objc!=1 ){
8118 Tcl_WrongNumArgs(interp, 1, objv, "");
8119 return TCL_ERROR;
8120 }else{
8121 extern int sqlite3_unregister_cksumvfs(void);
8122 int rc = sqlite3_unregister_cksumvfs();
8123 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
8124 }
8125 return TCL_OK;
8126 }
8127
8128 /*
8129 ** Usage: decode_hexdb TEXT
8130 **
8131 ** Example: db deserialize [decode_hexdb $output_of_dbtotxt]
8132 **
8133 ** This routine returns a byte-array for an SQLite database file that
8134 ** is constructed from a text input which is the output of the "dbtotxt"
8135 ** utility.
8136 */
test_decode_hexdb(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])8137 static int SQLITE_TCLAPI test_decode_hexdb(
8138 void * clientData,
8139 Tcl_Interp *interp,
8140 int objc,
8141 Tcl_Obj *CONST objv[]
8142 ){
8143 const char *zIn = 0;
8144 unsigned char *a = 0;
8145 int n = 0;
8146 int lineno = 0;
8147 int i, iNext;
8148 int iOffset = 0;
8149 int j, k;
8150 int rc;
8151 unsigned int x[16];
8152 if( objc!=2 ){
8153 Tcl_WrongNumArgs(interp, 1, objv, "HEXDB");
8154 return TCL_ERROR;
8155 }
8156 zIn = Tcl_GetString(objv[1]);
8157 for(i=0; zIn[i]; i=iNext){
8158 lineno++;
8159 for(iNext=i; zIn[iNext] && zIn[iNext]!='\n'; iNext++){}
8160 if( zIn[iNext]=='\n' ) iNext++;
8161 while( zIn[i]==' ' || zIn[i]=='\t' ){ i++; }
8162 if( a==0 ){
8163 int pgsz;
8164 rc = sscanf(zIn+i, "| size %d pagesize %d", &n, &pgsz);
8165 if( rc!=2 ) continue;
8166 if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ){
8167 Tcl_AppendResult(interp, "bad 'pagesize' field", (void*)0);
8168 return TCL_ERROR;
8169 }
8170 n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */
8171 if( n<512 ){
8172 Tcl_AppendResult(interp, "bad 'size' field", (void*)0);
8173 return TCL_ERROR;
8174 }
8175 a = malloc( n );
8176 if( a==0 ){
8177 Tcl_AppendResult(interp, "out of memory", (void*)0);
8178 return TCL_ERROR;
8179 }
8180 memset(a, 0, n);
8181 continue;
8182 }
8183 rc = sscanf(zIn+i, "| page %d offset %d", &j, &k);
8184 if( rc==2 ){
8185 iOffset = k;
8186 continue;
8187 }
8188 rc = sscanf(zIn+i,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
8189 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
8190 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]);
8191 if( rc==17 ){
8192 k = iOffset+j;
8193 if( k+16<=n ){
8194 int ii;
8195 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff;
8196 }
8197 continue;
8198 }
8199 }
8200 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(a, n));
8201 free(a);
8202 return TCL_OK;
8203 }
8204
8205
8206 /*
8207 ** Register commands with the TCL interpreter.
8208 */
Sqlitetest1_Init(Tcl_Interp * interp)8209 int Sqlitetest1_Init(Tcl_Interp *interp){
8210 extern int sqlite3_search_count;
8211 extern int sqlite3_found_count;
8212 extern int sqlite3_interrupt_count;
8213 extern int sqlite3_open_file_count;
8214 extern int sqlite3_sort_count;
8215 extern int sqlite3_current_time;
8216 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
8217 extern int sqlite3_hostid_num;
8218 #endif
8219 extern int sqlite3_max_blobsize;
8220 extern int SQLITE_TCLAPI sqlite3BtreeSharedCacheReport(void*,
8221 Tcl_Interp*,int,Tcl_Obj*CONST*);
8222 static int iZero = 0;
8223 static struct {
8224 char *zName;
8225 Tcl_CmdProc *xProc;
8226 } aCmd[] = {
8227 { "db_enter", (Tcl_CmdProc*)db_enter },
8228 { "db_leave", (Tcl_CmdProc*)db_leave },
8229 { "sqlite3_mprintf_int", (Tcl_CmdProc*)sqlite3_mprintf_int },
8230 { "sqlite3_mprintf_int64", (Tcl_CmdProc*)sqlite3_mprintf_int64 },
8231 { "sqlite3_mprintf_long", (Tcl_CmdProc*)sqlite3_mprintf_long },
8232 { "sqlite3_mprintf_str", (Tcl_CmdProc*)sqlite3_mprintf_str },
8233 { "sqlite3_snprintf_str", (Tcl_CmdProc*)sqlite3_snprintf_str },
8234 { "sqlite3_mprintf_stronly", (Tcl_CmdProc*)sqlite3_mprintf_stronly},
8235 { "sqlite3_mprintf_double", (Tcl_CmdProc*)sqlite3_mprintf_double },
8236 { "sqlite3_mprintf_scaled", (Tcl_CmdProc*)sqlite3_mprintf_scaled },
8237 { "sqlite3_mprintf_hexdouble", (Tcl_CmdProc*)sqlite3_mprintf_hexdouble},
8238 { "sqlite3_mprintf_z_test", (Tcl_CmdProc*)test_mprintf_z },
8239 { "sqlite3_mprintf_n_test", (Tcl_CmdProc*)test_mprintf_n },
8240 { "sqlite3_snprintf_int", (Tcl_CmdProc*)test_snprintf_int },
8241 { "sqlite3_last_insert_rowid", (Tcl_CmdProc*)test_last_rowid },
8242 { "sqlite3_exec_printf", (Tcl_CmdProc*)test_exec_printf },
8243 { "sqlite3_exec_hex", (Tcl_CmdProc*)test_exec_hex },
8244 { "sqlite3_exec", (Tcl_CmdProc*)test_exec },
8245 { "sqlite3_exec_nr", (Tcl_CmdProc*)test_exec_nr },
8246 #ifndef SQLITE_OMIT_GET_TABLE
8247 { "sqlite3_get_table_printf", (Tcl_CmdProc*)test_get_table_printf },
8248 #endif
8249 { "sqlite3_close", (Tcl_CmdProc*)sqlite_test_close },
8250 { "sqlite3_close_v2", (Tcl_CmdProc*)sqlite_test_close_v2 },
8251 { "sqlite3_create_function", (Tcl_CmdProc*)test_create_function },
8252 { "sqlite3_create_aggregate", (Tcl_CmdProc*)test_create_aggregate },
8253 { "sqlite3_drop_modules", (Tcl_CmdProc*)test_drop_modules },
8254 { "sqlite_register_test_function", (Tcl_CmdProc*)test_register_func },
8255 { "sqlite_abort", (Tcl_CmdProc*)sqlite_abort },
8256 { "sqlite_bind", (Tcl_CmdProc*)test_bind },
8257 { "breakpoint", (Tcl_CmdProc*)test_breakpoint },
8258 { "sqlite3_key", (Tcl_CmdProc*)test_key },
8259 { "sqlite3_rekey", (Tcl_CmdProc*)test_rekey },
8260 { "sqlite_set_magic", (Tcl_CmdProc*)sqlite_set_magic },
8261 { "sqlite3_interrupt", (Tcl_CmdProc*)test_interrupt },
8262 { "sqlite_delete_function", (Tcl_CmdProc*)delete_function },
8263 { "sqlite_delete_collation", (Tcl_CmdProc*)delete_collation },
8264 { "sqlite3_get_autocommit", (Tcl_CmdProc*)get_autocommit },
8265 { "sqlite3_busy_timeout", (Tcl_CmdProc*)test_busy_timeout },
8266 { "printf", (Tcl_CmdProc*)test_printf },
8267 { "sqlite3IoTrace", (Tcl_CmdProc*)test_io_trace },
8268 { "clang_sanitize_address", (Tcl_CmdProc*)clang_sanitize_address },
8269 };
8270 static struct {
8271 char *zName;
8272 Tcl_ObjCmdProc *xProc;
8273 void *clientData;
8274 } aObjCmd[] = {
8275 { "sqlite3_db_config", test_sqlite3_db_config, 0 },
8276 { "sqlite3_txn_state", test_sqlite3_txn_state, 0 },
8277 { "bad_behavior", test_bad_behavior, (void*)&iZero },
8278 { "register_dbstat_vtab", test_register_dbstat_vtab },
8279 { "sqlite3_connection_pointer", get_sqlite_pointer, 0 },
8280 { "intarray_addr", test_intarray_addr, 0 },
8281 { "int64array_addr", test_int64array_addr, 0 },
8282 { "doublearray_addr", test_doublearray_addr, 0 },
8283 { "textarray_addr", test_textarray_addr, 0 },
8284 { "sqlite3_bind_int", test_bind_int, 0 },
8285 { "sqlite3_bind_zeroblob", test_bind_zeroblob, 0 },
8286 { "sqlite3_bind_zeroblob64", test_bind_zeroblob64, 0 },
8287 { "sqlite3_bind_int64", test_bind_int64, 0 },
8288 { "sqlite3_bind_double", test_bind_double, 0 },
8289 { "sqlite3_bind_null", test_bind_null ,0 },
8290 { "sqlite3_bind_text", test_bind_text ,0 },
8291 { "sqlite3_bind_text16", test_bind_text16 ,0 },
8292 { "sqlite3_bind_blob", test_bind_blob ,0 },
8293 #ifndef SQLITE_OMIT_VIRTUALTABLE
8294 { "sqlite3_carray_bind", test_carray_bind ,0 },
8295 #endif
8296 { "sqlite3_bind_parameter_count", test_bind_parameter_count, 0},
8297 { "sqlite3_bind_parameter_name", test_bind_parameter_name, 0},
8298 { "sqlite3_bind_parameter_index", test_bind_parameter_index, 0},
8299 { "sqlite3_clear_bindings", test_clear_bindings, 0},
8300 { "sqlite3_sleep", test_sleep, 0},
8301 { "sqlite3_errcode", test_errcode ,0 },
8302 { "sqlite3_extended_errcode", test_ex_errcode ,0 },
8303 { "sqlite3_errmsg", test_errmsg ,0 },
8304 { "sqlite3_errmsg16", test_errmsg16 ,0 },
8305 { "sqlite3_open", test_open ,0 },
8306 { "sqlite3_open16", test_open16 ,0 },
8307 { "sqlite3_open_v2", test_open_v2 ,0 },
8308 { "sqlite3_complete16", test_complete16 ,0 },
8309 { "sqlite3_normalize", test_normalize ,0 },
8310
8311 { "sqlite3_prepare", test_prepare ,0 },
8312 { "sqlite3_prepare16", test_prepare16 ,0 },
8313 { "sqlite3_prepare_v2", test_prepare_v2 ,0 },
8314 { "sqlite3_prepare_v3", test_prepare_v3 ,0 },
8315 { "sqlite3_prepare_tkt3134", test_prepare_tkt3134, 0},
8316 { "sqlite3_prepare16_v2", test_prepare16_v2 ,0 },
8317 { "sqlite3_finalize", test_finalize ,0 },
8318 { "sqlite3_stmt_status", test_stmt_status ,0 },
8319 { "sqlite3_reset", test_reset ,0 },
8320 { "sqlite3_expired", test_expired ,0 },
8321 { "sqlite3_transfer_bindings", test_transfer_bind ,0 },
8322 { "sqlite3_changes", test_changes ,0 },
8323 { "sqlite3_step", test_step ,0 },
8324 { "sqlite3_sql", test_sql ,0 },
8325 { "sqlite3_expanded_sql", test_ex_sql ,0 },
8326 #ifdef SQLITE_ENABLE_NORMALIZE
8327 { "sqlite3_normalized_sql", test_norm_sql ,0 },
8328 #endif
8329 { "sqlite3_next_stmt", test_next_stmt ,0 },
8330 { "sqlite3_stmt_readonly", test_stmt_readonly ,0 },
8331 { "sqlite3_stmt_isexplain", test_stmt_isexplain,0 },
8332 { "sqlite3_stmt_busy", test_stmt_busy ,0 },
8333 { "uses_stmt_journal", uses_stmt_journal ,0 },
8334
8335 { "sqlite3_release_memory", test_release_memory, 0},
8336 { "sqlite3_db_release_memory", test_db_release_memory, 0},
8337 { "sqlite3_db_cacheflush", test_db_cacheflush, 0},
8338 { "sqlite3_system_errno", test_system_errno, 0},
8339 { "sqlite3_db_filename", test_db_filename, 0},
8340 { "sqlite3_db_readonly", test_db_readonly, 0},
8341 { "sqlite3_soft_heap_limit", test_soft_heap_limit, 0},
8342 { "sqlite3_soft_heap_limit64", test_soft_heap_limit, 0},
8343 { "sqlite3_hard_heap_limit64", test_hard_heap_limit, 0},
8344 { "sqlite3_thread_cleanup", test_thread_cleanup, 0},
8345 { "sqlite3_pager_refcounts", test_pager_refcounts, 0},
8346
8347 { "sqlite3_load_extension", test_load_extension, 0},
8348 { "sqlite3_enable_load_extension", test_enable_load, 0},
8349 { "sqlite3_extended_result_codes", test_extended_result_codes, 0},
8350 { "sqlite3_limit", test_limit, 0},
8351 { "dbconfig_maindbname_icecube", test_dbconfig_maindbname_icecube },
8352
8353 { "save_prng_state", save_prng_state, 0 },
8354 { "restore_prng_state", restore_prng_state, 0 },
8355 { "reset_prng_state", reset_prng_state, 0 },
8356 { "prng_seed", prng_seed, 0 },
8357 { "extra_schema_checks", extra_schema_checks, 0},
8358 { "database_never_corrupt", database_never_corrupt, 0},
8359 { "database_may_be_corrupt", database_may_be_corrupt, 0},
8360 { "optimization_control", optimization_control,0},
8361 #if SQLITE_OS_WIN
8362 { "lock_win32_file", win32_file_lock, 0 },
8363 { "exists_win32_path", win32_exists_path, 0 },
8364 { "find_win32_file", win32_find_file, 0 },
8365 { "delete_win32_file", win32_delete_file, 0 },
8366 { "make_win32_dir", win32_mkdir, 0 },
8367 { "remove_win32_dir", win32_rmdir, 0 },
8368 #endif
8369 { "tcl_objproc", runAsObjProc, 0 },
8370
8371 /* sqlite3_column_*() API */
8372 { "sqlite3_column_count", test_column_count ,0 },
8373 { "sqlite3_data_count", test_data_count ,0 },
8374 { "sqlite3_column_type", test_column_type ,0 },
8375 { "sqlite3_column_blob", test_column_blob ,0 },
8376 { "sqlite3_column_double", test_column_double ,0 },
8377 { "sqlite3_column_int64", test_column_int64 ,0 },
8378 { "sqlite3_column_text", test_stmt_utf8, (void*)sqlite3_column_text },
8379 { "sqlite3_column_name", test_stmt_utf8, (void*)sqlite3_column_name },
8380 { "sqlite3_column_int", test_stmt_int, (void*)sqlite3_column_int },
8381 { "sqlite3_column_bytes", test_stmt_int, (void*)sqlite3_column_bytes},
8382 #ifndef SQLITE_OMIT_DECLTYPE
8383 { "sqlite3_column_decltype",test_stmt_utf8,(void*)sqlite3_column_decltype},
8384 #endif
8385 #ifdef SQLITE_ENABLE_COLUMN_METADATA
8386 { "sqlite3_column_database_name",test_stmt_utf8,(void*)sqlite3_column_database_name},
8387 { "sqlite3_column_table_name",test_stmt_utf8,(void*)sqlite3_column_table_name},
8388 { "sqlite3_column_origin_name",test_stmt_utf8,(void*)sqlite3_column_origin_name},
8389 #endif
8390
8391 #ifndef SQLITE_OMIT_UTF16
8392 { "sqlite3_column_bytes16", test_stmt_int, (void*)sqlite3_column_bytes16 },
8393 { "sqlite3_column_text16", test_stmt_utf16, (void*)sqlite3_column_text16},
8394 { "sqlite3_column_name16", test_stmt_utf16, (void*)sqlite3_column_name16},
8395 { "add_alignment_test_collations", add_alignment_test_collations, 0 },
8396 #ifndef SQLITE_OMIT_DECLTYPE
8397 { "sqlite3_column_decltype16",test_stmt_utf16,(void*)sqlite3_column_decltype16},
8398 #endif
8399 #ifdef SQLITE_ENABLE_COLUMN_METADATA
8400 {"sqlite3_column_database_name16",
8401 test_stmt_utf16, (void*)sqlite3_column_database_name16},
8402 {"sqlite3_column_table_name16", test_stmt_utf16, (void*)sqlite3_column_table_name16},
8403 {"sqlite3_column_origin_name16", test_stmt_utf16, (void*)sqlite3_column_origin_name16},
8404 #endif
8405 #endif
8406 { "sqlite3_create_collation_v2", test_create_collation_v2, 0 },
8407 { "sqlite3_global_recover", test_global_recover, 0 },
8408 { "working_64bit_int", working_64bit_int, 0 },
8409 { "vfs_unlink_test", vfs_unlink_test, 0 },
8410 { "vfs_initfail_test", vfs_initfail_test, 0 },
8411 { "vfs_unregister_all", vfs_unregister_all, 0 },
8412 { "vfs_reregister_all", vfs_reregister_all, 0 },
8413 { "file_control_test", file_control_test, 0 },
8414 { "file_control_lasterrno_test", file_control_lasterrno_test, 0 },
8415 { "file_control_lockproxy_test", file_control_lockproxy_test, 0 },
8416 { "file_control_chunksize_test", file_control_chunksize_test, 0 },
8417 { "file_control_sizehint_test", file_control_sizehint_test, 0 },
8418 { "file_control_data_version", file_control_data_version, 0 },
8419 #if SQLITE_OS_WIN
8420 { "file_control_win32_av_retry", file_control_win32_av_retry, 0 },
8421 { "file_control_win32_get_handle", file_control_win32_get_handle, 0 },
8422 { "file_control_win32_set_handle", file_control_win32_set_handle, 0 },
8423 #endif
8424 { "file_control_persist_wal", file_control_persist_wal, 0 },
8425 { "file_control_powersafe_overwrite",file_control_powersafe_overwrite,0},
8426 { "file_control_vfsname", file_control_vfsname, 0 },
8427 { "file_control_reservebytes", file_control_reservebytes, 0 },
8428 { "file_control_tempfilename", file_control_tempfilename, 0 },
8429 { "sqlite3_vfs_list", vfs_list, 0 },
8430 { "sqlite3_create_function_v2", test_create_function_v2, 0 },
8431
8432 /* Functions from os.h */
8433 #ifndef SQLITE_OMIT_UTF16
8434 { "add_test_collate", test_collate, 0 },
8435 { "add_test_collate_needed", test_collate_needed, 0 },
8436 { "add_test_function", test_function, 0 },
8437 { "add_test_utf16bin_collate", test_utf16bin_collate, 0 },
8438 #endif
8439 { "sqlite3_test_errstr", test_errstr, 0 },
8440 { "tcl_variable_type", tcl_variable_type, 0 },
8441 #ifndef SQLITE_OMIT_SHARED_CACHE
8442 { "sqlite3_enable_shared_cache", test_enable_shared, 0 },
8443 { "sqlite3_shared_cache_report", sqlite3BtreeSharedCacheReport, 0},
8444 #endif
8445 { "sqlite3_libversion_number", test_libversion_number, 0 },
8446 { "sqlite3_table_column_metadata", test_table_column_metadata, 0 },
8447 #ifndef SQLITE_OMIT_INCRBLOB
8448 { "sqlite3_blob_reopen", test_blob_reopen, 0 },
8449 #endif
8450 { "pcache_stats", test_pcache_stats, 0 },
8451 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
8452 { "sqlite3_unlock_notify", test_unlock_notify, 0 },
8453 #endif
8454 { "sqlite3_wal_checkpoint", test_wal_checkpoint, 0 },
8455 { "sqlite3_wal_checkpoint_v2",test_wal_checkpoint_v2, 0 },
8456 { "sqlite3_wal_autocheckpoint",test_wal_autocheckpoint, 0 },
8457 { "test_sqlite3_log", test_sqlite3_log, 0 },
8458 #ifndef SQLITE_OMIT_EXPLAIN
8459 { "print_explain_query_plan", test_print_eqp, 0 },
8460 #endif
8461 { "sqlite3_test_control", test_test_control },
8462 #if SQLITE_OS_UNIX
8463 { "getrusage", test_getrusage },
8464 #endif
8465 { "load_static_extension", tclLoadStaticExtensionCmd },
8466 { "sorter_test_fakeheap", sorter_test_fakeheap },
8467 { "sorter_test_sort4_helper", sorter_test_sort4_helper },
8468 #ifdef SQLITE_USER_AUTHENTICATION
8469 { "sqlite3_user_authenticate", test_user_authenticate, 0 },
8470 { "sqlite3_user_add", test_user_add, 0 },
8471 { "sqlite3_user_change", test_user_change, 0 },
8472 { "sqlite3_user_delete", test_user_delete, 0 },
8473 #endif
8474 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
8475 { "sqlite3_stmt_scanstatus", test_stmt_scanstatus, 0 },
8476 { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset, 0 },
8477 #endif
8478 #ifdef SQLITE_ENABLE_SQLLOG
8479 { "sqlite3_config_sqllog", test_config_sqllog, 0 },
8480 #endif
8481 { "vfs_current_time_int64", vfsCurrentTimeInt64, 0 },
8482 #ifdef SQLITE_ENABLE_SNAPSHOT
8483 { "sqlite3_snapshot_get", test_snapshot_get, 0 },
8484 { "sqlite3_snapshot_open", test_snapshot_open, 0 },
8485 { "sqlite3_snapshot_free", test_snapshot_free, 0 },
8486 { "sqlite3_snapshot_cmp", test_snapshot_cmp, 0 },
8487 { "sqlite3_snapshot_recover", test_snapshot_recover, 0 },
8488 { "sqlite3_snapshot_get_blob", test_snapshot_get_blob, 0 },
8489 { "sqlite3_snapshot_open_blob", test_snapshot_open_blob, 0 },
8490 { "sqlite3_snapshot_cmp_blob", test_snapshot_cmp_blob, 0 },
8491 #endif
8492 { "sqlite3_delete_database", test_delete_database, 0 },
8493 { "atomic_batch_write", test_atomic_batch_write, 0 },
8494 { "sqlite3_mmap_warm", test_mmap_warm, 0 },
8495 { "sqlite3_config_sorterref", test_config_sorterref, 0 },
8496 { "decode_hexdb", test_decode_hexdb, 0 },
8497 { "test_write_db", test_write_db, 0 },
8498 { "sqlite3_register_cksumvfs", test_register_cksumvfs, 0 },
8499 { "sqlite3_unregister_cksumvfs", test_unregister_cksumvfs, 0 },
8500 };
8501 static int bitmask_size = sizeof(Bitmask)*8;
8502 static int longdouble_size = sizeof(LONGDOUBLE_TYPE);
8503 int i;
8504 extern int sqlite3_sync_count, sqlite3_fullsync_count;
8505 extern int sqlite3_opentemp_count;
8506 extern int sqlite3_like_count;
8507 extern int sqlite3_xferopt_count;
8508 extern int sqlite3_pager_readdb_count;
8509 extern int sqlite3_pager_writedb_count;
8510 extern int sqlite3_pager_writej_count;
8511 #if SQLITE_OS_WIN
8512 extern LONG volatile sqlite3_os_type;
8513 #endif
8514 #ifdef SQLITE_DEBUG
8515 extern int sqlite3WhereTrace;
8516 extern int sqlite3OSTrace;
8517 extern int sqlite3WalTrace;
8518 #endif
8519 #ifdef SQLITE_TEST
8520 #ifdef SQLITE_ENABLE_FTS3
8521 extern int sqlite3_fts3_enable_parentheses;
8522 #endif
8523 #endif
8524 #if defined(SQLITE_ENABLE_SELECTTRACE)
8525 extern u32 sqlite3_unsupported_selecttrace;
8526 #endif
8527
8528 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
8529 Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
8530 }
8531 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
8532 Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
8533 aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
8534 }
8535 Tcl_LinkVar(interp, "sqlite_search_count",
8536 (char*)&sqlite3_search_count, TCL_LINK_INT);
8537 Tcl_LinkVar(interp, "sqlite_found_count",
8538 (char*)&sqlite3_found_count, TCL_LINK_INT);
8539 Tcl_LinkVar(interp, "sqlite_sort_count",
8540 (char*)&sqlite3_sort_count, TCL_LINK_INT);
8541 Tcl_LinkVar(interp, "sqlite3_max_blobsize",
8542 (char*)&sqlite3_max_blobsize, TCL_LINK_INT);
8543 Tcl_LinkVar(interp, "sqlite_like_count",
8544 (char*)&sqlite3_like_count, TCL_LINK_INT);
8545 Tcl_LinkVar(interp, "sqlite_interrupt_count",
8546 (char*)&sqlite3_interrupt_count, TCL_LINK_INT);
8547 Tcl_LinkVar(interp, "sqlite_open_file_count",
8548 (char*)&sqlite3_open_file_count, TCL_LINK_INT);
8549 Tcl_LinkVar(interp, "sqlite_current_time",
8550 (char*)&sqlite3_current_time, TCL_LINK_INT);
8551 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
8552 Tcl_LinkVar(interp, "sqlite_hostid_num",
8553 (char*)&sqlite3_hostid_num, TCL_LINK_INT);
8554 #endif
8555 Tcl_LinkVar(interp, "sqlite3_xferopt_count",
8556 (char*)&sqlite3_xferopt_count, TCL_LINK_INT);
8557 Tcl_LinkVar(interp, "sqlite3_pager_readdb_count",
8558 (char*)&sqlite3_pager_readdb_count, TCL_LINK_INT);
8559 Tcl_LinkVar(interp, "sqlite3_pager_writedb_count",
8560 (char*)&sqlite3_pager_writedb_count, TCL_LINK_INT);
8561 Tcl_LinkVar(interp, "sqlite3_pager_writej_count",
8562 (char*)&sqlite3_pager_writej_count, TCL_LINK_INT);
8563 #ifndef SQLITE_OMIT_UTF16
8564 Tcl_LinkVar(interp, "unaligned_string_counter",
8565 (char*)&unaligned_string_counter, TCL_LINK_INT);
8566 #endif
8567 #ifndef SQLITE_OMIT_UTF16
8568 Tcl_LinkVar(interp, "sqlite_last_needed_collation",
8569 (char*)&pzNeededCollation, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
8570 #endif
8571 #if SQLITE_OS_WIN
8572 Tcl_LinkVar(interp, "sqlite_os_type",
8573 (char*)&sqlite3_os_type, TCL_LINK_LONG);
8574 #endif
8575 #ifdef SQLITE_TEST
8576 {
8577 static const char *query_plan = "*** OBSOLETE VARIABLE ***";
8578 Tcl_LinkVar(interp, "sqlite_query_plan",
8579 (char*)&query_plan, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
8580 }
8581 #endif
8582 #ifdef SQLITE_DEBUG
8583 Tcl_LinkVar(interp, "sqlite_where_trace",
8584 (char*)&sqlite3WhereTrace, TCL_LINK_INT);
8585 Tcl_LinkVar(interp, "sqlite_os_trace",
8586 (char*)&sqlite3OSTrace, TCL_LINK_INT);
8587 #ifndef SQLITE_OMIT_WAL
8588 Tcl_LinkVar(interp, "sqlite_wal_trace",
8589 (char*)&sqlite3WalTrace, TCL_LINK_INT);
8590 #endif
8591 #endif
8592 #ifndef SQLITE_OMIT_DISKIO
8593 Tcl_LinkVar(interp, "sqlite_opentemp_count",
8594 (char*)&sqlite3_opentemp_count, TCL_LINK_INT);
8595 #endif
8596 Tcl_LinkVar(interp, "sqlite_static_bind_value",
8597 (char*)&sqlite_static_bind_value, TCL_LINK_STRING);
8598 Tcl_LinkVar(interp, "sqlite_static_bind_nbyte",
8599 (char*)&sqlite_static_bind_nbyte, TCL_LINK_INT);
8600 Tcl_LinkVar(interp, "sqlite_temp_directory",
8601 (char*)&sqlite3_temp_directory, TCL_LINK_STRING);
8602 Tcl_LinkVar(interp, "sqlite_data_directory",
8603 (char*)&sqlite3_data_directory, TCL_LINK_STRING);
8604 Tcl_LinkVar(interp, "bitmask_size",
8605 (char*)&bitmask_size, TCL_LINK_INT|TCL_LINK_READ_ONLY);
8606 Tcl_LinkVar(interp, "longdouble_size",
8607 (char*)&longdouble_size, TCL_LINK_INT|TCL_LINK_READ_ONLY);
8608 Tcl_LinkVar(interp, "sqlite_sync_count",
8609 (char*)&sqlite3_sync_count, TCL_LINK_INT);
8610 Tcl_LinkVar(interp, "sqlite_fullsync_count",
8611 (char*)&sqlite3_fullsync_count, TCL_LINK_INT);
8612 #if defined(SQLITE_ENABLE_SELECTTRACE)
8613 Tcl_LinkVar(interp, "sqlite3_unsupported_selecttrace",
8614 (char*)&sqlite3_unsupported_selecttrace, TCL_LINK_INT);
8615 #endif
8616 #if defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_TEST)
8617 Tcl_LinkVar(interp, "sqlite_fts3_enable_parentheses",
8618 (char*)&sqlite3_fts3_enable_parentheses, TCL_LINK_INT);
8619 #endif
8620 return TCL_OK;
8621 }
8622