4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** Code for testing all sorts of SQLite interfaces. This code
13 ** implements new SQL functions used by the test scripts.
16 #if defined(INCLUDE_SQLITE_TCL_H)
17 # include "sqlite_tcl.h"
25 #include "sqliteInt.h"
29 ** Allocate nByte bytes of space using sqlite3_malloc(). If the
30 ** allocation fails, call sqlite3_result_error_nomem() to notify
31 ** the database handle that malloc() has failed.
33 static void *testContextMalloc(sqlite3_context
*context
, int nByte
){
34 char *z
= sqlite3_malloc(nByte
);
36 sqlite3_result_error_nomem(context
);
42 ** This function generates a string of random characters. Used for
43 ** generating test data.
45 static void randStr(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
46 static const unsigned char zSrc
[] =
47 "abcdefghijklmnopqrstuvwxyz"
48 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
51 int iMin
, iMax
, n
, r
, i
;
52 unsigned char zBuf
[1000];
54 /* It used to be possible to call randstr() with any number of arguments,
55 ** but now it is registered with SQLite as requiring exactly 2.
59 iMin
= sqlite3_value_int(argv
[0]);
60 if( iMin
<0 ) iMin
= 0;
61 if( iMin
>=sizeof(zBuf
) ) iMin
= sizeof(zBuf
)-1;
62 iMax
= sqlite3_value_int(argv
[1]);
63 if( iMax
<iMin
) iMax
= iMin
;
64 if( iMax
>=sizeof(zBuf
) ) iMax
= sizeof(zBuf
)-1;
67 sqlite3_randomness(sizeof(r
), &r
);
69 n
+= r
%(iMax
+ 1 - iMin
);
71 assert( n
<sizeof(zBuf
) );
72 sqlite3_randomness(n
, zBuf
);
74 zBuf
[i
] = zSrc
[zBuf
[i
]%(sizeof(zSrc
)-1)];
77 sqlite3_result_text(context
, (char*)zBuf
, n
, SQLITE_TRANSIENT
);
81 ** The following two SQL functions are used to test returning a text
82 ** result with a destructor. Function 'test_destructor' takes one argument
83 ** and returns the same argument interpreted as TEXT. A destructor is
84 ** passed with the sqlite3_result_text() call.
86 ** SQL function 'test_destructor_count' returns the number of outstanding
87 ** allocations made by 'test_destructor';
89 ** WARNING: Not threadsafe.
91 static int test_destructor_count_var
= 0;
92 static void destructor(void *p
){
93 char *zVal
= (char *)p
;
97 test_destructor_count_var
--;
99 static void test_destructor(
100 sqlite3_context
*pCtx
,
107 test_destructor_count_var
++;
109 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
) return;
110 len
= sqlite3_value_bytes(argv
[0]);
111 zVal
= testContextMalloc(pCtx
, len
+3);
118 memcpy(zVal
, sqlite3_value_text(argv
[0]), len
);
119 sqlite3_result_text(pCtx
, zVal
, -1, destructor
);
121 #ifndef SQLITE_OMIT_UTF16
122 static void test_destructor16(
123 sqlite3_context
*pCtx
,
130 test_destructor_count_var
++;
132 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
) return;
133 len
= sqlite3_value_bytes16(argv
[0]);
134 zVal
= testContextMalloc(pCtx
, len
+3);
141 memcpy(zVal
, sqlite3_value_text16(argv
[0]), len
);
142 sqlite3_result_text16(pCtx
, zVal
, -1, destructor
);
145 static void test_destructor_count(
146 sqlite3_context
*pCtx
,
150 sqlite3_result_int(pCtx
, test_destructor_count_var
);
154 ** The following aggregate function, test_agg_errmsg16(), takes zero
155 ** arguments. It returns the text value returned by the sqlite3_errmsg16()
158 #ifndef SQLITE_UNTESTABLE
159 void sqlite3BeginBenignMalloc(void);
160 void sqlite3EndBenignMalloc(void);
162 #define sqlite3BeginBenignMalloc()
163 #define sqlite3EndBenignMalloc()
165 static void test_agg_errmsg16_step(sqlite3_context
*a
, int b
,sqlite3_value
**c
){
167 static void test_agg_errmsg16_final(sqlite3_context
*ctx
){
168 #ifndef SQLITE_OMIT_UTF16
170 sqlite3
* db
= sqlite3_context_db_handle(ctx
);
171 sqlite3_aggregate_context(ctx
, 2048);
172 z
= sqlite3_errmsg16(db
);
173 sqlite3_result_text16(ctx
, z
, -1, SQLITE_TRANSIENT
);
178 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
181 ** The test_auxdata() SQL function attempts to register each of its arguments
182 ** as auxiliary data. If there are no prior registrations of aux data for
183 ** that argument (meaning the argument is not a constant or this is its first
184 ** call) then the result for that argument is 0. If there is a prior
185 ** registration, the result for that argument is 1. The overall result
186 ** is the individual argument results separated by spaces.
188 static void free_test_auxdata(void *p
) {sqlite3_free(p
);}
189 static void test_auxdata(
190 sqlite3_context
*pCtx
,
195 char *zRet
= testContextMalloc(pCtx
, nArg
*2);
197 memset(zRet
, 0, nArg
*2);
198 for(i
=0; i
<nArg
; i
++){
199 char const *z
= (char*)sqlite3_value_text(argv
[i
]);
202 char *zAux
= sqlite3_get_auxdata(pCtx
, i
);
205 assert( strcmp(zAux
,z
)==0 );
209 n
= (int)strlen(z
) + 1;
210 zAux
= testContextMalloc(pCtx
, n
);
213 sqlite3_set_auxdata(pCtx
, i
, zAux
, free_test_auxdata
);
218 sqlite3_result_text(pCtx
, zRet
, 2*nArg
-1, free_test_auxdata
);
222 ** A function to test error reporting from user functions. This function
223 ** returns a copy of its first argument as the error message. If the
224 ** second argument exists, it becomes the error code.
226 static void test_error(
227 sqlite3_context
*pCtx
,
231 sqlite3_result_error(pCtx
, (char*)sqlite3_value_text(argv
[0]), -1);
233 sqlite3_result_error_code(pCtx
, sqlite3_value_int(argv
[1]));
238 ** Implementation of the counter(X) function. If X is an integer
239 ** constant, then the first invocation will return X. The second X+1.
240 ** and so forth. Can be used (for example) to provide a sequence number
243 static void counterFunc(
244 sqlite3_context
*pCtx
, /* Function context */
245 int nArg
, /* Number of function arguments */
246 sqlite3_value
**argv
/* Values for all function arguments */
248 int *pCounter
= (int*)sqlite3_get_auxdata(pCtx
, 0);
250 pCounter
= sqlite3_malloc( sizeof(*pCounter
) );
252 sqlite3_result_error_nomem(pCtx
);
255 *pCounter
= sqlite3_value_int(argv
[0]);
256 sqlite3_set_auxdata(pCtx
, 0, pCounter
, sqlite3_free
);
260 sqlite3_result_int(pCtx
, *pCounter
);
265 ** This function takes two arguments. It performance UTF-8/16 type
266 ** conversions on the first argument then returns a copy of the second
269 ** This function is used in cases such as the following:
271 ** SELECT test_isolation(x,x) FROM t1;
273 ** We want to verify that the type conversions that occur on the
274 ** first argument do not invalidate the second argument.
276 static void test_isolation(
277 sqlite3_context
*pCtx
,
281 #ifndef SQLITE_OMIT_UTF16
282 sqlite3_value_text16(argv
[0]);
283 sqlite3_value_text(argv
[0]);
284 sqlite3_value_text16(argv
[0]);
285 sqlite3_value_text(argv
[0]);
287 sqlite3_result_value(pCtx
, argv
[1]);
291 ** Invoke an SQL statement recursively. The function result is the
292 ** first column of the first row of the result set.
294 static void test_eval(
295 sqlite3_context
*pCtx
,
301 sqlite3
*db
= sqlite3_context_db_handle(pCtx
);
304 zSql
= (char*)sqlite3_value_text(argv
[0]);
305 rc
= sqlite3_prepare_v2(db
, zSql
, -1, &pStmt
, 0);
307 rc
= sqlite3_step(pStmt
);
308 if( rc
==SQLITE_ROW
){
309 sqlite3_result_value(pCtx
, sqlite3_column_value(pStmt
, 0));
311 rc
= sqlite3_finalize(pStmt
);
316 zErr
= sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db
));
317 sqlite3_result_text(pCtx
, zErr
, -1, sqlite3_free
);
318 sqlite3_result_error_code(pCtx
, rc
);
324 ** convert one character from hex to binary
326 static int testHexChar(char c
){
327 if( c
>='0' && c
<='9' ){
329 }else if( c
>='a' && c
<='f' ){
331 }else if( c
>='A' && c
<='F' ){
338 ** Convert hex to binary.
340 static void testHexToBin(const char *zIn
, char *zOut
){
341 while( zIn
[0] && zIn
[1] ){
342 *(zOut
++) = (testHexChar(zIn
[0])<<4) + testHexChar(zIn
[1]);
348 ** hex_to_utf16be(HEX)
350 ** Convert the input string from HEX into binary. Then return the
351 ** result using sqlite3_result_text16le().
353 #ifndef SQLITE_OMIT_UTF16
354 static void testHexToUtf16be(
355 sqlite3_context
*pCtx
,
363 n
= sqlite3_value_bytes(argv
[0]);
364 zIn
= (const char*)sqlite3_value_text(argv
[0]);
365 zOut
= sqlite3_malloc( n
/2 );
367 sqlite3_result_error_nomem(pCtx
);
369 testHexToBin(zIn
, zOut
);
370 sqlite3_result_text16be(pCtx
, zOut
, n
/2, sqlite3_free
);
378 ** Convert the input string from HEX into binary. Then return the
379 ** result using sqlite3_result_text16le().
381 static void testHexToUtf8(
382 sqlite3_context
*pCtx
,
390 n
= sqlite3_value_bytes(argv
[0]);
391 zIn
= (const char*)sqlite3_value_text(argv
[0]);
392 zOut
= sqlite3_malloc( n
/2 );
394 sqlite3_result_error_nomem(pCtx
);
396 testHexToBin(zIn
, zOut
);
397 sqlite3_result_text(pCtx
, zOut
, n
/2, sqlite3_free
);
402 ** hex_to_utf16le(HEX)
404 ** Convert the input string from HEX into binary. Then return the
405 ** result using sqlite3_result_text16le().
407 #ifndef SQLITE_OMIT_UTF16
408 static void testHexToUtf16le(
409 sqlite3_context
*pCtx
,
417 n
= sqlite3_value_bytes(argv
[0]);
418 zIn
= (const char*)sqlite3_value_text(argv
[0]);
419 zOut
= sqlite3_malloc( n
/2 );
421 sqlite3_result_error_nomem(pCtx
);
423 testHexToBin(zIn
, zOut
);
424 sqlite3_result_text16le(pCtx
, zOut
, n
/2, sqlite3_free
);
430 ** SQL function: real2hex(X)
432 ** If argument X is a real number, then convert it into a string which is
433 ** the big-endian hexadecimal representation of the ieee754 encoding of
434 ** that number. If X is not a real number, return NULL.
436 static void real2hex(
437 sqlite3_context
*context
,
450 bigEndian
= v
.x
[0]==0;
451 v
.r
= sqlite3_value_double(argv
[0]);
454 zOut
[i
*2] = "0123456789abcdef"[v
.x
[i
]>>4];
455 zOut
[i
*2+1] = "0123456789abcdef"[v
.x
[i
]&0xf];
457 zOut
[14-i
*2] = "0123456789abcdef"[v
.x
[i
]>>4];
458 zOut
[14-i
*2+1] = "0123456789abcdef"[v
.x
[i
]&0xf];
462 sqlite3_result_text(context
, zOut
, -1, SQLITE_TRANSIENT
);
466 ** test_extract(record, field)
468 ** This function implements an SQL user-function that accepts a blob
469 ** containing a formatted database record as the first argument. The
470 ** second argument is the index of the field within that record to
471 ** extract and return.
473 static void test_extract(
474 sqlite3_context
*context
,
478 sqlite3
*db
= sqlite3_context_db_handle(context
);
480 u8
*pEndHdr
; /* Points to one byte past record header */
481 u8
*pHdr
; /* Current point in record header */
482 u8
*pBody
; /* Current point in record data */
483 u64 nHdr
; /* Bytes in record header */
484 int iIdx
; /* Required field */
485 int iCurrent
= 0; /* Current field */
488 pRec
= (u8
*)sqlite3_value_blob(argv
[0]);
489 iIdx
= sqlite3_value_int(argv
[1]);
491 pHdr
= pRec
+ sqlite3GetVarint(pRec
, &nHdr
);
492 pBody
= pEndHdr
= &pRec
[nHdr
];
494 for(iCurrent
=0; pHdr
<pEndHdr
&& iCurrent
<=iIdx
; iCurrent
++){
498 memset(&mem
, 0, sizeof(mem
));
501 pHdr
+= sqlite3GetVarint(pHdr
, &iSerialType
);
502 pBody
+= sqlite3VdbeSerialGet(pBody
, (u32
)iSerialType
, &mem
);
504 if( iCurrent
==iIdx
){
505 sqlite3_result_value(context
, &mem
);
508 if( mem
.szMalloc
) sqlite3DbFree(db
, mem
.zMalloc
);
513 ** test_decode(record)
515 ** This function implements an SQL user-function that accepts a blob
516 ** containing a formatted database record as its only argument. It returns
517 ** a tcl list (type SQLITE_TEXT) containing each of the values stored
520 static void test_decode(
521 sqlite3_context
*context
,
525 sqlite3
*db
= sqlite3_context_db_handle(context
);
527 u8
*pEndHdr
; /* Points to one byte past record header */
528 u8
*pHdr
; /* Current point in record header */
529 u8
*pBody
; /* Current point in record data */
530 u64 nHdr
; /* Bytes in record header */
531 Tcl_Obj
*pRet
; /* Return value */
534 Tcl_IncrRefCount(pRet
);
537 pRec
= (u8
*)sqlite3_value_blob(argv
[0]);
539 pHdr
= pRec
+ sqlite3GetVarint(pRec
, &nHdr
);
540 pBody
= pEndHdr
= &pRec
[nHdr
];
541 while( pHdr
<pEndHdr
){
546 memset(&mem
, 0, sizeof(mem
));
549 pHdr
+= sqlite3GetVarint(pHdr
, &iSerialType
);
550 pBody
+= sqlite3VdbeSerialGet(pBody
, (u32
)iSerialType
, &mem
);
552 switch( sqlite3_value_type(&mem
) ){
554 pVal
= Tcl_NewStringObj((const char*)sqlite3_value_text(&mem
), -1);
559 '0', '1', '2', '3', '4', '5', '6', '7',
560 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
562 int n
= sqlite3_value_bytes(&mem
);
563 u8
*z
= (u8
*)sqlite3_value_blob(&mem
);
565 pVal
= Tcl_NewStringObj("x'", -1);
568 hex
[0] = hexdigit
[((z
[i
] >> 4) & 0x0F)];
569 hex
[1] = hexdigit
[(z
[i
] & 0x0F)];
571 Tcl_AppendStringsToObj(pVal
, hex
, 0);
573 Tcl_AppendStringsToObj(pVal
, "'", 0);
578 pVal
= Tcl_NewDoubleObj(sqlite3_value_double(&mem
));
582 pVal
= Tcl_NewWideIntObj(sqlite3_value_int64(&mem
));
586 pVal
= Tcl_NewStringObj("NULL", -1);
593 Tcl_ListObjAppendElement(0, pRet
, pVal
);
596 sqlite3DbFree(db
, mem
.zMalloc
);
600 sqlite3_result_text(context
, Tcl_GetString(pRet
), -1, SQLITE_TRANSIENT
);
601 Tcl_DecrRefCount(pRet
);
607 ** The implementation of scalar SQL function "test_zeroblob()". This is
608 ** similar to the built-in zeroblob() function, except that it does not
609 ** check that the integer parameter is within range before passing it
610 ** to sqlite3_result_zeroblob().
612 static void test_zeroblob(
613 sqlite3_context
*context
,
617 int nZero
= sqlite3_value_int(argv
[0]);
618 sqlite3_result_zeroblob(context
, nZero
);
621 /* test_getsubtype(V)
623 ** Return the subtype for value V.
625 static void test_getsubtype(
626 sqlite3_context
*context
,
630 sqlite3_result_int(context
, (int)sqlite3_value_subtype(argv
[0]));
633 /* test_setsubtype(V, T)
635 ** Return the value V with its subtype changed to T
637 static void test_setsubtype(
638 sqlite3_context
*context
,
642 sqlite3_result_value(context
, argv
[0]);
643 sqlite3_result_subtype(context
, (unsigned int)sqlite3_value_int(argv
[1]));
646 static int registerTestFunctions(
649 const sqlite3_api_routines
*pThunk
651 static const struct {
654 unsigned int eTextRep
; /* 1: UTF-16. 0: UTF-8 */
655 void (*xFunc
)(sqlite3_context
*,int,sqlite3_value
**);
657 { "randstr", 2, SQLITE_UTF8
, randStr
},
658 { "test_destructor", 1, SQLITE_UTF8
, test_destructor
},
659 #ifndef SQLITE_OMIT_UTF16
660 { "test_destructor16", 1, SQLITE_UTF8
, test_destructor16
},
661 { "hex_to_utf16be", 1, SQLITE_UTF8
, testHexToUtf16be
},
662 { "hex_to_utf16le", 1, SQLITE_UTF8
, testHexToUtf16le
},
664 { "hex_to_utf8", 1, SQLITE_UTF8
, testHexToUtf8
},
665 { "test_destructor_count", 0, SQLITE_UTF8
, test_destructor_count
},
666 { "test_auxdata", -1, SQLITE_UTF8
, test_auxdata
},
667 { "test_error", 1, SQLITE_UTF8
, test_error
},
668 { "test_error", 2, SQLITE_UTF8
, test_error
},
669 { "test_eval", 1, SQLITE_UTF8
, test_eval
},
670 { "test_isolation", 2, SQLITE_UTF8
, test_isolation
},
671 { "test_counter", 1, SQLITE_UTF8
, counterFunc
},
672 { "real2hex", 1, SQLITE_UTF8
, real2hex
},
673 { "test_decode", 1, SQLITE_UTF8
, test_decode
},
674 { "test_extract", 2, SQLITE_UTF8
, test_extract
},
675 { "test_zeroblob", 1, SQLITE_UTF8
|SQLITE_DETERMINISTIC
, test_zeroblob
},
676 { "test_getsubtype", 1, SQLITE_UTF8
, test_getsubtype
},
677 { "test_setsubtype", 2, SQLITE_UTF8
, test_setsubtype
},
681 for(i
=0; i
<sizeof(aFuncs
)/sizeof(aFuncs
[0]); i
++){
682 sqlite3_create_function(db
, aFuncs
[i
].zName
, aFuncs
[i
].nArg
,
683 aFuncs
[i
].eTextRep
, 0, aFuncs
[i
].xFunc
, 0, 0);
686 sqlite3_create_function(db
, "test_agg_errmsg16", 0, SQLITE_ANY
, 0, 0,
687 test_agg_errmsg16_step
, test_agg_errmsg16_final
);
693 ** TCLCMD: autoinstall_test_functions
695 ** Invoke this TCL command to use sqlite3_auto_extension() to cause
696 ** the standard set of test functions to be loaded into each new
697 ** database connection.
699 static int SQLITE_TCLAPI
autoinstall_test_funcs(
703 Tcl_Obj
*CONST objv
[]
705 extern int Md5_Register(sqlite3
*, char **, const sqlite3_api_routines
*);
706 int rc
= sqlite3_auto_extension((void(*)(void))registerTestFunctions
);
708 rc
= sqlite3_auto_extension((void(*)(void))Md5_Register
);
710 Tcl_SetObjResult(interp
, Tcl_NewIntObj(rc
));
715 ** A bogus step function and finalizer function.
717 static void tStep(sqlite3_context
*a
, int b
, sqlite3_value
**c
){}
718 static void tFinal(sqlite3_context
*a
){}
722 ** tclcmd: abuse_create_function
724 ** Make various calls to sqlite3_create_function that do not have valid
725 ** parameters. Verify that the error condition is detected and reported.
727 static int SQLITE_TCLAPI
abuse_create_function(
731 Tcl_Obj
*CONST objv
[]
733 extern int getDbPointer(Tcl_Interp
*, const char*, sqlite3
**);
738 if( getDbPointer(interp
, Tcl_GetString(objv
[1]), &db
) ) return TCL_ERROR
;
740 rc
= sqlite3_create_function(db
, "tx", 1, SQLITE_UTF8
, 0, tStep
,tStep
,tFinal
);
741 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
743 rc
= sqlite3_create_function(db
, "tx", 1, SQLITE_UTF8
, 0, tStep
, tStep
, 0);
744 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
746 rc
= sqlite3_create_function(db
, "tx", 1, SQLITE_UTF8
, 0, tStep
, 0, tFinal
);
747 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
749 rc
= sqlite3_create_function(db
, "tx", 1, SQLITE_UTF8
, 0, 0, 0, tFinal
);
750 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
752 rc
= sqlite3_create_function(db
, "tx", 1, SQLITE_UTF8
, 0, 0, tStep
, 0);
753 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
755 rc
= sqlite3_create_function(db
, "tx", -2, SQLITE_UTF8
, 0, tStep
, 0, 0);
756 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
758 rc
= sqlite3_create_function(db
, "tx", 128, SQLITE_UTF8
, 0, tStep
, 0, 0);
759 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
761 rc
= sqlite3_create_function(db
, "funcxx"
762 "_123456789_123456789_123456789_123456789_123456789"
763 "_123456789_123456789_123456789_123456789_123456789"
764 "_123456789_123456789_123456789_123456789_123456789"
765 "_123456789_123456789_123456789_123456789_123456789"
766 "_123456789_123456789_123456789_123456789_123456789",
767 1, SQLITE_UTF8
, 0, tStep
, 0, 0);
768 if( rc
!=SQLITE_MISUSE
) goto abuse_err
;
770 /* This last function registration should actually work. Generate
771 ** a no-op function (that always returns NULL) and which has the
772 ** maximum-length function name and the maximum number of parameters.
774 sqlite3_limit(db
, SQLITE_LIMIT_FUNCTION_ARG
, 10000);
775 mxArg
= sqlite3_limit(db
, SQLITE_LIMIT_FUNCTION_ARG
, -1);
776 rc
= sqlite3_create_function(db
, "nullx"
777 "_123456789_123456789_123456789_123456789_123456789"
778 "_123456789_123456789_123456789_123456789_123456789"
779 "_123456789_123456789_123456789_123456789_123456789"
780 "_123456789_123456789_123456789_123456789_123456789"
781 "_123456789_123456789_123456789_123456789_123456789",
782 mxArg
, SQLITE_UTF8
, 0, tStep
, 0, 0);
783 if( rc
!=SQLITE_OK
) goto abuse_err
;
788 Tcl_AppendResult(interp
, "sqlite3_create_function abused test failed",
795 ** Register commands with the TCL interpreter.
797 int Sqlitetest_func_Init(Tcl_Interp
*interp
){
800 Tcl_ObjCmdProc
*xProc
;
802 { "autoinstall_test_functions", autoinstall_test_funcs
},
803 { "abuse_create_function", abuse_create_function
},
806 extern int Md5_Register(sqlite3
*, char **, const sqlite3_api_routines
*);
808 for(i
=0; i
<sizeof(aObjCmd
)/sizeof(aObjCmd
[0]); i
++){
809 Tcl_CreateObjCommand(interp
, aObjCmd
[i
].zName
, aObjCmd
[i
].xProc
, 0, 0);
811 sqlite3_initialize();
812 sqlite3_auto_extension((void(*)(void))registerTestFunctions
);
813 sqlite3_auto_extension((void(*)(void))Md5_Register
);