sl@0: /*
sl@0: ** 2008 March 19
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** Code for testing all sorts of SQLite interfaces.  This code
sl@0: ** implements new SQL functions used by the test scripts.
sl@0: **
sl@0: ** $Id: test_func.c,v 1.13 2008/08/28 02:26:07 drh Exp $
sl@0: */
sl@0: #include "sqlite3.h"
sl@0: #include "tcl.h"
sl@0: #include <stdlib.h>
sl@0: #include <string.h>
sl@0: #include <assert.h>
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Allocate nByte bytes of space using sqlite3_malloc(). If the
sl@0: ** allocation fails, call sqlite3_result_error_nomem() to notify
sl@0: ** the database handle that malloc() has failed.
sl@0: */
sl@0: static void *testContextMalloc(sqlite3_context *context, int nByte){
sl@0:   char *z = sqlite3_malloc(nByte);
sl@0:   if( !z && nByte>0 ){
sl@0:     sqlite3_result_error_nomem(context);
sl@0:   }
sl@0:   return z;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This function generates a string of random characters.  Used for
sl@0: ** generating test data.
sl@0: */
sl@0: static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
sl@0:   static const unsigned char zSrc[] = 
sl@0:      "abcdefghijklmnopqrstuvwxyz"
sl@0:      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sl@0:      "0123456789"
sl@0:      ".-!,:*^+=_|?/<> ";
sl@0:   int iMin, iMax, n, r, i;
sl@0:   unsigned char zBuf[1000];
sl@0: 
sl@0:   /* It used to be possible to call randstr() with any number of arguments,
sl@0:   ** but now it is registered with SQLite as requiring exactly 2.
sl@0:   */
sl@0:   assert(argc==2);
sl@0: 
sl@0:   iMin = sqlite3_value_int(argv[0]);
sl@0:   if( iMin<0 ) iMin = 0;
sl@0:   if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
sl@0:   iMax = sqlite3_value_int(argv[1]);
sl@0:   if( iMax<iMin ) iMax = iMin;
sl@0:   if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
sl@0:   n = iMin;
sl@0:   if( iMax>iMin ){
sl@0:     sqlite3_randomness(sizeof(r), &r);
sl@0:     r &= 0x7fffffff;
sl@0:     n += r%(iMax + 1 - iMin);
sl@0:   }
sl@0:   assert( n<sizeof(zBuf) );
sl@0:   sqlite3_randomness(n, zBuf);
sl@0:   for(i=0; i<n; i++){
sl@0:     zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
sl@0:   }
sl@0:   zBuf[n] = 0;
sl@0:   sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The following two SQL functions are used to test returning a text
sl@0: ** result with a destructor. Function 'test_destructor' takes one argument
sl@0: ** and returns the same argument interpreted as TEXT. A destructor is
sl@0: ** passed with the sqlite3_result_text() call.
sl@0: **
sl@0: ** SQL function 'test_destructor_count' returns the number of outstanding 
sl@0: ** allocations made by 'test_destructor';
sl@0: **
sl@0: ** WARNING: Not threadsafe.
sl@0: */
sl@0: static int test_destructor_count_var = 0;
sl@0: static void destructor(void *p){
sl@0:   char *zVal = (char *)p;
sl@0:   assert(zVal);
sl@0:   zVal--;
sl@0:   sqlite3_free(zVal);
sl@0:   test_destructor_count_var--;
sl@0: }
sl@0: static void test_destructor(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   char *zVal;
sl@0:   int len;
sl@0:   
sl@0:   test_destructor_count_var++;
sl@0:   assert( nArg==1 );
sl@0:   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
sl@0:   len = sqlite3_value_bytes(argv[0]); 
sl@0:   zVal = testContextMalloc(pCtx, len+3);
sl@0:   if( !zVal ){
sl@0:     return;
sl@0:   }
sl@0:   zVal[len+1] = 0;
sl@0:   zVal[len+2] = 0;
sl@0:   zVal++;
sl@0:   memcpy(zVal, sqlite3_value_text(argv[0]), len);
sl@0:   sqlite3_result_text(pCtx, zVal, -1, destructor);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: static void test_destructor16(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   char *zVal;
sl@0:   int len;
sl@0:   
sl@0:   test_destructor_count_var++;
sl@0:   assert( nArg==1 );
sl@0:   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
sl@0:   len = sqlite3_value_bytes16(argv[0]); 
sl@0:   zVal = testContextMalloc(pCtx, len+3);
sl@0:   if( !zVal ){
sl@0:     return;
sl@0:   }
sl@0:   zVal[len+1] = 0;
sl@0:   zVal[len+2] = 0;
sl@0:   zVal++;
sl@0:   memcpy(zVal, sqlite3_value_text16(argv[0]), len);
sl@0:   sqlite3_result_text16(pCtx, zVal, -1, destructor);
sl@0: }
sl@0: #endif
sl@0: static void test_destructor_count(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   sqlite3_result_int(pCtx, test_destructor_count_var);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
sl@0: ** interface.
sl@0: **
sl@0: ** The test_auxdata() SQL function attempts to register each of its arguments
sl@0: ** as auxiliary data.  If there are no prior registrations of aux data for
sl@0: ** that argument (meaning the argument is not a constant or this is its first
sl@0: ** call) then the result for that argument is 0.  If there is a prior
sl@0: ** registration, the result for that argument is 1.  The overall result
sl@0: ** is the individual argument results separated by spaces.
sl@0: */
sl@0: static void free_test_auxdata(void *p) {sqlite3_free(p);}
sl@0: static void test_auxdata(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   int i;
sl@0:   char *zRet = testContextMalloc(pCtx, nArg*2);
sl@0:   if( !zRet ) return;
sl@0:   memset(zRet, 0, nArg*2);
sl@0:   for(i=0; i<nArg; i++){
sl@0:     char const *z = (char*)sqlite3_value_text(argv[i]);
sl@0:     if( z ){
sl@0:       int n;
sl@0:       char *zAux = sqlite3_get_auxdata(pCtx, i);
sl@0:       if( zAux ){
sl@0:         zRet[i*2] = '1';
sl@0:         assert( strcmp(zAux,z)==0 );
sl@0:       }else {
sl@0:         zRet[i*2] = '0';
sl@0:       }
sl@0:       n = strlen(z) + 1;
sl@0:       zAux = testContextMalloc(pCtx, n);
sl@0:       if( zAux ){
sl@0:         memcpy(zAux, z, n);
sl@0:         sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
sl@0:       }
sl@0:       zRet[i*2+1] = ' ';
sl@0:     }
sl@0:   }
sl@0:   sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** A function to test error reporting from user functions. This function
sl@0: ** returns a copy of its first argument as the error message.  If the
sl@0: ** second argument exists, it becomes the error code.
sl@0: */
sl@0: static void test_error(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1);
sl@0:   if( nArg==2 ){
sl@0:     sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1]));
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Implementation of the counter(X) function.  If X is an integer
sl@0: ** constant, then the first invocation will return X.  The second X+1.
sl@0: ** and so forth.  Can be used (for example) to provide a sequence number
sl@0: ** in a result set.
sl@0: */
sl@0: static void counterFunc(
sl@0:   sqlite3_context *pCtx,   /* Function context */
sl@0:   int nArg,                /* Number of function arguments */
sl@0:   sqlite3_value **argv     /* Values for all function arguments */
sl@0: ){
sl@0:   int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0);
sl@0:   if( pCounter==0 ){
sl@0:     pCounter = sqlite3_malloc( sizeof(*pCounter) );
sl@0:     if( pCounter==0 ){
sl@0:       sqlite3_result_error_nomem(pCtx);
sl@0:       return;
sl@0:     }
sl@0:     *pCounter = sqlite3_value_int(argv[0]);
sl@0:     sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free);
sl@0:   }else{
sl@0:     ++*pCounter;
sl@0:   }
sl@0:   sqlite3_result_int(pCtx, *pCounter);
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** This function takes two arguments.  It performance UTF-8/16 type
sl@0: ** conversions on the first argument then returns a copy of the second
sl@0: ** argument.
sl@0: **
sl@0: ** This function is used in cases such as the following:
sl@0: **
sl@0: **      SELECT test_isolation(x,x) FROM t1;
sl@0: **
sl@0: ** We want to verify that the type conversions that occur on the
sl@0: ** first argument do not invalidate the second argument.
sl@0: */
sl@0: static void test_isolation(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0:   sqlite3_value_text16(argv[0]);
sl@0:   sqlite3_value_text(argv[0]);
sl@0:   sqlite3_value_text16(argv[0]);
sl@0:   sqlite3_value_text(argv[0]);
sl@0: #endif
sl@0:   sqlite3_result_value(pCtx, argv[1]);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Invoke an SQL statement recursively.  The function result is the 
sl@0: ** first column of the first row of the result set.
sl@0: */
sl@0: static void test_eval(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int nArg,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   sqlite3_stmt *pStmt;
sl@0:   int rc;
sl@0:   sqlite3 *db = sqlite3_context_db_handle(pCtx);
sl@0:   const char *zSql;
sl@0: 
sl@0:   zSql = (char*)sqlite3_value_text(argv[0]);
sl@0:   rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     rc = sqlite3_step(pStmt);
sl@0:     if( rc==SQLITE_ROW ){
sl@0:       sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));
sl@0:     }
sl@0:     rc = sqlite3_finalize(pStmt);
sl@0:   }
sl@0:   if( rc ){
sl@0:     char *zErr;
sl@0:     assert( pStmt==0 );
sl@0:     zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));
sl@0:     sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);
sl@0:     sqlite3_result_error_code(pCtx, rc);
sl@0:   }
sl@0: }
sl@0: 
sl@0: 
sl@0: static int registerTestFunctions(sqlite3 *db){
sl@0:   static const struct {
sl@0:      char *zName;
sl@0:      signed char nArg;
sl@0:      unsigned char eTextRep; /* 1: UTF-16.  0: UTF-8 */
sl@0:      void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
sl@0:   } aFuncs[] = {
sl@0:     { "randstr",               2, SQLITE_UTF8, randStr    },
sl@0:     { "test_destructor",       1, SQLITE_UTF8, test_destructor},
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0:     { "test_destructor16",     1, SQLITE_UTF8, test_destructor16},
sl@0: #endif
sl@0:     { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
sl@0:     { "test_auxdata",         -1, SQLITE_UTF8, test_auxdata},
sl@0:     { "test_error",            1, SQLITE_UTF8, test_error},
sl@0:     { "test_error",            2, SQLITE_UTF8, test_error},
sl@0:     { "test_eval",             1, SQLITE_UTF8, test_eval},
sl@0:     { "test_isolation",        2, SQLITE_UTF8, test_isolation},
sl@0:     { "test_counter",          1, SQLITE_UTF8, counterFunc},
sl@0:   };
sl@0:   int i;
sl@0: 
sl@0:   for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
sl@0:     sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
sl@0:         aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
sl@0:   }
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** TCLCMD:  autoinstall_test_functions
sl@0: **
sl@0: ** Invoke this TCL command to use sqlite3_auto_extension() to cause
sl@0: ** the standard set of test functions to be loaded into each new
sl@0: ** database connection.
sl@0: */
sl@0: static int autoinstall_test_funcs(
sl@0:   void * clientData,
sl@0:   Tcl_Interp *interp,
sl@0:   int objc,
sl@0:   Tcl_Obj *CONST objv[]
sl@0: ){
sl@0:   extern int Md5_Register(sqlite3*);
sl@0:   int rc = sqlite3_auto_extension((void*)registerTestFunctions);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     rc = sqlite3_auto_extension((void*)Md5_Register);
sl@0:   }
sl@0:   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
sl@0:   return TCL_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** A bogus step function and finalizer function.
sl@0: */
sl@0: static void tStep(sqlite3_context *a, int b, sqlite3_value **c){}
sl@0: static void tFinal(sqlite3_context *a){}
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** tclcmd:  abuse_create_function
sl@0: **
sl@0: ** Make various calls to sqlite3_create_function that do not have valid
sl@0: ** parameters.  Verify that the error condition is detected and reported.
sl@0: */
sl@0: static int abuse_create_function(
sl@0:   void * clientData,
sl@0:   Tcl_Interp *interp,
sl@0:   int objc,
sl@0:   Tcl_Obj *CONST objv[]
sl@0: ){
sl@0:   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
sl@0:   sqlite3 *db;
sl@0:   int rc;
sl@0:   int mxArg;
sl@0: 
sl@0:   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   rc = sqlite3_create_function(db, "funcxx"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789",
sl@0:        1, SQLITE_UTF8, 0, tStep, 0, 0);
sl@0:   if( rc!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err;
sl@0:   if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err;
sl@0: 
sl@0:   /* This last function registration should actually work.  Generate
sl@0:   ** a no-op function (that always returns NULL) and which has the
sl@0:   ** maximum-length function name and the maximum number of parameters.
sl@0:   */
sl@0:   sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000);
sl@0:   mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1);
sl@0:   rc = sqlite3_create_function(db, "nullx"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789"
sl@0:        "_123456789_123456789_123456789_123456789_123456789",
sl@0:        mxArg, SQLITE_UTF8, 0, tStep, 0, 0);
sl@0:   if( rc!=SQLITE_OK ) goto abuse_err;
sl@0:                                 
sl@0:   return TCL_OK;
sl@0: 
sl@0: abuse_err:
sl@0:   Tcl_AppendResult(interp, "sqlite3_create_function abused test failed", 
sl@0:                    (char*)0);
sl@0:   return TCL_ERROR;
sl@0: }
sl@0: 
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Register commands with the TCL interpreter.
sl@0: */
sl@0: int Sqlitetest_func_Init(Tcl_Interp *interp){
sl@0:   static struct {
sl@0:      char *zName;
sl@0:      Tcl_ObjCmdProc *xProc;
sl@0:   } aObjCmd[] = {
sl@0:      { "autoinstall_test_functions",    autoinstall_test_funcs },
sl@0:      { "abuse_create_function",         abuse_create_function  },
sl@0:   };
sl@0:   int i;
sl@0:   extern int Md5_Register(sqlite3*);
sl@0: 
sl@0:   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
sl@0:     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
sl@0:   }
sl@0:   sqlite3_initialize();
sl@0:   sqlite3_auto_extension((void*)registerTestFunctions);
sl@0:   sqlite3_auto_extension((void*)Md5_Register);
sl@0:   return TCL_OK;
sl@0: }