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