/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** Code for testing all sorts of SQLite interfaces. This code

** is not included in the SQLite library. It is used for automated

** testing of the SQLite library.

*/

#include "sqliteInt.h"

#include "tcl.h"

#include <stdlib.h>

#include <string.h>

/*

** This is a copy of the first part of the SqliteDb structure in

** tclsqlite.c. We need it here so that the get_sqlite_pointer routine

** can extract the sqlite3* pointer from an existing Tcl SQLite

** connection.

*/

struct SqliteDb {

sqlite3 *db;

};

/*

** Convert text generated by the "%p" conversion format back into

** a pointer.

*/

static int testHexToInt(int h){

if( h>='0' && h<='9' ){

return h - '0';

}else if( h>='a' && h<='f' ){

return h - 'a' + 10;

}else{

assert( h>='A' && h<='F' );

return h - 'A' + 10;

}

}

void *sqlite3TestTextToPtr(const char *z){

void *p;

u64 v;

u32 v2;

if( z[0]=='0' && z[1]=='x' ){

z += 2;

}

v = 0;

while( *z ){

v = (v<<4) + testHexToInt(*z);

z++;

}

if( sizeof(p)==sizeof(v) ){

memcpy(&p, &v, sizeof(p));

}else{

assert( sizeof(p)==sizeof(v2) );

v2 = (u32)v;

memcpy(&p, &v2, sizeof(p));

}

return p;

}

/*

** A TCL command that returns the address of the sqlite* pointer

** for an sqlite connection instance. Bad things happen if the

** input is not an sqlite connection.

*/

static int get_sqlite_pointer(

void * clientData,

Tcl_Interp *interp,

int objc,

Tcl_Obj *CONST objv[]

){

struct SqliteDb *p;

Tcl_CmdInfo cmdInfo;

char zBuf[100];

if( objc!=2 ){

Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION");

return TCL_ERROR;

}

if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){

Tcl_AppendResult(interp, "command not found: ",

Tcl_GetString(objv[1]), (char*)0);

return TCL_ERROR;

}

p = (struct SqliteDb*)cmdInfo.objClientData;

sprintf(zBuf, "%p", p->db);

if( strncmp(zBuf,"0x",2) ){

sprintf(zBuf, "0x%p", p->db);

}

Tcl_AppendResult(interp, zBuf, 0);

return TCL_OK;

}

/*

** Decode a pointer to an sqlite3 object.

*/

int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){

struct SqliteDb *p;

Tcl_CmdInfo cmdInfo;

if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){

p = (struct SqliteDb*)cmdInfo.objClientData;

*ppDb = p->db;

}else{

*ppDb = (sqlite3*)sqlite3TestTextToPtr(zA);

}

return TCL_OK;

}

const char *sqlite3TestErrorName(int rc){

const char *zName = 0;

switch( rc ){

case SQLITE_OK: zName = "SQLITE_OK"; break;

case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;

case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;

case SQLITE_PERM: zName = "SQLITE_PERM"; break;

case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;

case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;

case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;

case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;

case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;

case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;

case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;

case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;

case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;

case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;

case SQLITE_FULL: zName = "SQLITE_FULL"; break;

case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;

case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;

case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;

case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;

case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;

case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;

case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;

case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;

case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;

case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;

case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;

case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;

case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;

case SQLITE_ROW: zName = "SQLITE_ROW"; break;

case SQLITE_DONE: zName = "SQLITE_DONE"; break;

case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;

case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;

case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;

case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;

case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;

case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;

case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;

case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;

case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;

case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;

case SQLITE_IOERR_BLOCKED: zName = "SQLITE_IOERR_BLOCKED"; break;

case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;

case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;

case SQLITE_IOERR_CHECKRESERVEDLOCK:

zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;

case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;

default: zName = "SQLITE_Unknown"; break;

}

return zName;

}

#define t1ErrorName sqlite3TestErrorName

/*

** Convert an sqlite3_stmt* into an sqlite3*. This depends on the

** fact that the sqlite3* is the first field in the Vdbe structure.

*/

#define StmtToDb(X) sqlite3_db_handle(X)

/*

** Check a return value to make sure it agrees with the results

** from sqlite3_errcode.

*/

int sqlite3TestErrCode(Tcl_Interp *interp, sqlite3 *db, int rc){

if( sqlite3_threadsafe()==0 && rc!=SQLITE_MISUSE && rc!=SQLITE_OK

&& sqlite3_errcode(db)!=rc ){

char zBuf[200];

int r2 = sqlite3_errcode(db);

sprintf(zBuf, "error code %s (%d) does not match sqlite3_errcode %s (%d)",

t1ErrorName(rc), rc, t1ErrorName(r2), r2);

Tcl_ResetResult(interp);

Tcl_AppendResult(interp, zBuf, 0);

return 1;

}

return 0;

}

/*

** Decode a pointer to an sqlite3_stmt object.

*/

static int getStmtPointer(

Tcl_Interp *interp,

const char *zArg,

sqlite3_stmt **ppStmt

){

*ppStmt = (sqlite3_stmt*)sqlite3TestTextToPtr(zArg);

return TCL_OK;

}

/*

** Generate a text representation of a pointer that can be understood

** by the getDbPointer and getVmPointer routines above.

**

** The problem is, on some machines (Solaris) if you do a printf with

** "%p" you cannot turn around and do a scanf with the same "%p" and

** get your pointer back. You have to prepend a "0x" before it will

** work. Or at least that is what is reported to me (drh). But this

** behavior varies from machine to machine. The solution used her is

** to test the string right after it is generated to see if it can be

** understood by scanf, and if not, try prepending an "0x" to see if

** that helps. If nothing works, a fatal error is generated.

*/

int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){

sqlite3_snprintf(100, zPtr, "%p", p);

return TCL_OK;

}

/*

** The callback routine for sqlite3_exec_printf().

*/

static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){

Tcl_DString *str = (Tcl_DString*)pArg;

int i;

if( Tcl_DStringLength(str)==0 ){

for(i=0; i<argc; i++){

Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL");

}

}

for(i=0; i<argc; i++){

Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL");

}

return 0;

}

/*

** The I/O tracing callback.

*/

#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)

static FILE *iotrace_file = 0;

static void io_trace_callback(const char *zFormat, ...){

va_list ap;

va_start(ap, zFormat);

vfprintf(iotrace_file, zFormat, ap);

va_end(ap);

fflush(iotrace_file);

}

#endif

/*

** Usage: io_trace FILENAME

**

** Turn I/O tracing on or off. If FILENAME is not an empty string,

** I/O tracing begins going into FILENAME. If FILENAME is an empty

** string, I/O tracing is turned off.

*/

static int test_io_trace(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)

if( argc!=2 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" FILENAME\"", 0);

return TCL_ERROR;

}

if( iotrace_file ){

if( iotrace_file!=stdout && iotrace_file!=stderr ){

fclose(iotrace_file);

}

iotrace_file = 0;

sqlite3IoTrace = 0;

}

if( argv[1][0] ){

if( strcmp(argv[1],"stdout")==0 ){

iotrace_file = stdout;

}else if( strcmp(argv[1],"stderr")==0 ){

iotrace_file = stderr;

}else{

iotrace_file = fopen(argv[1], "w");

}

sqlite3IoTrace = io_trace_callback;

}

#endif

return TCL_OK;

}

/*

** Usage: sqlite3_exec_printf DB FORMAT STRING

**

** Invoke the sqlite3_exec_printf() interface using the open database

** DB. The SQL is the string FORMAT. The format string should contain

** one %s or %q. STRING is the value inserted into %s or %q.

*/

static int test_exec_printf(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

Tcl_DString str;

int rc;

char *zErr = 0;

char *zSql;

char zBuf[30];

if( argc!=4 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB FORMAT STRING", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

Tcl_DStringInit(&str);

zSql = sqlite3_mprintf(argv[2], argv[3]);

rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);

sqlite3_free(zSql);

sprintf(zBuf, "%d", rc);

Tcl_AppendElement(interp, zBuf);

Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);

Tcl_DStringFree(&str);

if( zErr ) sqlite3_free(zErr);

if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

return TCL_OK;

}

/*

** Usage: sqlite3_exec_hex DB HEX

**

** Invoke the sqlite3_exec() on a string that is obtained by translating

** HEX into ASCII. Most characters are translated as is. %HH becomes

** a hex character.

*/

static int test_exec_hex(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

Tcl_DString str;

int rc, i, j;

char *zErr = 0;

char *zHex;

char zSql[500];

char zBuf[30];

if( argc!=3 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB HEX", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

zHex = argv[2];

for(i=j=0; i<sizeof(zSql) && zHex[j]; i++, j++){

if( zHex[j]=='%' && zHex[j+2] && zHex[j+2] ){

zSql[i] = (testHexToInt(zHex[j+1])<<4) + testHexToInt(zHex[j+2]);

j += 2;

}else{

zSql[i] = zHex[j];

}

}

zSql[i] = 0;

Tcl_DStringInit(&str);

rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);

sprintf(zBuf, "%d", rc);

Tcl_AppendElement(interp, zBuf);

Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);

Tcl_DStringFree(&str);

if( zErr ) sqlite3_free(zErr);

if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

return TCL_OK;

}

/*

** Usage: db_enter DB

** db_leave DB

**

** Enter or leave the mutex on a database connection.

*/

static int db_enter(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

if( argc!=2 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

sqlite3_mutex_enter(db->mutex);

return TCL_OK;

}

static int db_leave(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

if( argc!=2 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

sqlite3_mutex_leave(db->mutex);

return TCL_OK;

}

/*

** Usage: sqlite3_exec DB SQL

**

** Invoke the sqlite3_exec interface using the open database DB

*/

static int test_exec(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

Tcl_DString str;

int rc;

char *zErr = 0;

char *zSql;

int i, j;

char zBuf[30];

if( argc!=3 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB SQL", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

Tcl_DStringInit(&str);

zSql = sqlite3_mprintf("%s", argv[2]);

for(i=j=0; zSql[i];){

if( zSql[i]=='%' ){

zSql[j++] = (testHexToInt(zSql[i+1])<<4) + testHexToInt(zSql[i+2]);

i += 3;

}else{

zSql[j++] = zSql[i++];

}

}

zSql[j] = 0;

rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);

sqlite3_free(zSql);

sprintf(zBuf, "%d", rc);

Tcl_AppendElement(interp, zBuf);

Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);

Tcl_DStringFree(&str);

if( zErr ) sqlite3_free(zErr);

if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

return TCL_OK;

}

/*

** Usage: sqlite3_exec_nr DB SQL

**

** Invoke the sqlite3_exec interface using the open database DB. Discard

** all results

*/

static int test_exec_nr(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

int rc;

char *zErr = 0;

if( argc!=3 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB SQL", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);

if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

return TCL_OK;

}

/*

** Usage: sqlite3_mprintf_z_test SEPARATOR ARG0 ARG1 ...

**

** Test the %z format of sqlite_mprintf(). Use multiple mprintf() calls to

** concatenate arg0 through argn using separator as the separator.

** Return the result.

*/

static int test_mprintf_z(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

char *zResult = 0;

int i;

for(i=2; i<argc && (i==2 || zResult); i++){

zResult = sqlite3_mprintf("%z%s%s", zResult, argv[1], argv[i]);

}

Tcl_AppendResult(interp, zResult, 0);

sqlite3_free(zResult);

return TCL_OK;

}

/*

** Usage: sqlite3_mprintf_n_test STRING

**

** Test the %n format of sqlite_mprintf(). Return the length of the

** input string.

*/

static int test_mprintf_n(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

char *zStr;

int n = 0;

zStr = sqlite3_mprintf("%s%n", argv[1], &n);

sqlite3_free(zStr);

Tcl_SetObjResult(interp, Tcl_NewIntObj(n));

return TCL_OK;

}

/*

** Usage: sqlite3_snprintf_int SIZE FORMAT INT

**

** Test the of sqlite3_snprintf() routine. SIZE is the size of the

** output buffer in bytes. The maximum size is 100. FORMAT is the

** format string. INT is a single integer argument. The FORMAT

** string must require no more than this one integer argument. If

** You pass in a format string that requires more than one argument,

** bad things will happen.

*/

static int test_snprintf_int(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

char zStr[100];

int n = atoi(argv[1]);

const char *zFormat = argv[2];

int a1 = atoi(argv[3]);

if( n>sizeof(zStr) ) n = sizeof(zStr);

sqlite3_snprintf(sizeof(zStr), zStr, "abcdefghijklmnopqrstuvwxyz");

sqlite3_snprintf(n, zStr, zFormat, a1);

Tcl_AppendResult(interp, zStr, 0);

return TCL_OK;

}

#ifndef SQLITE_OMIT_GET_TABLE

/*

** Usage: sqlite3_get_table_printf DB FORMAT STRING ?--no-counts?

**

** Invoke the sqlite3_get_table_printf() interface using the open database

** DB. The SQL is the string FORMAT. The format string should contain

** one %s or %q. STRING is the value inserted into %s or %q.

*/

static int test_get_table_printf(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

Tcl_DString str;

int rc;

char *zErr = 0;

int nRow, nCol;

char **aResult;

int i;

char zBuf[30];

char *zSql;

int resCount = -1;

if( argc==5 ){

if( Tcl_GetInt(interp, argv[4], &resCount) ) return TCL_ERROR;

}

if( argc!=4 && argc!=5 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB FORMAT STRING ?COUNT?", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

Tcl_DStringInit(&str);

zSql = sqlite3_mprintf(argv[2],argv[3]);

if( argc==5 ){

rc = sqlite3_get_table(db, zSql, &aResult, 0, 0, &zErr);

}else{

rc = sqlite3_get_table(db, zSql, &aResult, &nRow, &nCol, &zErr);

resCount = (nRow+1)*nCol;

}

sqlite3_free(zSql);

sprintf(zBuf, "%d", rc);

Tcl_AppendElement(interp, zBuf);

if( rc==SQLITE_OK ){

if( argc==4 ){

sprintf(zBuf, "%d", nRow);

Tcl_AppendElement(interp, zBuf);

sprintf(zBuf, "%d", nCol);

Tcl_AppendElement(interp, zBuf);

}

for(i=0; i<resCount; i++){

Tcl_AppendElement(interp, aResult[i] ? aResult[i] : "NULL");

}

}else{

Tcl_AppendElement(interp, zErr);

}

sqlite3_free_table(aResult);

if( zErr ) sqlite3_free(zErr);

if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

return TCL_OK;

}

#endif /* SQLITE_OMIT_GET_TABLE */

/*

** Usage: sqlite3_last_insert_rowid DB

**

** Returns the integer ROWID of the most recent insert.

*/

static int test_last_rowid(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

char zBuf[30];

if( argc!=2 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

sprintf(zBuf, "%lld", sqlite3_last_insert_rowid(db));

Tcl_AppendResult(interp, zBuf, 0);

return SQLITE_OK;

}

/*

** Usage: sqlite3_key DB KEY

**

** Set the codec key.

*/

static int test_key(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

const char *zKey;

int nKey;

if( argc!=3 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" FILENAME\"", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

zKey = argv[2];

nKey = strlen(zKey);

#ifdef SQLITE_HAS_CODEC

sqlite3_key(db, zKey, nKey);

#endif

return TCL_OK;

}

/*

** Usage: sqlite3_rekey DB KEY

**

** Change the codec key.

*/

static int test_rekey(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

const char *zKey;

int nKey;

if( argc!=3 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" FILENAME\"", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

zKey = argv[2];

nKey = strlen(zKey);

#ifdef SQLITE_HAS_CODEC

sqlite3_rekey(db, zKey, nKey);

#endif

return TCL_OK;

}

/*

** Usage: sqlite3_close DB

**

** Closes the database opened by sqlite3_open.

*/

static int sqlite_test_close(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

sqlite3 *db;

int rc;

if( argc!=2 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" FILENAME\"", 0);

return TCL_ERROR;

}

if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

rc = sqlite3_close(db);

Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);

return TCL_OK;

}

/*

** Implementation of the x_coalesce() function.

** Return the first argument non-NULL argument.

*/

static void t1_ifnullFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int i;

for(i=0; i<argc; i++){

if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){

int n = sqlite3_value_bytes(argv[i]);

sqlite3_result_text(context, (char*)sqlite3_value_text(argv[i]),

n, SQLITE_TRANSIENT);

break;

}

}

}

/*

** These are test functions. hex8() interprets its argument as

** UTF8 and returns a hex encoding. hex16le() interprets its argument

** as UTF16le and returns a hex encoding.

*/

static void hex8Func(sqlite3_context *p, int argc, sqlite3_value **argv){

const unsigned char *z;

int i;

char zBuf[200];

z = sqlite3_value_text(argv[0]);

for(i=0; i<sizeof(zBuf)/2 - 2 && z[i]; i++){

sprintf(&zBuf[i*2], "%02x", z[i]&0xff);

}

zBuf[i*2] = 0;

sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);

}

#ifndef SQLITE_OMIT_UTF16

static void hex16Func(sqlite3_context *p, int argc, sqlite3_value **argv){

const unsigned short int *z;

int i;

char zBuf[400];

z = sqlite3_value_text16(argv[0]);

for(i=0; i<sizeof(zBuf)/4 - 4 && z[i]; i++){

sprintf(&zBuf[i*4], "%04x", z[i]&0xff);

}

zBuf[i*4] = 0;

sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);

}

#endif

/*

** A structure into which to accumulate text.

*/

struct dstr {

int nAlloc; /* Space allocated */

int nUsed; /* Space used */

char *z; /* The space */

};

/*

** Append text to a dstr

*/

static void dstrAppend(struct dstr *p, const char *z, int divider){

int n = strlen(z);

if( p->nUsed + n + 2 > p->nAlloc ){

char *zNew;

p->nAlloc = p->nAlloc*2 + n + 200;

zNew = sqlite3_realloc(p->z, p->nAlloc);

if( zNew==0 ){

sqlite3_free(p->z);

memset(p, 0, sizeof(*p));

return;

}

p->z = zNew;

}

if( divider && p->nUsed>0 ){

p->z[p->nUsed++] = divider;

}

memcpy(&p->z[p->nUsed], z, n+1);

p->nUsed += n;

}

/*

** Invoked for each callback from sqlite3ExecFunc

*/

static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){

struct dstr *p = (struct dstr*)pData;

int i;

for(i=0; i<argc; i++){

if( argv[i]==0 ){

dstrAppend(p, "NULL", ' ');

}else{

dstrAppend(p, argv[i], ' ');

}

}

return 0;

}

/*

** Implementation of the x_sqlite_exec() function. This function takes

** a single argument and attempts to execute that argument as SQL code.

** This is illegal and should set the SQLITE_MISUSE flag on the database.

**

** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec()

** from within a function call.

**

** This routine simulates the effect of having two threads attempt to

** use the same database at the same time.

*/

static void sqlite3ExecFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

struct dstr x;

memset(&x, 0, sizeof(x));

(void)sqlite3_exec((sqlite3*)sqlite3_user_data(context),

(char*)sqlite3_value_text(argv[0]),

execFuncCallback, &x, 0);

sqlite3_result_text(context, x.z, x.nUsed, SQLITE_TRANSIENT);

sqlite3_free(x.z);

}

/*

** Implementation of tkt2213func(), a scalar function that takes exactly

** one argument. It has two interesting features:

**

** * It calls sqlite3_value_text() 3 times on the argument sqlite3_value*.

** If the three pointers returned are not the same an SQL error is raised.

**

** * Otherwise it returns a copy of the text representation of its

** argument in such a way as the VDBE representation is a Mem* cell

** with the MEM_Term flag clear.

**

** Ticket #2213 can therefore be tested by evaluating the following

** SQL expression:

**

** tkt2213func(tkt2213func('a string'));

*/

static void tkt2213Function(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int nText;

unsigned char const *zText1;

unsigned char const *zText2;

unsigned char const *zText3;

nText = sqlite3_value_bytes(argv[0]);

zText1 = sqlite3_value_text(argv[0]);

zText2 = sqlite3_value_text(argv[0]);

zText3 = sqlite3_value_text(argv[0]);

if( zText1!=zText2 || zText2!=zText3 ){

sqlite3_result_error(context, "tkt2213 is not fixed", -1);

}else{

char *zCopy = (char *)sqlite3_malloc(nText);

memcpy(zCopy, zText1, nText);

sqlite3_result_text(context, zCopy, nText, sqlite3_free);

}

}

/*

** The following SQL function takes 4 arguments. The 2nd and

** 4th argument must be one of these strings: 'text', 'text16',

** or 'blob' corresponding to API functions

**

** sqlite3_value_text()

** sqlite3_value_text16()

** sqlite3_value_blob()

**

** The third argument is a string, either 'bytes' or 'bytes16' or 'noop',

** corresponding to APIs:

**

** sqlite3_value_bytes()

** sqlite3_value_bytes16()

** noop

**

** The APIs designated by the 2nd through 4th arguments are applied

** to the first argument in order. If the pointers returned by the

** second and fourth are different, this routine returns 1. Otherwise,

** this routine returns 0.

**

** This function is used to test to see when returned pointers from

** the _text(), _text16() and _blob() APIs become invalidated.

*/

static void ptrChngFunction(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const void *p1, *p2;

const char *zCmd;

if( argc!=4 ) return;

zCmd = (const char*)sqlite3_value_text(argv[1]);

if( zCmd==0 ) return;

if( strcmp(zCmd,"text")==0 ){

p1 = (const void*)sqlite3_value_text(argv[0]);

#ifndef SQLITE_OMIT_UTF16

}else if( strcmp(zCmd, "text16")==0 ){

p1 = (const void*)sqlite3_value_text16(argv[0]);

#endif

}else if( strcmp(zCmd, "blob")==0 ){

p1 = (const void*)sqlite3_value_blob(argv[0]);

}else{

return;

}

zCmd = (const char*)sqlite3_value_text(argv[2]);

if( zCmd==0 ) return;

if( strcmp(zCmd,"bytes")==0 ){

sqlite3_value_bytes(argv[0]);

#ifndef SQLITE_OMIT_UTF16

}else if( strcmp(zCmd, "bytes16")==0 ){

sqlite3_value_bytes16(argv[0]);

#endif

}else if( strcmp(zCmd, "noop")==0 ){

/* do nothing */

}else{

return;

}

zCmd = (const char*)sqlite3_value_text(argv[3]);

if( zCmd==0 ) return;

if( strcmp(zCmd,"text")==0 ){

p2 = (const void*)sqlite3_value_text(argv[0]);

#ifndef SQLITE_OMIT_UTF16

}else if( strcmp(zCmd, "text16")==0 ){

p2 = (const void*)sqlite3_value_text16(argv[0]);

#endif

}else if( strcmp(zCmd, "blob")==0 ){

p2 = (const void*)sqlite3_value_blob(argv[0]);

}else{

return;

}

sqlite3_result_int(context, p1!=p2);

}

/*

** Usage: sqlite_test_create_function DB

**

** Call the sqlite3_create_function API on the given database in order

** to create a function named "x_coalesce". This function does the same thing

** as the "coalesce" function. This function also registers an SQL function

** named "x_sqlite_exec" that invokes sqlite3_exec(). Invoking sqlite3_exec()

** in this way is illegal recursion and should raise an SQLITE_MISUSE error.

** The effect is similar to trying to use the same database connection from

** two threads at the same time.

**

** The original motivation for this routine was to be able to call the

** sqlite3_create_function function while a query is in progress in order

** to test the SQLITE_MISUSE detection logic.

*/

static int test_create_function(

void *NotUsed,

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int argc, /* Number of arguments */

char **argv /* Text of each argument */

){

int rc;

sqlite3 *db;

if( argc!=2 ){

Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

" DB\"", 0);