sl@0: /*
sl@0: ** 2006 June 10
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 the virtual table interfaces.  This code
sl@0: ** is not included in the SQLite library.  It is used for automated
sl@0: ** testing of the SQLite library.
sl@0: **
sl@0: ** $Id: test8.c,v 1.75 2008/08/31 00:29:08 shane Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #include "tcl.h"
sl@0: #include <stdlib.h>
sl@0: #include <string.h>
sl@0: 
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0: 
sl@0: typedef struct echo_vtab echo_vtab;
sl@0: typedef struct echo_cursor echo_cursor;
sl@0: 
sl@0: /*
sl@0: ** The test module defined in this file uses four global Tcl variables to
sl@0: ** commicate with test-scripts:
sl@0: **
sl@0: **     $::echo_module
sl@0: **     $::echo_module_sync_fail
sl@0: **     $::echo_module_begin_fail
sl@0: **     $::echo_module_cost
sl@0: **
sl@0: ** The variable ::echo_module is a list. Each time one of the following
sl@0: ** methods is called, one or more elements are appended to the list.
sl@0: ** This is used for automated testing of virtual table modules.
sl@0: **
sl@0: ** The ::echo_module_sync_fail variable is set by test scripts and read
sl@0: ** by code in this file. If it is set to the name of a real table in the
sl@0: ** the database, then all xSync operations on echo virtual tables that
sl@0: ** use the named table as a backing store will fail.
sl@0: */
sl@0: 
sl@0: /*
sl@0: ** Errors can be provoked within the following echo virtual table methods:
sl@0: **
sl@0: **   xBestIndex   xOpen     xFilter   xNext   
sl@0: **   xColumn      xRowid    xUpdate   xSync   
sl@0: **   xBegin       xRename
sl@0: **
sl@0: ** This is done by setting the global tcl variable:
sl@0: **
sl@0: **   echo_module_fail($method,$tbl)
sl@0: **
sl@0: ** where $method is set to the name of the virtual table method to fail
sl@0: ** (i.e. "xBestIndex") and $tbl is the name of the table being echoed (not
sl@0: ** the name of the virtual table, the name of the underlying real table).
sl@0: */
sl@0: 
sl@0: /* 
sl@0: ** An echo virtual-table object.
sl@0: **
sl@0: ** echo.vtab.aIndex is an array of booleans. The nth entry is true if 
sl@0: ** the nth column of the real table is the left-most column of an index
sl@0: ** (implicit or otherwise). In other words, if SQLite can optimize
sl@0: ** a query like "SELECT * FROM real_table WHERE col = ?".
sl@0: **
sl@0: ** Member variable aCol[] contains copies of the column names of the real
sl@0: ** table.
sl@0: */
sl@0: struct echo_vtab {
sl@0:   sqlite3_vtab base;
sl@0:   Tcl_Interp *interp;     /* Tcl interpreter containing debug variables */
sl@0:   sqlite3 *db;            /* Database connection */
sl@0: 
sl@0:   int isPattern;
sl@0:   int inTransaction;      /* True if within a transaction */
sl@0:   char *zThis;            /* Name of the echo table */
sl@0:   char *zTableName;       /* Name of the real table */
sl@0:   char *zLogName;         /* Name of the log table */
sl@0:   int nCol;               /* Number of columns in the real table */
sl@0:   int *aIndex;            /* Array of size nCol. True if column has an index */
sl@0:   char **aCol;            /* Array of size nCol. Column names */
sl@0: };
sl@0: 
sl@0: /* An echo cursor object */
sl@0: struct echo_cursor {
sl@0:   sqlite3_vtab_cursor base;
sl@0:   sqlite3_stmt *pStmt;
sl@0: };
sl@0: 
sl@0: static int simulateVtabError(echo_vtab *p, const char *zMethod){
sl@0:   const char *zErr;
sl@0:   char zVarname[128];
sl@0:   zVarname[127] = '\0';
sl@0:   sqlite3_snprintf(127, zVarname, "echo_module_fail(%s,%s)", zMethod, p->zTableName);
sl@0:   zErr = Tcl_GetVar(p->interp, zVarname, TCL_GLOBAL_ONLY);
sl@0:   if( zErr ){
sl@0:     p->base.zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", zErr);
sl@0:   }
sl@0:   return (zErr!=0);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Convert an SQL-style quoted string into a normal string by removing
sl@0: ** the quote characters.  The conversion is done in-place.  If the
sl@0: ** input does not begin with a quote character, then this routine
sl@0: ** is a no-op.
sl@0: **
sl@0: ** Examples:
sl@0: **
sl@0: **     "abc"   becomes   abc
sl@0: **     'xyz'   becomes   xyz
sl@0: **     [pqr]   becomes   pqr
sl@0: **     `mno`   becomes   mno
sl@0: */
sl@0: static void dequoteString(char *z){
sl@0:   int quote;
sl@0:   int i, j;
sl@0:   if( z==0 ) return;
sl@0:   quote = z[0];
sl@0:   switch( quote ){
sl@0:     case '\'':  break;
sl@0:     case '"':   break;
sl@0:     case '`':   break;                /* For MySQL compatibility */
sl@0:     case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
sl@0:     default:    return;
sl@0:   }
sl@0:   for(i=1, j=0; z[i]; i++){
sl@0:     if( z[i]==quote ){
sl@0:       if( z[i+1]==quote ){
sl@0:         z[j++] = quote;
sl@0:         i++;
sl@0:       }else{
sl@0:         z[j++] = 0;
sl@0:         break;
sl@0:       }
sl@0:     }else{
sl@0:       z[j++] = z[i];
sl@0:     }
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Retrieve the column names for the table named zTab via database
sl@0: ** connection db. SQLITE_OK is returned on success, or an sqlite error
sl@0: ** code otherwise.
sl@0: **
sl@0: ** If successful, the number of columns is written to *pnCol. *paCol is
sl@0: ** set to point at sqlite3_malloc()'d space containing the array of
sl@0: ** nCol column names. The caller is responsible for calling sqlite3_free
sl@0: ** on *paCol.
sl@0: */
sl@0: static int getColumnNames(
sl@0:   sqlite3 *db, 
sl@0:   const char *zTab,
sl@0:   char ***paCol, 
sl@0:   int *pnCol
sl@0: ){
sl@0:   char **aCol = 0;
sl@0:   char *zSql;
sl@0:   sqlite3_stmt *pStmt = 0;
sl@0:   int rc = SQLITE_OK;
sl@0:   int nCol = 0;
sl@0: 
sl@0:   /* Prepare the statement "SELECT * FROM <tbl>". The column names
sl@0:   ** of the result set of the compiled SELECT will be the same as
sl@0:   ** the column names of table <tbl>.
sl@0:   */
sl@0:   zSql = sqlite3_mprintf("SELECT * FROM %Q", zTab);
sl@0:   if( !zSql ){
sl@0:     rc = SQLITE_NOMEM;
sl@0:     goto out;
sl@0:   }
sl@0:   rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
sl@0:   sqlite3_free(zSql);
sl@0: 
sl@0:   if( rc==SQLITE_OK ){
sl@0:     int ii;
sl@0:     int nBytes;
sl@0:     char *zSpace;
sl@0:     nCol = sqlite3_column_count(pStmt);
sl@0: 
sl@0:     /* Figure out how much space to allocate for the array of column names 
sl@0:     ** (including space for the strings themselves). Then allocate it.
sl@0:     */
sl@0:     nBytes = sizeof(char *) * nCol;
sl@0:     for(ii=0; ii<nCol; ii++){
sl@0:       const char *zName = sqlite3_column_name(pStmt, ii);
sl@0:       if( !zName ){
sl@0:         rc = SQLITE_NOMEM;
sl@0:         goto out;
sl@0:       }
sl@0:       nBytes += strlen(zName)+1;
sl@0:     }
sl@0:     aCol = (char **)sqlite3MallocZero(nBytes);
sl@0:     if( !aCol ){
sl@0:       rc = SQLITE_NOMEM;
sl@0:       goto out;
sl@0:     }
sl@0: 
sl@0:     /* Copy the column names into the allocated space and set up the
sl@0:     ** pointers in the aCol[] array.
sl@0:     */
sl@0:     zSpace = (char *)(&aCol[nCol]);
sl@0:     for(ii=0; ii<nCol; ii++){
sl@0:       aCol[ii] = zSpace;
sl@0:       zSpace += sprintf(zSpace, "%s", sqlite3_column_name(pStmt, ii));
sl@0:       zSpace++;
sl@0:     }
sl@0:     assert( (zSpace-nBytes)==(char *)aCol );
sl@0:   }
sl@0: 
sl@0:   *paCol = aCol;
sl@0:   *pnCol = nCol;
sl@0: 
sl@0: out:
sl@0:   sqlite3_finalize(pStmt);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Parameter zTab is the name of a table in database db with nCol 
sl@0: ** columns. This function allocates an array of integers nCol in 
sl@0: ** size and populates it according to any implicit or explicit 
sl@0: ** indices on table zTab.
sl@0: **
sl@0: ** If successful, SQLITE_OK is returned and *paIndex set to point 
sl@0: ** at the allocated array. Otherwise, an error code is returned.
sl@0: **
sl@0: ** See comments associated with the member variable aIndex above 
sl@0: ** "struct echo_vtab" for details of the contents of the array.
sl@0: */
sl@0: static int getIndexArray(
sl@0:   sqlite3 *db,             /* Database connection */
sl@0:   const char *zTab,        /* Name of table in database db */
sl@0:   int nCol,
sl@0:   int **paIndex
sl@0: ){
sl@0:   sqlite3_stmt *pStmt = 0;
sl@0:   int *aIndex = 0;
sl@0:   int rc;
sl@0:   char *zSql;
sl@0: 
sl@0:   /* Allocate space for the index array */
sl@0:   aIndex = (int *)sqlite3MallocZero(sizeof(int) * nCol);
sl@0:   if( !aIndex ){
sl@0:     rc = SQLITE_NOMEM;
sl@0:     goto get_index_array_out;
sl@0:   }
sl@0: 
sl@0:   /* Compile an sqlite pragma to loop through all indices on table zTab */
sl@0:   zSql = sqlite3MPrintf(0, "PRAGMA index_list(%s)", zTab);
sl@0:   if( !zSql ){
sl@0:     rc = SQLITE_NOMEM;
sl@0:     goto get_index_array_out;
sl@0:   }
sl@0:   rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
sl@0:   sqlite3_free(zSql);
sl@0: 
sl@0:   /* For each index, figure out the left-most column and set the 
sl@0:   ** corresponding entry in aIndex[] to 1.
sl@0:   */
sl@0:   while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
sl@0:     const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
sl@0:     sqlite3_stmt *pStmt2 = 0;
sl@0:     zSql = sqlite3MPrintf(0, "PRAGMA index_info(%s)", zIdx);
sl@0:     if( !zSql ){
sl@0:       rc = SQLITE_NOMEM;
sl@0:       goto get_index_array_out;
sl@0:     }
sl@0:     rc = sqlite3_prepare(db, zSql, -1, &pStmt2, 0);
sl@0:     sqlite3_free(zSql);
sl@0:     if( pStmt2 && sqlite3_step(pStmt2)==SQLITE_ROW ){
sl@0:       int cid = sqlite3_column_int(pStmt2, 1);
sl@0:       assert( cid>=0 && cid<nCol );
sl@0:       aIndex[cid] = 1;
sl@0:     }
sl@0:     if( pStmt2 ){
sl@0:       rc = sqlite3_finalize(pStmt2);
sl@0:     }
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       goto get_index_array_out;
sl@0:     }
sl@0:   }
sl@0: 
sl@0: 
sl@0: get_index_array_out:
sl@0:   if( pStmt ){
sl@0:     int rc2 = sqlite3_finalize(pStmt);
sl@0:     if( rc==SQLITE_OK ){
sl@0:       rc = rc2;
sl@0:     }
sl@0:   }
sl@0:   if( rc!=SQLITE_OK ){
sl@0:     sqlite3_free(aIndex);
sl@0:     aIndex = 0;
sl@0:   }
sl@0:   *paIndex = aIndex;
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Global Tcl variable $echo_module is a list. This routine appends
sl@0: ** the string element zArg to that list in interpreter interp.
sl@0: */
sl@0: static void appendToEchoModule(Tcl_Interp *interp, const char *zArg){
sl@0:   int flags = (TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_GLOBAL_ONLY);
sl@0:   Tcl_SetVar(interp, "echo_module", (zArg?zArg:""), flags);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This function is called from within the echo-modules xCreate and
sl@0: ** xConnect methods. The argc and argv arguments are copies of those 
sl@0: ** passed to the calling method. This function is responsible for
sl@0: ** calling sqlite3_declare_vtab() to declare the schema of the virtual
sl@0: ** table being created or connected.
sl@0: **
sl@0: ** If the constructor was passed just one argument, i.e.:
sl@0: **
sl@0: **   CREATE TABLE t1 AS echo(t2);
sl@0: **
sl@0: ** Then t2 is assumed to be the name of a *real* database table. The
sl@0: ** schema of the virtual table is declared by passing a copy of the 
sl@0: ** CREATE TABLE statement for the real table to sqlite3_declare_vtab().
sl@0: ** Hence, the virtual table should have exactly the same column names and 
sl@0: ** types as the real table.
sl@0: */
sl@0: static int echoDeclareVtab(
sl@0:   echo_vtab *pVtab, 
sl@0:   sqlite3 *db 
sl@0: ){
sl@0:   int rc = SQLITE_OK;
sl@0: 
sl@0:   if( pVtab->zTableName ){
sl@0:     sqlite3_stmt *pStmt = 0;
sl@0:     rc = sqlite3_prepare(db, 
sl@0:         "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
sl@0:         -1, &pStmt, 0);
sl@0:     if( rc==SQLITE_OK ){
sl@0:       sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
sl@0:       if( sqlite3_step(pStmt)==SQLITE_ROW ){
sl@0:         int rc2;
sl@0:         const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
sl@0:         rc = sqlite3_declare_vtab(db, zCreateTable);
sl@0:         rc2 = sqlite3_finalize(pStmt);
sl@0:         if( rc==SQLITE_OK ){
sl@0:           rc = rc2;
sl@0:         }
sl@0:       } else {
sl@0:         rc = sqlite3_finalize(pStmt);
sl@0:         if( rc==SQLITE_OK ){ 
sl@0:           rc = SQLITE_ERROR;
sl@0:         }
sl@0:       }
sl@0:       if( rc==SQLITE_OK ){
sl@0:         rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
sl@0:       }
sl@0:       if( rc==SQLITE_OK ){
sl@0:         rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
sl@0:       }
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This function frees all runtime structures associated with the virtual
sl@0: ** table pVtab.
sl@0: */
sl@0: static int echoDestructor(sqlite3_vtab *pVtab){
sl@0:   echo_vtab *p = (echo_vtab*)pVtab;
sl@0:   sqlite3_free(p->aIndex);
sl@0:   sqlite3_free(p->aCol);
sl@0:   sqlite3_free(p->zThis);
sl@0:   sqlite3_free(p->zTableName);
sl@0:   sqlite3_free(p->zLogName);
sl@0:   sqlite3_free(p);
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: typedef struct EchoModule EchoModule;
sl@0: struct EchoModule {
sl@0:   Tcl_Interp *interp;
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** This function is called to do the work of the xConnect() method -
sl@0: ** to allocate the required in-memory structures for a newly connected
sl@0: ** virtual table.
sl@0: */
sl@0: static int echoConstructor(
sl@0:   sqlite3 *db,
sl@0:   void *pAux,
sl@0:   int argc, const char *const*argv,
sl@0:   sqlite3_vtab **ppVtab,
sl@0:   char **pzErr
sl@0: ){
sl@0:   int rc;
sl@0:   int i;
sl@0:   echo_vtab *pVtab;
sl@0: 
sl@0:   /* Allocate the sqlite3_vtab/echo_vtab structure itself */
sl@0:   pVtab = sqlite3MallocZero( sizeof(*pVtab) );
sl@0:   if( !pVtab ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0:   pVtab->interp = ((EchoModule *)pAux)->interp;
sl@0:   pVtab->db = db;
sl@0: 
sl@0:   /* Allocate echo_vtab.zThis */
sl@0:   pVtab->zThis = sqlite3MPrintf(0, "%s", argv[2]);
sl@0:   if( !pVtab->zThis ){
sl@0:     echoDestructor((sqlite3_vtab *)pVtab);
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0: 
sl@0:   /* Allocate echo_vtab.zTableName */
sl@0:   if( argc>3 ){
sl@0:     pVtab->zTableName = sqlite3MPrintf(0, "%s", argv[3]);
sl@0:     dequoteString(pVtab->zTableName);
sl@0:     if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){
sl@0:       char *z = sqlite3MPrintf(0, "%s%s", argv[2], &(pVtab->zTableName[1]));
sl@0:       sqlite3_free(pVtab->zTableName);
sl@0:       pVtab->zTableName = z;
sl@0:       pVtab->isPattern = 1;
sl@0:     }
sl@0:     if( !pVtab->zTableName ){
sl@0:       echoDestructor((sqlite3_vtab *)pVtab);
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Log the arguments to this function to Tcl var ::echo_module */
sl@0:   for(i=0; i<argc; i++){
sl@0:     appendToEchoModule(pVtab->interp, argv[i]);
sl@0:   }
sl@0: 
sl@0:   /* Invoke sqlite3_declare_vtab and set up other members of the echo_vtab
sl@0:   ** structure. If an error occurs, delete the sqlite3_vtab structure and
sl@0:   ** return an error code.
sl@0:   */
sl@0:   rc = echoDeclareVtab(pVtab, db);
sl@0:   if( rc!=SQLITE_OK ){
sl@0:     echoDestructor((sqlite3_vtab *)pVtab);
sl@0:     return rc;
sl@0:   }
sl@0: 
sl@0:   /* Success. Set *ppVtab and return */
sl@0:   *ppVtab = &pVtab->base;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xCreate method.
sl@0: */
sl@0: static int echoCreate(
sl@0:   sqlite3 *db,
sl@0:   void *pAux,
sl@0:   int argc, const char *const*argv,
sl@0:   sqlite3_vtab **ppVtab,
sl@0:   char **pzErr
sl@0: ){
sl@0:   int rc = SQLITE_OK;
sl@0:   appendToEchoModule(((EchoModule *)pAux)->interp, "xCreate");
sl@0:   rc = echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
sl@0: 
sl@0:   /* If there were two arguments passed to the module at the SQL level 
sl@0:   ** (i.e. "CREATE VIRTUAL TABLE tbl USING echo(arg1, arg2)"), then 
sl@0:   ** the second argument is used as a table name. Attempt to create
sl@0:   ** such a table with a single column, "logmsg". This table will
sl@0:   ** be used to log calls to the xUpdate method. It will be deleted
sl@0:   ** when the virtual table is DROPed.
sl@0:   **
sl@0:   ** Note: The main point of this is to test that we can drop tables
sl@0:   ** from within an xDestroy method call.
sl@0:   */
sl@0:   if( rc==SQLITE_OK && argc==5 ){
sl@0:     char *zSql;
sl@0:     echo_vtab *pVtab = *(echo_vtab **)ppVtab;
sl@0:     pVtab->zLogName = sqlite3MPrintf(0, "%s", argv[4]);
sl@0:     zSql = sqlite3MPrintf(0, "CREATE TABLE %Q(logmsg)", pVtab->zLogName);
sl@0:     rc = sqlite3_exec(db, zSql, 0, 0, 0);
sl@0:     sqlite3_free(zSql);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       *pzErr = sqlite3DbStrDup(0, sqlite3_errmsg(db));
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   if( *ppVtab && rc!=SQLITE_OK ){
sl@0:     echoDestructor(*ppVtab);
sl@0:     *ppVtab = 0;
sl@0:   }
sl@0: 
sl@0:   if( rc==SQLITE_OK ){
sl@0:     (*(echo_vtab**)ppVtab)->inTransaction = 1;
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xConnect method.
sl@0: */
sl@0: static int echoConnect(
sl@0:   sqlite3 *db,
sl@0:   void *pAux,
sl@0:   int argc, const char *const*argv,
sl@0:   sqlite3_vtab **ppVtab,
sl@0:   char **pzErr
sl@0: ){
sl@0:   appendToEchoModule(((EchoModule *)pAux)->interp, "xConnect");
sl@0:   return echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xDisconnect method.
sl@0: */
sl@0: static int echoDisconnect(sqlite3_vtab *pVtab){
sl@0:   appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDisconnect");
sl@0:   return echoDestructor(pVtab);
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xDestroy method.
sl@0: */
sl@0: static int echoDestroy(sqlite3_vtab *pVtab){
sl@0:   int rc = SQLITE_OK;
sl@0:   echo_vtab *p = (echo_vtab *)pVtab;
sl@0:   appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDestroy");
sl@0: 
sl@0:   /* Drop the "log" table, if one exists (see echoCreate() for details) */
sl@0:   if( p && p->zLogName ){
sl@0:     char *zSql;
sl@0:     zSql = sqlite3MPrintf(0, "DROP TABLE %Q", p->zLogName);
sl@0:     rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
sl@0:     sqlite3_free(zSql);
sl@0:   }
sl@0: 
sl@0:   if( rc==SQLITE_OK ){
sl@0:     rc = echoDestructor(pVtab);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xOpen method.
sl@0: */
sl@0: static int echoOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
sl@0:   echo_cursor *pCur;
sl@0:   if( simulateVtabError((echo_vtab *)pVTab, "xOpen") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0:   pCur = sqlite3MallocZero(sizeof(echo_cursor));
sl@0:   *ppCursor = (sqlite3_vtab_cursor *)pCur;
sl@0:   return (pCur ? SQLITE_OK : SQLITE_NOMEM);
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xClose method.
sl@0: */
sl@0: static int echoClose(sqlite3_vtab_cursor *cur){
sl@0:   int rc;
sl@0:   echo_cursor *pCur = (echo_cursor *)cur;
sl@0:   sqlite3_stmt *pStmt = pCur->pStmt;
sl@0:   pCur->pStmt = 0;
sl@0:   sqlite3_free(pCur);
sl@0:   rc = sqlite3_finalize(pStmt);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return non-zero if the cursor does not currently point to a valid record
sl@0: ** (i.e if the scan has finished), or zero otherwise.
sl@0: */
sl@0: static int echoEof(sqlite3_vtab_cursor *cur){
sl@0:   return (((echo_cursor *)cur)->pStmt ? 0 : 1);
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xNext method.
sl@0: */
sl@0: static int echoNext(sqlite3_vtab_cursor *cur){
sl@0:   int rc = SQLITE_OK;
sl@0:   echo_cursor *pCur = (echo_cursor *)cur;
sl@0: 
sl@0:   if( simulateVtabError((echo_vtab *)(cur->pVtab), "xNext") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   if( pCur->pStmt ){
sl@0:     rc = sqlite3_step(pCur->pStmt);
sl@0:     if( rc==SQLITE_ROW ){
sl@0:       rc = SQLITE_OK;
sl@0:     }else{
sl@0:       rc = sqlite3_finalize(pCur->pStmt);
sl@0:       pCur->pStmt = 0;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xColumn method.
sl@0: */
sl@0: static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
sl@0:   int iCol = i + 1;
sl@0:   sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
sl@0: 
sl@0:   if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   if( !pStmt ){
sl@0:     sqlite3_result_null(ctx);
sl@0:   }else{
sl@0:     assert( sqlite3_data_count(pStmt)>iCol );
sl@0:     sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
sl@0:   }
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xRowid method.
sl@0: */
sl@0: static int echoRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
sl@0:   sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
sl@0: 
sl@0:   if( simulateVtabError((echo_vtab *)(cur->pVtab), "xRowid") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   *pRowid = sqlite3_column_int64(pStmt, 0);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Compute a simple hash of the null terminated string zString.
sl@0: **
sl@0: ** This module uses only sqlite3_index_info.idxStr, not 
sl@0: ** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
sl@0: ** in echoBestIndex(), idxNum is set to the corresponding hash value.
sl@0: ** In echoFilter(), code assert()s that the supplied idxNum value is
sl@0: ** indeed the hash of the supplied idxStr.
sl@0: */
sl@0: static int hashString(const char *zString){
sl@0:   int val = 0;
sl@0:   int ii;
sl@0:   for(ii=0; zString[ii]; ii++){
sl@0:     val = (val << 3) + (int)zString[ii];
sl@0:   }
sl@0:   return val;
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** Echo virtual table module xFilter method.
sl@0: */
sl@0: static int echoFilter(
sl@0:   sqlite3_vtab_cursor *pVtabCursor, 
sl@0:   int idxNum, const char *idxStr,
sl@0:   int argc, sqlite3_value **argv
sl@0: ){
sl@0:   int rc;
sl@0:   int i;
sl@0: 
sl@0:   echo_cursor *pCur = (echo_cursor *)pVtabCursor;
sl@0:   echo_vtab *pVtab = (echo_vtab *)pVtabCursor->pVtab;
sl@0:   sqlite3 *db = pVtab->db;
sl@0: 
sl@0:   if( simulateVtabError(pVtab, "xFilter") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   /* Check that idxNum matches idxStr */
sl@0:   assert( idxNum==hashString(idxStr) );
sl@0: 
sl@0:   /* Log arguments to the ::echo_module Tcl variable */
sl@0:   appendToEchoModule(pVtab->interp, "xFilter");
sl@0:   appendToEchoModule(pVtab->interp, idxStr);
sl@0:   for(i=0; i<argc; i++){
sl@0:     appendToEchoModule(pVtab->interp, (const char*)sqlite3_value_text(argv[i]));
sl@0:   }
sl@0: 
sl@0:   sqlite3_finalize(pCur->pStmt);
sl@0:   pCur->pStmt = 0;
sl@0: 
sl@0:   /* Prepare the SQL statement created by echoBestIndex and bind the
sl@0:   ** runtime parameters passed to this function to it.
sl@0:   */
sl@0:   rc = sqlite3_prepare(db, idxStr, -1, &pCur->pStmt, 0);
sl@0:   assert( pCur->pStmt || rc!=SQLITE_OK );
sl@0:   for(i=0; rc==SQLITE_OK && i<argc; i++){
sl@0:     sqlite3_bind_value(pCur->pStmt, i+1, argv[i]);
sl@0:   }
sl@0: 
sl@0:   /* If everything was successful, advance to the first row of the scan */
sl@0:   if( rc==SQLITE_OK ){
sl@0:     rc = echoNext(pVtabCursor);
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** A helper function used by echoUpdate() and echoBestIndex() for
sl@0: ** manipulating strings in concert with the sqlite3_mprintf() function.
sl@0: **
sl@0: ** Parameter pzStr points to a pointer to a string allocated with
sl@0: ** sqlite3_mprintf. The second parameter, zAppend, points to another
sl@0: ** string. The two strings are concatenated together and *pzStr
sl@0: ** set to point at the result. The initial buffer pointed to by *pzStr
sl@0: ** is deallocated via sqlite3_free().
sl@0: **
sl@0: ** If the third argument, doFree, is true, then sqlite3_free() is
sl@0: ** also called to free the buffer pointed to by zAppend.
sl@0: */
sl@0: static void string_concat(char **pzStr, char *zAppend, int doFree, int *pRc){
sl@0:   char *zIn = *pzStr;
sl@0:   if( !zAppend && doFree && *pRc==SQLITE_OK ){
sl@0:     *pRc = SQLITE_NOMEM;
sl@0:   }
sl@0:   if( *pRc!=SQLITE_OK ){
sl@0:     sqlite3_free(zIn);
sl@0:     zIn = 0;
sl@0:   }else{
sl@0:     if( zIn ){
sl@0:       char *zTemp = zIn;
sl@0:       zIn = sqlite3_mprintf("%s%s", zIn, zAppend);
sl@0:       sqlite3_free(zTemp);
sl@0:     }else{
sl@0:       zIn = sqlite3_mprintf("%s", zAppend);
sl@0:     }
sl@0:     if( !zIn ){
sl@0:       *pRc = SQLITE_NOMEM;
sl@0:     }
sl@0:   }
sl@0:   *pzStr = zIn;
sl@0:   if( doFree ){
sl@0:     sqlite3_free(zAppend);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The echo module implements the subset of query constraints and sort
sl@0: ** orders that may take advantage of SQLite indices on the underlying
sl@0: ** real table. For example, if the real table is declared as:
sl@0: **
sl@0: **     CREATE TABLE real(a, b, c);
sl@0: **     CREATE INDEX real_index ON real(b);
sl@0: **
sl@0: ** then the echo module handles WHERE or ORDER BY clauses that refer
sl@0: ** to the column "b", but not "a" or "c". If a multi-column index is
sl@0: ** present, only its left most column is considered. 
sl@0: **
sl@0: ** This xBestIndex method encodes the proposed search strategy as
sl@0: ** an SQL query on the real table underlying the virtual echo module 
sl@0: ** table and stores the query in sqlite3_index_info.idxStr. The SQL
sl@0: ** statement is of the form:
sl@0: **
sl@0: **   SELECT rowid, * FROM <real-table> ?<where-clause>? ?<order-by-clause>?
sl@0: **
sl@0: ** where the <where-clause> and <order-by-clause> are determined
sl@0: ** by the contents of the structure pointed to by the pIdxInfo argument.
sl@0: */
sl@0: static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
sl@0:   int ii;
sl@0:   char *zQuery = 0;
sl@0:   char *zNew;
sl@0:   int nArg = 0;
sl@0:   const char *zSep = "WHERE";
sl@0:   echo_vtab *pVtab = (echo_vtab *)tab;
sl@0:   sqlite3_stmt *pStmt = 0;
sl@0:   Tcl_Interp *interp = pVtab->interp;
sl@0: 
sl@0:   int nRow;
sl@0:   int useIdx = 0;
sl@0:   int rc = SQLITE_OK;
sl@0:   int useCost = 0;
sl@0:   double cost;
sl@0:   int isIgnoreUsable = 0;
sl@0:   if( Tcl_GetVar(interp, "echo_module_ignore_usable", TCL_GLOBAL_ONLY) ){
sl@0:     isIgnoreUsable = 1;
sl@0:   }
sl@0: 
sl@0:   if( simulateVtabError(pVtab, "xBestIndex") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   /* Determine the number of rows in the table and store this value in local
sl@0:   ** variable nRow. The 'estimated-cost' of the scan will be the number of
sl@0:   ** rows in the table for a linear scan, or the log (base 2) of the 
sl@0:   ** number of rows if the proposed scan uses an index.  
sl@0:   */
sl@0:   if( Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY) ){
sl@0:     cost = atof(Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY));
sl@0:     useCost = 1;
sl@0:   } else {
sl@0:     zQuery = sqlite3_mprintf("SELECT count(*) FROM %Q", pVtab->zTableName);
sl@0:     if( !zQuery ){
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:     rc = sqlite3_prepare(pVtab->db, zQuery, -1, &pStmt, 0);
sl@0:     sqlite3_free(zQuery);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       return rc;
sl@0:     }
sl@0:     sqlite3_step(pStmt);
sl@0:     nRow = sqlite3_column_int(pStmt, 0);
sl@0:     rc = sqlite3_finalize(pStmt);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       return rc;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   zQuery = sqlite3_mprintf("SELECT rowid, * FROM %Q", pVtab->zTableName);
sl@0:   if( !zQuery ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0:   for(ii=0; ii<pIdxInfo->nConstraint; ii++){
sl@0:     const struct sqlite3_index_constraint *pConstraint;
sl@0:     struct sqlite3_index_constraint_usage *pUsage;
sl@0:     int iCol;
sl@0: 
sl@0:     pConstraint = &pIdxInfo->aConstraint[ii];
sl@0:     pUsage = &pIdxInfo->aConstraintUsage[ii];
sl@0: 
sl@0:     if( !isIgnoreUsable && !pConstraint->usable ) continue;
sl@0: 
sl@0:     iCol = pConstraint->iColumn;
sl@0:     if( pVtab->aIndex[iCol] || iCol<0 ){
sl@0:       char *zCol = pVtab->aCol[iCol];
sl@0:       char *zOp = 0;
sl@0:       useIdx = 1;
sl@0:       if( iCol<0 ){
sl@0:         zCol = "rowid";
sl@0:       }
sl@0:       switch( pConstraint->op ){
sl@0:         case SQLITE_INDEX_CONSTRAINT_EQ:
sl@0:           zOp = "="; break;
sl@0:         case SQLITE_INDEX_CONSTRAINT_LT:
sl@0:           zOp = "<"; break;
sl@0:         case SQLITE_INDEX_CONSTRAINT_GT:
sl@0:           zOp = ">"; break;
sl@0:         case SQLITE_INDEX_CONSTRAINT_LE:
sl@0:           zOp = "<="; break;
sl@0:         case SQLITE_INDEX_CONSTRAINT_GE:
sl@0:           zOp = ">="; break;
sl@0:         case SQLITE_INDEX_CONSTRAINT_MATCH:
sl@0:           zOp = "LIKE"; break;
sl@0:       }
sl@0:       if( zOp[0]=='L' ){
sl@0:         zNew = sqlite3_mprintf(" %s %s LIKE (SELECT '%%'||?||'%%')", 
sl@0:                                zSep, zCol);
sl@0:       } else {
sl@0:         zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zCol, zOp);
sl@0:       }
sl@0:       string_concat(&zQuery, zNew, 1, &rc);
sl@0: 
sl@0:       zSep = "AND";
sl@0:       pUsage->argvIndex = ++nArg;
sl@0:       pUsage->omit = 1;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* If there is only one term in the ORDER BY clause, and it is
sl@0:   ** on a column that this virtual table has an index for, then consume 
sl@0:   ** the ORDER BY clause.
sl@0:   */
sl@0:   if( pIdxInfo->nOrderBy==1 && pVtab->aIndex[pIdxInfo->aOrderBy->iColumn] ){
sl@0:     int iCol = pIdxInfo->aOrderBy->iColumn;
sl@0:     char *zCol = pVtab->aCol[iCol];
sl@0:     char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
sl@0:     if( iCol<0 ){
sl@0:       zCol = "rowid";
sl@0:     }
sl@0:     zNew = sqlite3_mprintf(" ORDER BY %s %s", zCol, zDir);
sl@0:     string_concat(&zQuery, zNew, 1, &rc);
sl@0:     pIdxInfo->orderByConsumed = 1;
sl@0:   }
sl@0: 
sl@0:   appendToEchoModule(pVtab->interp, "xBestIndex");;
sl@0:   appendToEchoModule(pVtab->interp, zQuery);
sl@0: 
sl@0:   if( !zQuery ){
sl@0:     return rc;
sl@0:   }
sl@0:   pIdxInfo->idxNum = hashString(zQuery);
sl@0:   pIdxInfo->idxStr = zQuery;
sl@0:   pIdxInfo->needToFreeIdxStr = 1;
sl@0:   if (useCost) {
sl@0:     pIdxInfo->estimatedCost = cost;
sl@0:   } else if( useIdx ){
sl@0:     /* Approximation of log2(nRow). */
sl@0:     for( ii=0; ii<(sizeof(int)*8); ii++ ){
sl@0:       if( nRow & (1<<ii) ){
sl@0:         pIdxInfo->estimatedCost = (double)ii;
sl@0:       }
sl@0:     }
sl@0:   } else {
sl@0:     pIdxInfo->estimatedCost = (double)nRow;
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The xUpdate method for echo module virtual tables.
sl@0: ** 
sl@0: **    apData[0]  apData[1]  apData[2..]
sl@0: **
sl@0: **    INTEGER                              DELETE            
sl@0: **
sl@0: **    INTEGER    NULL       (nCol args)    UPDATE (do not set rowid)
sl@0: **    INTEGER    INTEGER    (nCol args)    UPDATE (with SET rowid = <arg1>)
sl@0: **
sl@0: **    NULL       NULL       (nCol args)    INSERT INTO (automatic rowid value)
sl@0: **    NULL       INTEGER    (nCol args)    INSERT (incl. rowid value)
sl@0: **
sl@0: */
sl@0: int echoUpdate(
sl@0:   sqlite3_vtab *tab, 
sl@0:   int nData, 
sl@0:   sqlite3_value **apData, 
sl@0:   sqlite_int64 *pRowid
sl@0: ){
sl@0:   echo_vtab *pVtab = (echo_vtab *)tab;
sl@0:   sqlite3 *db = pVtab->db;
sl@0:   int rc = SQLITE_OK;
sl@0: 
sl@0:   sqlite3_stmt *pStmt;
sl@0:   char *z = 0;               /* SQL statement to execute */
sl@0:   int bindArgZero = 0;       /* True to bind apData[0] to sql var no. nData */
sl@0:   int bindArgOne = 0;        /* True to bind apData[1] to sql var no. 1 */
sl@0:   int i;                     /* Counter variable used by for loops */
sl@0: 
sl@0:   assert( nData==pVtab->nCol+2 || nData==1 );
sl@0: 
sl@0:   /* Ticket #3083 - make sure we always start a transaction prior to
sl@0:   ** making any changes to a virtual table */
sl@0:   assert( pVtab->inTransaction );
sl@0: 
sl@0:   if( simulateVtabError(pVtab, "xUpdate") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   /* If apData[0] is an integer and nData>1 then do an UPDATE */
sl@0:   if( nData>1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
sl@0:     char *zSep = " SET";
sl@0:     z = sqlite3_mprintf("UPDATE %Q", pVtab->zTableName);
sl@0:     if( !z ){
sl@0:       rc = SQLITE_NOMEM;
sl@0:     }
sl@0: 
sl@0:     bindArgOne = (apData[1] && sqlite3_value_type(apData[1])==SQLITE_INTEGER);
sl@0:     bindArgZero = 1;
sl@0: 
sl@0:     if( bindArgOne ){
sl@0:        string_concat(&z, " SET rowid=?1 ", 0, &rc);
sl@0:        zSep = ",";
sl@0:     }
sl@0:     for(i=2; i<nData; i++){
sl@0:       if( apData[i]==0 ) continue;
sl@0:       string_concat(&z, sqlite3_mprintf(
sl@0:           "%s %Q=?%d", zSep, pVtab->aCol[i-2], i), 1, &rc);
sl@0:       zSep = ",";
sl@0:     }
sl@0:     string_concat(&z, sqlite3_mprintf(" WHERE rowid=?%d", nData), 1, &rc);
sl@0:   }
sl@0: 
sl@0:   /* If apData[0] is an integer and nData==1 then do a DELETE */
sl@0:   else if( nData==1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
sl@0:     z = sqlite3_mprintf("DELETE FROM %Q WHERE rowid = ?1", pVtab->zTableName);
sl@0:     if( !z ){
sl@0:       rc = SQLITE_NOMEM;
sl@0:     }
sl@0:     bindArgZero = 1;
sl@0:   }
sl@0: 
sl@0:   /* If the first argument is NULL and there are more than two args, INSERT */
sl@0:   else if( nData>2 && sqlite3_value_type(apData[0])==SQLITE_NULL ){
sl@0:     int ii;
sl@0:     char *zInsert = 0;
sl@0:     char *zValues = 0;
sl@0:   
sl@0:     zInsert = sqlite3_mprintf("INSERT INTO %Q (", pVtab->zTableName);
sl@0:     if( !zInsert ){
sl@0:       rc = SQLITE_NOMEM;
sl@0:     }
sl@0:     if( sqlite3_value_type(apData[1])==SQLITE_INTEGER ){
sl@0:       bindArgOne = 1;
sl@0:       zValues = sqlite3_mprintf("?");
sl@0:       string_concat(&zInsert, "rowid", 0, &rc);
sl@0:     }
sl@0: 
sl@0:     assert((pVtab->nCol+2)==nData);
sl@0:     for(ii=2; ii<nData; ii++){
sl@0:       string_concat(&zInsert, 
sl@0:           sqlite3_mprintf("%s%Q", zValues?", ":"", pVtab->aCol[ii-2]), 1, &rc);
sl@0:       string_concat(&zValues, 
sl@0:           sqlite3_mprintf("%s?%d", zValues?", ":"", ii), 1, &rc);
sl@0:     }
sl@0: 
sl@0:     string_concat(&z, zInsert, 1, &rc);
sl@0:     string_concat(&z, ") VALUES(", 0, &rc);
sl@0:     string_concat(&z, zValues, 1, &rc);
sl@0:     string_concat(&z, ")", 0, &rc);
sl@0:   }
sl@0: 
sl@0:   /* Anything else is an error */
sl@0:   else{
sl@0:     assert(0);
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   if( rc==SQLITE_OK ){
sl@0:     rc = sqlite3_prepare(db, z, -1, &pStmt, 0);
sl@0:   }
sl@0:   assert( rc!=SQLITE_OK || pStmt );
sl@0:   sqlite3_free(z);
sl@0:   if( rc==SQLITE_OK ) {
sl@0:     if( bindArgZero ){
sl@0:       sqlite3_bind_value(pStmt, nData, apData[0]);
sl@0:     }
sl@0:     if( bindArgOne ){
sl@0:       sqlite3_bind_value(pStmt, 1, apData[1]);
sl@0:     }
sl@0:     for(i=2; i<nData && rc==SQLITE_OK; i++){
sl@0:       if( apData[i] ) rc = sqlite3_bind_value(pStmt, i, apData[i]);
sl@0:     }
sl@0:     if( rc==SQLITE_OK ){
sl@0:       sqlite3_step(pStmt);
sl@0:       rc = sqlite3_finalize(pStmt);
sl@0:     }else{
sl@0:       sqlite3_finalize(pStmt);
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   if( pRowid && rc==SQLITE_OK ){
sl@0:     *pRowid = sqlite3_last_insert_rowid(db);
sl@0:   }
sl@0:   if( rc!=SQLITE_OK ){
sl@0:     tab->zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", sqlite3_errmsg(db));
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** xBegin, xSync, xCommit and xRollback callbacks for echo module
sl@0: ** virtual tables. Do nothing other than add the name of the callback
sl@0: ** to the $::echo_module Tcl variable.
sl@0: */
sl@0: static int echoTransactionCall(sqlite3_vtab *tab, const char *zCall){
sl@0:   char *z;
sl@0:   echo_vtab *pVtab = (echo_vtab *)tab;
sl@0:   z = sqlite3_mprintf("echo(%s)", pVtab->zTableName);
sl@0:   if( z==0 ) return SQLITE_NOMEM;
sl@0:   appendToEchoModule(pVtab->interp, zCall);
sl@0:   appendToEchoModule(pVtab->interp, z);
sl@0:   sqlite3_free(z);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: static int echoBegin(sqlite3_vtab *tab){
sl@0:   int rc;
sl@0:   echo_vtab *pVtab = (echo_vtab *)tab;
sl@0:   Tcl_Interp *interp = pVtab->interp;
sl@0:   const char *zVal; 
sl@0: 
sl@0:   /* Ticket #3083 - do not start a transaction if we are already in
sl@0:   ** a transaction */
sl@0:   assert( !pVtab->inTransaction );
sl@0: 
sl@0:   if( simulateVtabError(pVtab, "xBegin") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   rc = echoTransactionCall(tab, "xBegin");
sl@0: 
sl@0:   if( rc==SQLITE_OK ){
sl@0:     /* Check if the $::echo_module_begin_fail variable is defined. If it is,
sl@0:     ** and it is set to the name of the real table underlying this virtual
sl@0:     ** echo module table, then cause this xSync operation to fail.
sl@0:     */
sl@0:     zVal = Tcl_GetVar(interp, "echo_module_begin_fail", TCL_GLOBAL_ONLY);
sl@0:     if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
sl@0:       rc = SQLITE_ERROR;
sl@0:     }
sl@0:   }
sl@0:   if( rc==SQLITE_OK ){
sl@0:     pVtab->inTransaction = 1;
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: static int echoSync(sqlite3_vtab *tab){
sl@0:   int rc;
sl@0:   echo_vtab *pVtab = (echo_vtab *)tab;
sl@0:   Tcl_Interp *interp = pVtab->interp;
sl@0:   const char *zVal; 
sl@0: 
sl@0:   /* Ticket #3083 - Only call xSync if we have previously started a
sl@0:   ** transaction */
sl@0:   assert( pVtab->inTransaction );
sl@0: 
sl@0:   if( simulateVtabError(pVtab, "xSync") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   rc = echoTransactionCall(tab, "xSync");
sl@0: 
sl@0:   if( rc==SQLITE_OK ){
sl@0:     /* Check if the $::echo_module_sync_fail variable is defined. If it is,
sl@0:     ** and it is set to the name of the real table underlying this virtual
sl@0:     ** echo module table, then cause this xSync operation to fail.
sl@0:     */
sl@0:     zVal = Tcl_GetVar(interp, "echo_module_sync_fail", TCL_GLOBAL_ONLY);
sl@0:     if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
sl@0:       rc = -1;
sl@0:     }
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: static int echoCommit(sqlite3_vtab *tab){
sl@0:   echo_vtab *pVtab = (echo_vtab*)tab;
sl@0:   int rc;
sl@0: 
sl@0:   /* Ticket #3083 - Only call xCommit if we have previously started
sl@0:   ** a transaction */
sl@0:   assert( pVtab->inTransaction );
sl@0: 
sl@0:   if( simulateVtabError(pVtab, "xCommit") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   sqlite3BeginBenignMalloc();
sl@0:   rc = echoTransactionCall(tab, "xCommit");
sl@0:   sqlite3EndBenignMalloc();
sl@0:   pVtab->inTransaction = 0;
sl@0:   return rc;
sl@0: }
sl@0: static int echoRollback(sqlite3_vtab *tab){
sl@0:   int rc;
sl@0:   echo_vtab *pVtab = (echo_vtab*)tab;
sl@0: 
sl@0:   /* Ticket #3083 - Only call xRollback if we have previously started
sl@0:   ** a transaction */
sl@0:   assert( pVtab->inTransaction );
sl@0: 
sl@0:   rc = echoTransactionCall(tab, "xRollback");
sl@0:   pVtab->inTransaction = 0;
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Implementation of "GLOB" function on the echo module.  Pass
sl@0: ** all arguments to the ::echo_glob_overload procedure of TCL
sl@0: ** and return the result of that procedure as a string.
sl@0: */
sl@0: static void overloadedGlobFunction(
sl@0:   sqlite3_context *pContext,
sl@0:   int nArg,
sl@0:   sqlite3_value **apArg
sl@0: ){
sl@0:   Tcl_Interp *interp = sqlite3_user_data(pContext);
sl@0:   Tcl_DString str;
sl@0:   int i;
sl@0:   int rc;
sl@0:   Tcl_DStringInit(&str);
sl@0:   Tcl_DStringAppendElement(&str, "::echo_glob_overload");
sl@0:   for(i=0; i<nArg; i++){
sl@0:     Tcl_DStringAppendElement(&str, (char*)sqlite3_value_text(apArg[i]));
sl@0:   }
sl@0:   rc = Tcl_Eval(interp, Tcl_DStringValue(&str));
sl@0:   Tcl_DStringFree(&str);
sl@0:   if( rc ){
sl@0:     sqlite3_result_error(pContext, Tcl_GetStringResult(interp), -1);
sl@0:   }else{
sl@0:     sqlite3_result_text(pContext, Tcl_GetStringResult(interp),
sl@0:                         -1, SQLITE_TRANSIENT);
sl@0:   }
sl@0:   Tcl_ResetResult(interp);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This is the xFindFunction implementation for the echo module.
sl@0: ** SQLite calls this routine when the first argument of a function
sl@0: ** is a column of an echo virtual table.  This routine can optionally
sl@0: ** override the implementation of that function.  It will choose to
sl@0: ** do so if the function is named "glob", and a TCL command named
sl@0: ** ::echo_glob_overload exists.
sl@0: */
sl@0: static int echoFindFunction(
sl@0:   sqlite3_vtab *vtab,
sl@0:   int nArg,
sl@0:   const char *zFuncName,
sl@0:   void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
sl@0:   void **ppArg
sl@0: ){
sl@0:   echo_vtab *pVtab = (echo_vtab *)vtab;
sl@0:   Tcl_Interp *interp = pVtab->interp;
sl@0:   Tcl_CmdInfo info;
sl@0:   if( strcmp(zFuncName,"glob")!=0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   if( Tcl_GetCommandInfo(interp, "::echo_glob_overload", &info)==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   *pxFunc = overloadedGlobFunction;
sl@0:   *ppArg = interp;
sl@0:   return 1;
sl@0: }
sl@0: 
sl@0: static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
sl@0:   int rc = SQLITE_OK;
sl@0:   echo_vtab *p = (echo_vtab *)vtab;
sl@0: 
sl@0:   if( simulateVtabError(p, "xRename") ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0:   if( p->isPattern ){
sl@0:     int nThis = strlen(p->zThis);
sl@0:     char *zSql = sqlite3MPrintf(0, "ALTER TABLE %s RENAME TO %s%s", 
sl@0:         p->zTableName, zNewName, &p->zTableName[nThis]
sl@0:     );
sl@0:     rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
sl@0:     sqlite3_free(zSql);
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** A virtual table module that merely "echos" the contents of another
sl@0: ** table (like an SQL VIEW).
sl@0: */
sl@0: static sqlite3_module echoModule = {
sl@0:   0,                         /* iVersion */
sl@0:   echoCreate,
sl@0:   echoConnect,
sl@0:   echoBestIndex,
sl@0:   echoDisconnect, 
sl@0:   echoDestroy,
sl@0:   echoOpen,                  /* xOpen - open a cursor */
sl@0:   echoClose,                 /* xClose - close a cursor */
sl@0:   echoFilter,                /* xFilter - configure scan constraints */
sl@0:   echoNext,                  /* xNext - advance a cursor */
sl@0:   echoEof,                   /* xEof */
sl@0:   echoColumn,                /* xColumn - read data */
sl@0:   echoRowid,                 /* xRowid - read data */
sl@0:   echoUpdate,                /* xUpdate - write data */
sl@0:   echoBegin,                 /* xBegin - begin transaction */
sl@0:   echoSync,                  /* xSync - sync transaction */
sl@0:   echoCommit,                /* xCommit - commit transaction */
sl@0:   echoRollback,              /* xRollback - rollback transaction */
sl@0:   echoFindFunction,          /* xFindFunction - function overloading */
sl@0:   echoRename,                /* xRename - rename the table */
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** Decode a pointer to an sqlite3 object.
sl@0: */
sl@0: extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
sl@0: 
sl@0: static void moduleDestroy(void *p){
sl@0:   sqlite3_free(p);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Register the echo virtual table module.
sl@0: */
sl@0: static int register_echo_module(
sl@0:   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
sl@0:   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
sl@0:   int objc,              /* Number of arguments */
sl@0:   Tcl_Obj *CONST objv[]  /* Command arguments */
sl@0: ){
sl@0:   sqlite3 *db;
sl@0:   EchoModule *pMod;
sl@0:   if( objc!=2 ){
sl@0:     Tcl_WrongNumArgs(interp, 1, objv, "DB");
sl@0:     return TCL_ERROR;
sl@0:   }
sl@0:   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
sl@0:   pMod = sqlite3_malloc(sizeof(EchoModule));
sl@0:   pMod->interp = interp;
sl@0:   sqlite3_create_module_v2(db, "echo", &echoModule, (void*)pMod, moduleDestroy);
sl@0:   return TCL_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Tcl interface to sqlite3_declare_vtab, invoked as follows from Tcl:
sl@0: **
sl@0: ** sqlite3_declare_vtab DB SQL
sl@0: */
sl@0: static int declare_vtab(
sl@0:   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
sl@0:   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
sl@0:   int objc,              /* Number of arguments */
sl@0:   Tcl_Obj *CONST objv[]  /* Command arguments */
sl@0: ){
sl@0:   sqlite3 *db;
sl@0:   int rc;
sl@0:   if( objc!=3 ){
sl@0:     Tcl_WrongNumArgs(interp, 1, objv, "DB SQL");
sl@0:     return TCL_ERROR;
sl@0:   }
sl@0:   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
sl@0:   rc = sqlite3_declare_vtab(db, Tcl_GetString(objv[2]));
sl@0:   if( rc!=SQLITE_OK ){
sl@0:     Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
sl@0:     return TCL_ERROR;
sl@0:   }
sl@0:   return TCL_OK;
sl@0: }
sl@0: 
sl@0: #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
sl@0: 
sl@0: /*
sl@0: ** Register commands with the TCL interpreter.
sl@0: */
sl@0: int Sqlitetest8_Init(Tcl_Interp *interp){
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0:   static struct {
sl@0:      char *zName;
sl@0:      Tcl_ObjCmdProc *xProc;
sl@0:      void *clientData;
sl@0:   } aObjCmd[] = {
sl@0:      { "register_echo_module",   register_echo_module, 0 },
sl@0:      { "sqlite3_declare_vtab",   declare_vtab, 0 },
sl@0:   };
sl@0:   int i;
sl@0:   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
sl@0:     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
sl@0:         aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
sl@0:   }
sl@0: #endif
sl@0:   return TCL_OK;
sl@0: }