src/test8.c

   1 /*
   2 ** 2006 June 10
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 ** Code for testing the virtual table interfaces.  This code
  13 ** is not included in the SQLite library.  It is used for automated
  14 ** testing of the SQLite library.
  15 */
  16 #include "sqliteInt.h"
  17 #if defined(INCLUDE_SQLITE_TCL_H)
  18 #  include "sqlite_tcl.h"
  19 #else
  20 #  include "tcl.h"
  21 #endif
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #ifndef SQLITE_OMIT_VIRTUALTABLE
  26
  27 typedef struct echo_vtab echo_vtab;
  28 typedef struct echo_cursor echo_cursor;
  29
  30 /*
  31 ** The test module defined in this file uses four global Tcl variables to
  32 ** commicate with test-scripts:
  33 **
  34 **     $::echo_module
  35 **     $::echo_module_sync_fail
  36 **     $::echo_module_begin_fail
  37 **     $::echo_module_cost
  38 **
  39 ** The variable ::echo_module is a list. Each time one of the following
  40 ** methods is called, one or more elements are appended to the list.
  41 ** This is used for automated testing of virtual table modules.
  42 **
  43 ** The ::echo_module_sync_fail variable is set by test scripts and read
  44 ** by code in this file. If it is set to the name of a real table in the
  45 ** the database, then all xSync operations on echo virtual tables that
  46 ** use the named table as a backing store will fail.
  47 */
  48
  49 /*
  50 ** Errors can be provoked within the following echo virtual table methods:
  51 **
  52 **   xBestIndex   xOpen     xFilter   xNext
  53 **   xColumn      xRowid    xUpdate   xSync
  54 **   xBegin       xRename
  55 **
  56 ** This is done by setting the global tcl variable:
  57 **
  58 **   echo_module_fail($method,$tbl)
  59 **
  60 ** where $method is set to the name of the virtual table method to fail
  61 ** (i.e. "xBestIndex") and $tbl is the name of the table being echoed (not
  62 ** the name of the virtual table, the name of the underlying real table).
  63 */
  64
  65 /*
  66 ** An echo virtual-table object.
  67 **
  68 ** echo.vtab.aIndex is an array of booleans. The nth entry is true if
  69 ** the nth column of the real table is the left-most column of an index
  70 ** (implicit or otherwise). In other words, if SQLite can optimize
  71 ** a query like "SELECT * FROM real_table WHERE col = ?".
  72 **
  73 ** Member variable aCol[] contains copies of the column names of the real
  74 ** table.
  75 */
  76 struct echo_vtab {
  77   sqlite3_vtab base;
  78   Tcl_Interp *interp;     /* Tcl interpreter containing debug variables */
  79   sqlite3 *db;            /* Database connection */
  80
  81   int isPattern;
  82   int inTransaction;      /* True if within a transaction */
  83   char *zThis;            /* Name of the echo table */
  84   char *zTableName;       /* Name of the real table */
  85   char *zLogName;         /* Name of the log table */
  86   int nCol;               /* Number of columns in the real table */
  87   int *aIndex;            /* Array of size nCol. True if column has an index */
  88   char **aCol;            /* Array of size nCol. Column names */
  89 };
  90
  91 /* An echo cursor object */
  92 struct echo_cursor {
  93   sqlite3_vtab_cursor base;
  94   sqlite3_stmt *pStmt;
  95 };
  96
  97 static int simulateVtabError(echo_vtab *p, const char *zMethod){
  98   const char *zErr;
  99   char zVarname[128];
 100   zVarname[127] = '\0';
 101   sqlite3_snprintf(127, zVarname, "echo_module_fail(%s,%s)", zMethod, p->zTableName);
 102   zErr = Tcl_GetVar(p->interp, zVarname, TCL_GLOBAL_ONLY);
 103   if( zErr ){
 104     p->base.zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", zErr);
 105   }
 106   return (zErr!=0);
 107 }
 108
 109 /*
 110 ** Convert an SQL-style quoted string into a normal string by removing
 111 ** the quote characters.  The conversion is done in-place.  If the
 112 ** input does not begin with a quote character, then this routine
 113 ** is a no-op.
 114 **
 115 ** Examples:
 116 **
 117 **     "abc"   becomes   abc
 118 **     'xyz'   becomes   xyz
 119 **     [pqr]   becomes   pqr
 120 **     `mno`   becomes   mno
 121 */
 122 static void dequoteString(char *z){
 123   int quote;
 124   int i, j;
 125   if( z==0 ) return;
 126   quote = z[0];
 127   switch( quote ){
 128     case '\'':  break;
 129     case '"':   break;
 130     case '`':   break;                /* For MySQL compatibility */
 131     case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
 132     default:    return;
 133   }
 134   for(i=1, j=0; z[i]; i++){
 135     if( z[i]==quote ){
 136       if( z[i+1]==quote ){
 137         z[j++] = quote;
 138         i++;
 139       }else{
 140         z[j++] = 0;
 141         break;
 142       }
 143     }else{
 144       z[j++] = z[i];
 145     }
 146   }
 147 }
 148
 149 /*
 150 ** Retrieve the column names for the table named zTab via database
 151 ** connection db. SQLITE_OK is returned on success, or an sqlite error
 152 ** code otherwise.
 153 **
 154 ** If successful, the number of columns is written to *pnCol. *paCol is
 155 ** set to point at sqlite3_malloc()'d space containing the array of
 156 ** nCol column names. The caller is responsible for calling sqlite3_free
 157 ** on *paCol.
 158 */
 159 static int getColumnNames(
 160   sqlite3 *db,
 161   const char *zTab,
 162   char ***paCol,
 163   int *pnCol
 164 ){
 165   char **aCol = 0;
 166   char *zSql;
 167   sqlite3_stmt *pStmt = 0;
 168   int rc = SQLITE_OK;
 169   int nCol = 0;
 170
 171   /* Prepare the statement "SELECT * FROM <tbl>". The column names
 172   ** of the result set of the compiled SELECT will be the same as
 173   ** the column names of table <tbl>.
 174   */
 175   zSql = sqlite3_mprintf("SELECT * FROM %Q", zTab);
 176   if( !zSql ){
 177     rc = SQLITE_NOMEM;
 178     goto out;
 179   }
 180   rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
 181   sqlite3_free(zSql);
 182
 183   if( rc==SQLITE_OK ){
 184     int ii;
 185     int nBytes;
 186     char *zSpace;
 187     nCol = sqlite3_column_count(pStmt);
 188
 189     /* Figure out how much space to allocate for the array of column names
 190     ** (including space for the strings themselves). Then allocate it.
 191     */
 192     nBytes = sizeof(char *) * nCol;
 193     for(ii=0; ii<nCol; ii++){
 194       const char *zName = sqlite3_column_name(pStmt, ii);
 195       if( !zName ){
 196         rc = SQLITE_NOMEM;
 197         goto out;
 198       }
 199       nBytes += (int)strlen(zName)+1;
 200     }
 201     aCol = (char **)sqlite3MallocZero(nBytes);
 202     if( !aCol ){
 203       rc = SQLITE_NOMEM;
 204       goto out;
 205     }
 206
 207     /* Copy the column names into the allocated space and set up the
 208     ** pointers in the aCol[] array.
 209     */
 210     zSpace = (char *)(&aCol[nCol]);
 211     for(ii=0; ii<nCol; ii++){
 212       aCol[ii] = zSpace;
 213       sqlite3_snprintf(nBytes, zSpace, "%s", sqlite3_column_name(pStmt,ii));
 214       zSpace += (int)strlen(zSpace) + 1;
 215     }
 216     assert( (zSpace-nBytes)==(char *)aCol );
 217   }
 218
 219   *paCol = aCol;
 220   *pnCol = nCol;
 221
 222 out:
 223   sqlite3_finalize(pStmt);
 224   return rc;
 225 }
 226
 227 /*
 228 ** Parameter zTab is the name of a table in database db with nCol
 229 ** columns. This function allocates an array of integers nCol in
 230 ** size and populates it according to any implicit or explicit
 231 ** indices on table zTab.
 232 **
 233 ** If successful, SQLITE_OK is returned and *paIndex set to point
 234 ** at the allocated array. Otherwise, an error code is returned.
 235 **
 236 ** See comments associated with the member variable aIndex above
 237 ** "struct echo_vtab" for details of the contents of the array.
 238 */
 239 static int getIndexArray(
 240   sqlite3 *db,             /* Database connection */
 241   const char *zTab,        /* Name of table in database db */
 242   int nCol,
 243   int **paIndex
 244 ){
 245   sqlite3_stmt *pStmt = 0;
 246   int *aIndex = 0;
 247   int rc;
 248   char *zSql;
 249
 250   /* Allocate space for the index array */
 251   aIndex = (int *)sqlite3MallocZero(sizeof(int) * nCol);
 252   if( !aIndex ){
 253     rc = SQLITE_NOMEM;
 254     goto get_index_array_out;
 255   }
 256
 257   /* Compile an sqlite pragma to loop through all indices on table zTab */
 258   zSql = sqlite3_mprintf("PRAGMA index_list(%s)", zTab);
 259   if( !zSql ){
 260     rc = SQLITE_NOMEM;
 261     goto get_index_array_out;
 262   }
 263   rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
 264   sqlite3_free(zSql);
 265
 266   /* For each index, figure out the left-most column and set the
 267   ** corresponding entry in aIndex[] to 1.
 268   */
 269   while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
 270     const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
 271     sqlite3_stmt *pStmt2 = 0;
 272     if( zIdx==0 ) continue;
 273     zSql = sqlite3_mprintf("PRAGMA index_info(%s)", zIdx);
 274     if( !zSql ){
 275       rc = SQLITE_NOMEM;
 276       goto get_index_array_out;
 277     }
 278     rc = sqlite3_prepare(db, zSql, -1, &pStmt2, 0);
 279     sqlite3_free(zSql);
 280     if( pStmt2 && sqlite3_step(pStmt2)==SQLITE_ROW ){
 281       int cid = sqlite3_column_int(pStmt2, 1);
 282       assert( cid>=0 && cid<nCol );
 283       aIndex[cid] = 1;
 284     }
 285     if( pStmt2 ){
 286       rc = sqlite3_finalize(pStmt2);
 287     }
 288     if( rc!=SQLITE_OK ){
 289       goto get_index_array_out;
 290     }
 291   }
 292
 293
 294 get_index_array_out:
 295   if( pStmt ){
 296     int rc2 = sqlite3_finalize(pStmt);
 297     if( rc==SQLITE_OK ){
 298       rc = rc2;
 299     }
 300   }
 301   if( rc!=SQLITE_OK ){
 302     sqlite3_free(aIndex);
 303     aIndex = 0;
 304   }
 305   *paIndex = aIndex;
 306   return rc;
 307 }
 308
 309 /*
 310 ** Global Tcl variable $echo_module is a list. This routine appends
 311 ** the string element zArg to that list in interpreter interp.
 312 */
 313 static void appendToEchoModule(Tcl_Interp *interp, const char *zArg){
 314   int flags = (TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_GLOBAL_ONLY);
 315   Tcl_SetVar(interp, "echo_module", (zArg?zArg:""), flags);
 316 }
 317
 318 /*
 319 ** This function is called from within the echo-modules xCreate and
 320 ** xConnect methods. The argc and argv arguments are copies of those
 321 ** passed to the calling method. This function is responsible for
 322 ** calling sqlite3_declare_vtab() to declare the schema of the virtual
 323 ** table being created or connected.
 324 **
 325 ** If the constructor was passed just one argument, i.e.:
 326 **
 327 **   CREATE TABLE t1 AS echo(t2);
 328 **
 329 ** Then t2 is assumed to be the name of a *real* database table. The
 330 ** schema of the virtual table is declared by passing a copy of the
 331 ** CREATE TABLE statement for the real table to sqlite3_declare_vtab().
 332 ** Hence, the virtual table should have exactly the same column names and
 333 ** types as the real table.
 334 */
 335 static int echoDeclareVtab(
 336   echo_vtab *pVtab,
 337   sqlite3 *db
 338 ){
 339   int rc = SQLITE_OK;
 340
 341   if( pVtab->zTableName ){
 342     sqlite3_stmt *pStmt = 0;
 343     rc = sqlite3_prepare(db,
 344         "SELECT sql FROM sqlite_schema WHERE type = 'table' AND name = ?",
 345         -1, &pStmt, 0);
 346     if( rc==SQLITE_OK ){
 347       sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
 348       if( sqlite3_step(pStmt)==SQLITE_ROW ){
 349         int rc2;
 350         const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
 351         rc = sqlite3_declare_vtab(db, zCreateTable);
 352         rc2 = sqlite3_finalize(pStmt);
 353         if( rc==SQLITE_OK ){
 354           rc = rc2;
 355         }
 356       } else {
 357         rc = sqlite3_finalize(pStmt);
 358         if( rc==SQLITE_OK ){
 359           rc = SQLITE_ERROR;
 360         }
 361       }
 362       if( rc==SQLITE_OK ){
 363         rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
 364       }
 365       if( rc==SQLITE_OK ){
 366         rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
 367       }
 368     }
 369   }
 370
 371   return rc;
 372 }
 373
 374 /*
 375 ** This function frees all runtime structures associated with the virtual
 376 ** table pVtab.
 377 */
 378 static int echoDestructor(sqlite3_vtab *pVtab){
 379   echo_vtab *p = (echo_vtab*)pVtab;
 380   sqlite3_free(p->aIndex);
 381   sqlite3_free(p->aCol);
 382   sqlite3_free(p->zThis);
 383   sqlite3_free(p->zTableName);
 384   sqlite3_free(p->zLogName);
 385   sqlite3_free(p);
 386   return 0;
 387 }
 388
 389 typedef struct EchoModule EchoModule;
 390 struct EchoModule {
 391   Tcl_Interp *interp;
 392   sqlite3 *db;
 393 };
 394
 395 /*
 396 ** This function is called to do the work of the xConnect() method -
 397 ** to allocate the required in-memory structures for a newly connected
 398 ** virtual table.
 399 */
 400 static int echoConstructor(
 401   sqlite3 *db,
 402   void *pAux,
 403   int argc, const char *const*argv,
 404   sqlite3_vtab **ppVtab,
 405   char **pzErr
 406 ){
 407   int rc;
 408   int i;
 409   echo_vtab *pVtab;
 410
 411   /* Allocate the sqlite3_vtab/echo_vtab structure itself */
 412   pVtab = sqlite3MallocZero( sizeof(*pVtab) );
 413   if( !pVtab ){
 414     return SQLITE_NOMEM;
 415   }
 416   pVtab->interp = ((EchoModule *)pAux)->interp;
 417   pVtab->db = db;
 418
 419   /* Allocate echo_vtab.zThis */
 420   pVtab->zThis = sqlite3_mprintf("%s", argv[2]);
 421   if( !pVtab->zThis ){
 422     echoDestructor((sqlite3_vtab *)pVtab);
 423     return SQLITE_NOMEM;
 424   }
 425
 426   /* Allocate echo_vtab.zTableName */
 427   if( argc>3 ){
 428     pVtab->zTableName = sqlite3_mprintf("%s", argv[3]);
 429     dequoteString(pVtab->zTableName);
 430     if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){
 431       char *z = sqlite3_mprintf("%s%s", argv[2], &(pVtab->zTableName[1]));
 432       sqlite3_free(pVtab->zTableName);
 433       pVtab->zTableName = z;
 434       pVtab->isPattern = 1;
 435     }
 436     if( !pVtab->zTableName ){
 437       echoDestructor((sqlite3_vtab *)pVtab);
 438       return SQLITE_NOMEM;
 439     }
 440   }
 441
 442   /* Log the arguments to this function to Tcl var ::echo_module */
 443   for(i=0; i<argc; i++){
 444     appendToEchoModule(pVtab->interp, argv[i]);
 445   }
 446
 447   /* Invoke sqlite3_declare_vtab and set up other members of the echo_vtab
 448   ** structure. If an error occurs, delete the sqlite3_vtab structure and
 449   ** return an error code.
 450   */
 451   rc = echoDeclareVtab(pVtab, db);
 452   if( rc!=SQLITE_OK ){
 453     echoDestructor((sqlite3_vtab *)pVtab);
 454     return rc;
 455   }
 456
 457   /* Success. Set *ppVtab and return */
 458   *ppVtab = &pVtab->base;
 459   return SQLITE_OK;
 460 }
 461
 462 /*
 463 ** Echo virtual table module xCreate method.
 464 */
 465 static int echoCreate(
 466   sqlite3 *db,
 467   void *pAux,
 468   int argc, const char *const*argv,
 469   sqlite3_vtab **ppVtab,
 470   char **pzErr
 471 ){
 472   int rc = SQLITE_OK;
 473   appendToEchoModule(((EchoModule *)pAux)->interp, "xCreate");
 474   rc = echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
 475
 476   /* If there were two arguments passed to the module at the SQL level
 477   ** (i.e. "CREATE VIRTUAL TABLE tbl USING echo(arg1, arg2)"), then
 478   ** the second argument is used as a table name. Attempt to create
 479   ** such a table with a single column, "logmsg". This table will
 480   ** be used to log calls to the xUpdate method. It will be deleted
 481   ** when the virtual table is DROPed.
 482   **
 483   ** Note: The main point of this is to test that we can drop tables
 484   ** from within an xDestroy method call.
 485   */
 486   if( rc==SQLITE_OK && argc==5 ){
 487     char *zSql;
 488     echo_vtab *pVtab = *(echo_vtab **)ppVtab;
 489     pVtab->zLogName = sqlite3_mprintf("%s", argv[4]);
 490     zSql = sqlite3_mprintf("CREATE TABLE %Q(logmsg)", pVtab->zLogName);
 491     rc = sqlite3_exec(db, zSql, 0, 0, 0);
 492     sqlite3_free(zSql);
 493     if( rc!=SQLITE_OK ){
 494       *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
 495     }
 496   }
 497
 498   if( *ppVtab && rc!=SQLITE_OK ){
 499     echoDestructor(*ppVtab);
 500     *ppVtab = 0;
 501   }
 502
 503   if( rc==SQLITE_OK ){
 504     (*(echo_vtab**)ppVtab)->inTransaction = 1;
 505   }
 506
 507   return rc;
 508 }
 509
 510 /*
 511 ** Echo virtual table module xConnect method.
 512 */
 513 static int echoConnect(
 514   sqlite3 *db,
 515   void *pAux,
 516   int argc, const char *const*argv,
 517   sqlite3_vtab **ppVtab,
 518   char **pzErr
 519 ){
 520   appendToEchoModule(((EchoModule *)pAux)->interp, "xConnect");
 521   return echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
 522 }
 523
 524 /*
 525 ** Echo virtual table module xDisconnect method.
 526 */
 527 static int echoDisconnect(sqlite3_vtab *pVtab){
 528   appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDisconnect");
 529   return echoDestructor(pVtab);
 530 }
 531
 532 /*
 533 ** Echo virtual table module xDestroy method.
 534 */
 535 static int echoDestroy(sqlite3_vtab *pVtab){
 536   int rc = SQLITE_OK;
 537   echo_vtab *p = (echo_vtab *)pVtab;
 538   appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDestroy");
 539
 540   /* Drop the "log" table, if one exists (see echoCreate() for details) */
 541   if( p && p->zLogName ){
 542     char *zSql;
 543     zSql = sqlite3_mprintf("DROP TABLE %Q", p->zLogName);
 544     rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
 545     sqlite3_free(zSql);
 546   }
 547
 548   if( rc==SQLITE_OK ){
 549     rc = echoDestructor(pVtab);
 550   }
 551   return rc;
 552 }
 553
 554 /*
 555 ** Echo virtual table module xOpen method.
 556 */
 557 static int echoOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
 558   echo_cursor *pCur;
 559   if( simulateVtabError((echo_vtab *)pVTab, "xOpen") ){
 560     return SQLITE_ERROR;
 561   }
 562   pCur = sqlite3MallocZero(sizeof(echo_cursor));
 563   *ppCursor = (sqlite3_vtab_cursor *)pCur;
 564   return (pCur ? SQLITE_OK : SQLITE_NOMEM);
 565 }
 566
 567 /*
 568 ** Echo virtual table module xClose method.
 569 */
 570 static int echoClose(sqlite3_vtab_cursor *cur){
 571   int rc;
 572   echo_cursor *pCur = (echo_cursor *)cur;
 573   sqlite3_stmt *pStmt = pCur->pStmt;
 574   pCur->pStmt = 0;
 575   sqlite3_free(pCur);
 576   rc = sqlite3_finalize(pStmt);
 577   return rc;
 578 }
 579
 580 /*
 581 ** Return non-zero if the cursor does not currently point to a valid record
 582 ** (i.e if the scan has finished), or zero otherwise.
 583 */
 584 static int echoEof(sqlite3_vtab_cursor *cur){
 585   return (((echo_cursor *)cur)->pStmt ? 0 : 1);
 586 }
 587
 588 /*
 589 ** Echo virtual table module xNext method.
 590 */
 591 static int echoNext(sqlite3_vtab_cursor *cur){
 592   int rc = SQLITE_OK;
 593   echo_cursor *pCur = (echo_cursor *)cur;
 594
 595   if( simulateVtabError((echo_vtab *)(cur->pVtab), "xNext") ){
 596     return SQLITE_ERROR;
 597   }
 598
 599   if( pCur->pStmt ){
 600     rc = sqlite3_step(pCur->pStmt);
 601     if( rc==SQLITE_ROW ){
 602       rc = SQLITE_OK;
 603     }else{
 604       rc = sqlite3_finalize(pCur->pStmt);
 605       pCur->pStmt = 0;
 606     }
 607   }
 608
 609   return rc;
 610 }
 611
 612 /*
 613 ** Echo virtual table module xColumn method.
 614 */
 615 static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
 616   int iCol = i + 1;
 617   sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
 618
 619   if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){
 620     return SQLITE_ERROR;
 621   }
 622
 623   if( !pStmt ){
 624     sqlite3_result_null(ctx);
 625   }else{
 626     assert( sqlite3_data_count(pStmt)>iCol );
 627     sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
 628   }
 629   return SQLITE_OK;
 630 }
 631
 632 /*
 633 ** Echo virtual table module xRowid method.
 634 */
 635 static int echoRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
 636   sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
 637
 638   if( simulateVtabError((echo_vtab *)(cur->pVtab), "xRowid") ){
 639     return SQLITE_ERROR;
 640   }
 641
 642   *pRowid = sqlite3_column_int64(pStmt, 0);
 643   return SQLITE_OK;
 644 }
 645
 646 /*
 647 ** Compute a simple hash of the null terminated string zString.
 648 **
 649 ** This module uses only sqlite3_index_info.idxStr, not
 650 ** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
 651 ** in echoBestIndex(), idxNum is set to the corresponding hash value.
 652 ** In echoFilter(), code assert()s that the supplied idxNum value is
 653 ** indeed the hash of the supplied idxStr.
 654 */
 655 static int hashString(const char *zString){
 656   u32 val = 0;
 657   int ii;
 658   for(ii=0; zString[ii]; ii++){
 659     val = (val << 3) + (int)zString[ii];
 660   }
 661   return (int)(val&0x7fffffff);
 662 }
 663
 664 /*
 665 ** Echo virtual table module xFilter method.
 666 */
 667 static int echoFilter(
 668   sqlite3_vtab_cursor *pVtabCursor,
 669   int idxNum, const char *idxStr,
 670   int argc, sqlite3_value **argv
 671 ){
 672   int rc;
 673   int i;
 674
 675   echo_cursor *pCur = (echo_cursor *)pVtabCursor;
 676   echo_vtab *pVtab = (echo_vtab *)pVtabCursor->pVtab;
 677   sqlite3 *db = pVtab->db;
 678
 679   if( simulateVtabError(pVtab, "xFilter") ){
 680     return SQLITE_ERROR;
 681   }
 682
 683   /* Check that idxNum matches idxStr */
 684   assert( idxNum==hashString(idxStr) );
 685
 686   /* Log arguments to the ::echo_module Tcl variable */
 687   appendToEchoModule(pVtab->interp, "xFilter");
 688   appendToEchoModule(pVtab->interp, idxStr);
 689   for(i=0; i<argc; i++){
 690     appendToEchoModule(pVtab->interp, (const char*)sqlite3_value_text(argv[i]));
 691   }
 692
 693   sqlite3_finalize(pCur->pStmt);
 694   pCur->pStmt = 0;
 695
 696   /* Prepare the SQL statement created by echoBestIndex and bind the
 697   ** runtime parameters passed to this function to it.
 698   */
 699   rc = sqlite3_prepare(db, idxStr, -1, &pCur->pStmt, 0);
 700   assert( pCur->pStmt || rc!=SQLITE_OK );
 701   for(i=0; rc==SQLITE_OK && i<argc; i++){
 702     rc = sqlite3_bind_value(pCur->pStmt, i+1, argv[i]);
 703   }
 704
 705   /* If everything was successful, advance to the first row of the scan */
 706   if( rc==SQLITE_OK ){
 707     rc = echoNext(pVtabCursor);
 708   }
 709
 710   return rc;
 711 }
 712
 713
 714 /*
 715 ** A helper function used by echoUpdate() and echoBestIndex() for
 716 ** manipulating strings in concert with the sqlite3_mprintf() function.
 717 **
 718 ** Parameter pzStr points to a pointer to a string allocated with
 719 ** sqlite3_mprintf. The second parameter, zAppend, points to another
 720 ** string. The two strings are concatenated together and *pzStr
 721 ** set to point at the result. The initial buffer pointed to by *pzStr
 722 ** is deallocated via sqlite3_free().
 723 **
 724 ** If the third argument, doFree, is true, then sqlite3_free() is
 725 ** also called to free the buffer pointed to by zAppend.
 726 */
 727 static void string_concat(char **pzStr, char *zAppend, int doFree, int *pRc){
 728   char *zIn = *pzStr;
 729   if( !zAppend && doFree && *pRc==SQLITE_OK ){
 730     *pRc = SQLITE_NOMEM;
 731   }
 732   if( *pRc!=SQLITE_OK ){
 733     sqlite3_free(zIn);
 734     zIn = 0;
 735   }else{
 736     if( zIn ){
 737       char *zTemp = zIn;
 738       zIn = sqlite3_mprintf("%s%s", zIn, zAppend);
 739       sqlite3_free(zTemp);
 740     }else{
 741       zIn = sqlite3_mprintf("%s", zAppend);
 742     }
 743     if( !zIn ){
 744       *pRc = SQLITE_NOMEM;
 745     }
 746   }
 747   *pzStr = zIn;
 748   if( doFree ){
 749     sqlite3_free(zAppend);
 750   }
 751 }
 752
 753 /*
 754 ** This function returns a pointer to an sqlite3_malloc()ed buffer
 755 ** containing the select-list (the thing between keywords SELECT and FROM)
 756 ** to query the underlying real table with for the scan described by
 757 ** argument pIdxInfo.
 758 **
 759 ** If the current SQLite version is earlier than 3.10.0, this is just "*"
 760 ** (select all columns). Or, for version 3.10.0 and greater, the list of
 761 ** columns identified by the pIdxInfo->colUsed mask.
 762 */
 763 static char *echoSelectList(echo_vtab *pTab, sqlite3_index_info *pIdxInfo){
 764   char *zRet = 0;
 765   if( sqlite3_libversion_number()<3010000 ){
 766     zRet = sqlite3_mprintf(", *");
 767   }else{
 768     int i;
 769     for(i=0; i<pTab->nCol; i++){
 770       if( pIdxInfo->colUsed & ((sqlite3_uint64)1 << (i>=63 ? 63 : i)) ){
 771         zRet = sqlite3_mprintf("%z, %s", zRet, pTab->aCol[i]);
 772       }else{
 773         zRet = sqlite3_mprintf("%z, NULL", zRet);
 774       }
 775       if( !zRet ) break;
 776     }
 777   }
 778   return zRet;
 779 }
 780
 781 /*
 782 ** The echo module implements the subset of query constraints and sort
 783 ** orders that may take advantage of SQLite indices on the underlying
 784 ** real table. For example, if the real table is declared as:
 785 **
 786 **     CREATE TABLE real(a, b, c);
 787 **     CREATE INDEX real_index ON real(b);
 788 **
 789 ** then the echo module handles WHERE or ORDER BY clauses that refer
 790 ** to the column "b", but not "a" or "c". If a multi-column index is
 791 ** present, only its left most column is considered.
 792 **
 793 ** This xBestIndex method encodes the proposed search strategy as
 794 ** an SQL query on the real table underlying the virtual echo module
 795 ** table and stores the query in sqlite3_index_info.idxStr. The SQL
 796 ** statement is of the form:
 797 **
 798 **   SELECT rowid, * FROM <real-table> ?<where-clause>? ?<order-by-clause>?
 799 **
 800 ** where the <where-clause> and <order-by-clause> are determined
 801 ** by the contents of the structure pointed to by the pIdxInfo argument.
 802 */
 803 static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
 804   int ii;
 805   char *zQuery = 0;
 806   char *zCol = 0;
 807   char *zNew;
 808   int nArg = 0;
 809   const char *zSep = "WHERE";
 810   echo_vtab *pVtab = (echo_vtab *)tab;
 811   sqlite3_stmt *pStmt = 0;
 812   Tcl_Interp *interp = pVtab->interp;
 813
 814   int nRow = 0;
 815   int useIdx = 0;
 816   int rc = SQLITE_OK;
 817   int useCost = 0;
 818   double cost = 0;
 819   int isIgnoreUsable = 0;
 820   if( Tcl_GetVar(interp, "echo_module_ignore_usable", TCL_GLOBAL_ONLY) ){
 821     isIgnoreUsable = 1;
 822   }
 823
 824   if( simulateVtabError(pVtab, "xBestIndex") ){
 825     return SQLITE_ERROR;
 826   }
 827
 828   /* Determine the number of rows in the table and store this value in local
 829   ** variable nRow. The 'estimated-cost' of the scan will be the number of
 830   ** rows in the table for a linear scan, or the log (base 2) of the
 831   ** number of rows if the proposed scan uses an index.
 832   */
 833   if( Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY) ){
 834     cost = atof(Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY));
 835     useCost = 1;
 836   } else {
 837     zQuery = sqlite3_mprintf("SELECT count(*) FROM %Q", pVtab->zTableName);
 838     if( !zQuery ){
 839       return SQLITE_NOMEM;
 840     }
 841     rc = sqlite3_prepare(pVtab->db, zQuery, -1, &pStmt, 0);
 842     sqlite3_free(zQuery);
 843     if( rc!=SQLITE_OK ){
 844       return rc;
 845     }
 846     sqlite3_step(pStmt);
 847     nRow = sqlite3_column_int(pStmt, 0);
 848     rc = sqlite3_finalize(pStmt);
 849     if( rc!=SQLITE_OK ){
 850       return rc;
 851     }
 852   }
 853
 854   zCol = echoSelectList(pVtab, pIdxInfo);
 855   if( !zCol ) return SQLITE_NOMEM;
 856   zQuery = sqlite3_mprintf("SELECT rowid%z FROM %Q", zCol, pVtab->zTableName);
 857   if( !zQuery ) return SQLITE_NOMEM;
 858
 859   for(ii=0; ii<pIdxInfo->nConstraint; ii++){
 860     const struct sqlite3_index_constraint *pConstraint;
 861     struct sqlite3_index_constraint_usage *pUsage;
 862     int iCol;
 863
 864     pConstraint = &pIdxInfo->aConstraint[ii];
 865     pUsage = &pIdxInfo->aConstraintUsage[ii];
 866
 867     if( !isIgnoreUsable && !pConstraint->usable ) continue;
 868
 869     iCol = pConstraint->iColumn;
 870     if( iCol<0 || pVtab->aIndex[iCol] ){
 871       char *zNewCol = iCol>=0 ? pVtab->aCol[iCol] : "rowid";
 872       char *zOp = 0;
 873       useIdx = 1;
 874       switch( pConstraint->op ){
 875         case SQLITE_INDEX_CONSTRAINT_EQ:
 876           zOp = "="; break;
 877         case SQLITE_INDEX_CONSTRAINT_LT:
 878           zOp = "<"; break;
 879         case SQLITE_INDEX_CONSTRAINT_GT:
 880           zOp = ">"; break;
 881         case SQLITE_INDEX_CONSTRAINT_LE:
 882           zOp = "<="; break;
 883         case SQLITE_INDEX_CONSTRAINT_GE:
 884           zOp = ">="; break;
 885         case SQLITE_INDEX_CONSTRAINT_MATCH:
 886           /* Purposely translate the MATCH operator into a LIKE, which
 887           ** will be used by the next block of code to construct a new
 888           ** query.  It should also be noted here that the next block
 889           ** of code requires the first letter of this operator to be
 890           ** in upper-case to trigger the special MATCH handling (i.e.
 891           ** wrapping the bound parameter with literal '%'s).
 892           */
 893           zOp = "LIKE"; break;
 894         case SQLITE_INDEX_CONSTRAINT_LIKE:
 895           zOp = "like"; break;
 896         case SQLITE_INDEX_CONSTRAINT_GLOB:
 897           zOp = "glob"; break;
 898         case SQLITE_INDEX_CONSTRAINT_REGEXP:
 899           zOp = "regexp"; break;
 900       }
 901       if( zOp ){
 902         if( zOp[0]=='L' ){
 903           zNew = sqlite3_mprintf(" %s %s LIKE (SELECT '%%'||?||'%%')",
 904               zSep, zNewCol);
 905         } else {
 906           zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zNewCol, zOp);
 907         }
 908         string_concat(&zQuery, zNew, 1, &rc);
 909         zSep = "AND";
 910         pUsage->argvIndex = ++nArg;
 911         pUsage->omit = 1;
 912       }
 913     }
 914   }
 915
 916   /* If there is only one term in the ORDER BY clause, and it is
 917   ** on a column that this virtual table has an index for, then consume
 918   ** the ORDER BY clause.
 919   */
 920   if( pIdxInfo->nOrderBy==1 && (
 921         pIdxInfo->aOrderBy->iColumn<0 ||
 922         pVtab->aIndex[pIdxInfo->aOrderBy->iColumn]) ){
 923     int iCol = pIdxInfo->aOrderBy->iColumn;
 924     char *zNewCol = iCol>=0 ? pVtab->aCol[iCol] : "rowid";
 925     char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
 926     zNew = sqlite3_mprintf(" ORDER BY %s %s", zNewCol, zDir);
 927     string_concat(&zQuery, zNew, 1, &rc);
 928     pIdxInfo->orderByConsumed = 1;
 929   }
 930
 931   appendToEchoModule(pVtab->interp, "xBestIndex");;
 932   appendToEchoModule(pVtab->interp, zQuery);
 933
 934   if( !zQuery ){
 935     return rc;
 936   }
 937   pIdxInfo->idxNum = hashString(zQuery);
 938   pIdxInfo->idxStr = zQuery;
 939   pIdxInfo->needToFreeIdxStr = 1;
 940   if( useCost ){
 941     pIdxInfo->estimatedCost = cost;
 942   }else if( useIdx ){
 943     /* Approximation of log2(nRow). */
 944     for( ii=0; ii<(sizeof(int)*8)-1; ii++ ){
 945       if( nRow & (1<<ii) ){
 946         pIdxInfo->estimatedCost = (double)ii;
 947       }
 948     }
 949   }else{
 950     pIdxInfo->estimatedCost = (double)nRow;
 951   }
 952   return rc;
 953 }
 954
 955 /*
 956 ** The xUpdate method for echo module virtual tables.
 957 **
 958 **    apData[0]  apData[1]  apData[2..]
 959 **
 960 **    INTEGER                              DELETE
 961 **
 962 **    INTEGER    NULL       (nCol args)    UPDATE (do not set rowid)
 963 **    INTEGER    INTEGER    (nCol args)    UPDATE (with SET rowid = <arg1>)
 964 **
 965 **    NULL       NULL       (nCol args)    INSERT INTO (automatic rowid value)
 966 **    NULL       INTEGER    (nCol args)    INSERT (incl. rowid value)
 967 **
 968 */
 969 int echoUpdate(
 970   sqlite3_vtab *tab,
 971   int nData,
 972   sqlite3_value **apData,
 973   sqlite_int64 *pRowid
 974 ){
 975   echo_vtab *pVtab = (echo_vtab *)tab;
 976   sqlite3 *db = pVtab->db;
 977   int rc = SQLITE_OK;
 978
 979   sqlite3_stmt *pStmt = 0;
 980   char *z = 0;               /* SQL statement to execute */
 981   int bindArgZero = 0;       /* True to bind apData[0] to sql var no. nData */
 982   int bindArgOne = 0;        /* True to bind apData[1] to sql var no. 1 */
 983   int i;                     /* Counter variable used by for loops */
 984
 985   assert( nData==pVtab->nCol+2 || nData==1 );
 986
 987   /* Ticket #3083 - make sure we always start a transaction prior to
 988   ** making any changes to a virtual table */
 989   assert( pVtab->inTransaction );
 990
 991   if( simulateVtabError(pVtab, "xUpdate") ){
 992     return SQLITE_ERROR;
 993   }
 994
 995   /* If apData[0] is an integer and nData>1 then do an UPDATE */
 996   if( nData>1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
 997     char *zSep = " SET";
 998     z = sqlite3_mprintf("UPDATE %Q", pVtab->zTableName);
 999     if( !z ){
1000       rc = SQLITE_NOMEM;
1001     }
1002
1003     bindArgOne = (apData[1] && sqlite3_value_type(apData[1])==SQLITE_INTEGER);
1004     bindArgZero = 1;
1005
1006     if( bindArgOne ){
1007        string_concat(&z, " SET rowid=?1 ", 0, &rc);
1008        zSep = ",";
1009     }
1010     for(i=2; i<nData; i++){
1011       if( apData[i]==0 ) continue;
1012       string_concat(&z, sqlite3_mprintf(
1013           "%s %Q=?%d", zSep, pVtab->aCol[i-2], i), 1, &rc);
1014       zSep = ",";
1015     }
1016     string_concat(&z, sqlite3_mprintf(" WHERE rowid=?%d", nData), 1, &rc);
1017   }
1018
1019   /* If apData[0] is an integer and nData==1 then do a DELETE */
1020   else if( nData==1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
1021     z = sqlite3_mprintf("DELETE FROM %Q WHERE rowid = ?1", pVtab->zTableName);
1022     if( !z ){
1023       rc = SQLITE_NOMEM;
1024     }
1025     bindArgZero = 1;
1026   }
1027
1028   /* If the first argument is NULL and there are more than two args, INSERT */
1029   else if( nData>2 && sqlite3_value_type(apData[0])==SQLITE_NULL ){
1030     int ii;
1031     char *zInsert = 0;
1032     char *zValues = 0;
1033
1034     zInsert = sqlite3_mprintf("INSERT INTO %Q (", pVtab->zTableName);
1035     if( !zInsert ){
1036       rc = SQLITE_NOMEM;
1037     }
1038     if( sqlite3_value_type(apData[1])==SQLITE_INTEGER ){
1039       bindArgOne = 1;
1040       zValues = sqlite3_mprintf("?");
1041       string_concat(&zInsert, "rowid", 0, &rc);
1042     }
1043
1044     assert((pVtab->nCol+2)==nData);
1045     for(ii=2; ii<nData; ii++){
1046       string_concat(&zInsert,
1047           sqlite3_mprintf("%s%Q", zValues?", ":"", pVtab->aCol[ii-2]), 1, &rc);
1048       string_concat(&zValues,
1049           sqlite3_mprintf("%s?%d", zValues?", ":"", ii), 1, &rc);
1050     }
1051
1052     string_concat(&z, zInsert, 1, &rc);
1053     string_concat(&z, ") VALUES(", 0, &rc);
1054     string_concat(&z, zValues, 1, &rc);
1055     string_concat(&z, ")", 0, &rc);
1056   }
1057
1058   /* Anything else is an error */
1059   else{
1060     assert(0);
1061     return SQLITE_ERROR;
1062   }
1063
1064   if( rc==SQLITE_OK ){
1065     rc = sqlite3_prepare(db, z, -1, &pStmt, 0);
1066   }
1067   assert( rc!=SQLITE_OK || pStmt );
1068   sqlite3_free(z);
1069   if( rc==SQLITE_OK ) {
1070     if( bindArgZero ){
1071       sqlite3_bind_value(pStmt, nData, apData[0]);
1072     }
1073     if( bindArgOne ){
1074       sqlite3_bind_value(pStmt, 1, apData[1]);
1075     }
1076     for(i=2; i<nData && rc==SQLITE_OK; i++){
1077       if( apData[i] ) rc = sqlite3_bind_value(pStmt, i, apData[i]);
1078     }
1079     if( rc==SQLITE_OK ){
1080       sqlite3_step(pStmt);
1081       rc = sqlite3_finalize(pStmt);
1082     }else{
1083       sqlite3_finalize(pStmt);
1084     }
1085   }
1086
1087   if( pRowid && rc==SQLITE_OK ){
1088     *pRowid = sqlite3_last_insert_rowid(db);
1089   }
1090   if( rc!=SQLITE_OK ){
1091     tab->zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", sqlite3_errmsg(db));
1092   }
1093
1094   return rc;
1095 }
1096
1097 /*
1098 ** xBegin, xSync, xCommit and xRollback callbacks for echo module
1099 ** virtual tables. Do nothing other than add the name of the callback
1100 ** to the $::echo_module Tcl variable.
1101 */
1102 static int echoTransactionCall(sqlite3_vtab *tab, const char *zCall){
1103   char *z;
1104   echo_vtab *pVtab = (echo_vtab *)tab;
1105   z = sqlite3_mprintf("echo(%s)", pVtab->zTableName);
1106   if( z==0 ) return SQLITE_NOMEM;
1107   appendToEchoModule(pVtab->interp, zCall);
1108   appendToEchoModule(pVtab->interp, z);
1109   sqlite3_free(z);
1110   return SQLITE_OK;
1111 }
1112 static int echoBegin(sqlite3_vtab *tab){
1113   int rc;
1114   echo_vtab *pVtab = (echo_vtab *)tab;
1115   Tcl_Interp *interp = pVtab->interp;
1116   const char *zVal;
1117
1118   /* Ticket #3083 - do not start a transaction if we are already in
1119   ** a transaction */
1120   assert( !pVtab->inTransaction );
1121
1122   if( simulateVtabError(pVtab, "xBegin") ){
1123     return SQLITE_ERROR;
1124   }
1125
1126   rc = echoTransactionCall(tab, "xBegin");
1127
1128   if( rc==SQLITE_OK ){
1129     /* Check if the $::echo_module_begin_fail variable is defined. If it is,
1130     ** and it is set to the name of the real table underlying this virtual
1131     ** echo module table, then cause this xSync operation to fail.
1132     */
1133     zVal = Tcl_GetVar(interp, "echo_module_begin_fail", TCL_GLOBAL_ONLY);
1134     if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
1135       rc = SQLITE_ERROR;
1136     }
1137   }
1138   if( rc==SQLITE_OK ){
1139     pVtab->inTransaction = 1;
1140   }
1141   return rc;
1142 }
1143 static int echoSync(sqlite3_vtab *tab){
1144   int rc;
1145   echo_vtab *pVtab = (echo_vtab *)tab;
1146   Tcl_Interp *interp = pVtab->interp;
1147   const char *zVal;
1148
1149   /* Ticket #3083 - Only call xSync if we have previously started a
1150   ** transaction */
1151   assert( pVtab->inTransaction );
1152
1153   if( simulateVtabError(pVtab, "xSync") ){
1154     return SQLITE_ERROR;
1155   }
1156
1157   rc = echoTransactionCall(tab, "xSync");
1158
1159   if( rc==SQLITE_OK ){
1160     /* Check if the $::echo_module_sync_fail variable is defined. If it is,
1161     ** and it is set to the name of the real table underlying this virtual
1162     ** echo module table, then cause this xSync operation to fail.
1163     */
1164     zVal = Tcl_GetVar(interp, "echo_module_sync_fail", TCL_GLOBAL_ONLY);
1165     if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
1166       rc = -1;
1167     }
1168   }
1169   return rc;
1170 }
1171 static int echoCommit(sqlite3_vtab *tab){
1172   echo_vtab *pVtab = (echo_vtab*)tab;
1173   int rc;
1174
1175   /* Ticket #3083 - Only call xCommit if we have previously started
1176   ** a transaction */
1177   assert( pVtab->inTransaction );
1178
1179   if( simulateVtabError(pVtab, "xCommit") ){
1180     return SQLITE_ERROR;
1181   }
1182
1183   sqlite3BeginBenignMalloc();
1184   rc = echoTransactionCall(tab, "xCommit");
1185   sqlite3EndBenignMalloc();
1186   pVtab->inTransaction = 0;
1187   return rc;
1188 }
1189 static int echoRollback(sqlite3_vtab *tab){
1190   int rc;
1191   echo_vtab *pVtab = (echo_vtab*)tab;
1192
1193   /* Ticket #3083 - Only call xRollback if we have previously started
1194   ** a transaction */
1195   assert( pVtab->inTransaction );
1196
1197   rc = echoTransactionCall(tab, "xRollback");
1198   pVtab->inTransaction = 0;
1199   return rc;
1200 }
1201
1202 /*
1203 ** Implementation of "GLOB" function on the echo module.  Pass
1204 ** all arguments to the ::echo_glob_overload procedure of TCL
1205 ** and return the result of that procedure as a string.
1206 */
1207 static void overloadedGlobFunction(
1208   sqlite3_context *pContext,
1209   int nArg,
1210   sqlite3_value **apArg
1211 ){
1212   Tcl_Interp *interp = sqlite3_user_data(pContext);
1213   Tcl_DString str;
1214   int i;
1215   int rc;
1216   Tcl_DStringInit(&str);
1217   Tcl_DStringAppendElement(&str, "::echo_glob_overload");
1218   for(i=0; i<nArg; i++){
1219     Tcl_DStringAppendElement(&str, (char*)sqlite3_value_text(apArg[i]));
1220   }
1221   rc = Tcl_Eval(interp, Tcl_DStringValue(&str));
1222   Tcl_DStringFree(&str);
1223   if( rc ){
1224     sqlite3_result_error(pContext, Tcl_GetStringResult(interp), -1);
1225   }else{
1226     sqlite3_result_text(pContext, Tcl_GetStringResult(interp),
1227                         -1, SQLITE_TRANSIENT);
1228   }
1229   Tcl_ResetResult(interp);
1230 }
1231
1232 /*
1233 ** This is the xFindFunction implementation for the echo module.
1234 ** SQLite calls this routine when the first argument of a function
1235 ** is a column of an echo virtual table.  This routine can optionally
1236 ** override the implementation of that function.  It will choose to
1237 ** do so if the function is named "glob", and a TCL command named
1238 ** ::echo_glob_overload exists.
1239 */
1240 static int echoFindFunction(
1241   sqlite3_vtab *vtab,
1242   int nArg,
1243   const char *zFuncName,
1244   void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
1245   void **ppArg
1246 ){
1247   echo_vtab *pVtab = (echo_vtab *)vtab;
1248   Tcl_Interp *interp = pVtab->interp;
1249   Tcl_CmdInfo info;
1250   if( strcmp(zFuncName,"glob")!=0 ){
1251     return 0;
1252   }
1253   if( Tcl_GetCommandInfo(interp, "::echo_glob_overload", &info)==0 ){
1254     return 0;
1255   }
1256   *pxFunc = overloadedGlobFunction;
1257   *ppArg = interp;
1258   return 1;
1259 }
1260
1261 static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
1262   int rc = SQLITE_OK;
1263   echo_vtab *p = (echo_vtab *)vtab;
1264
1265   if( simulateVtabError(p, "xRename") ){
1266     return SQLITE_ERROR;
1267   }
1268
1269   if( p->isPattern ){
1270     int nThis = (int)strlen(p->zThis);
1271     char *zSql = sqlite3_mprintf("ALTER TABLE %s RENAME TO %s%s",
1272         p->zTableName, zNewName, &p->zTableName[nThis]
1273     );
1274     rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
1275     sqlite3_free(zSql);
1276   }
1277
1278   return rc;
1279 }
1280
1281 static int echoSavepoint(sqlite3_vtab *pVTab, int iSavepoint){
1282   assert( pVTab );
1283   return SQLITE_OK;
1284 }
1285
1286 static int echoRelease(sqlite3_vtab *pVTab, int iSavepoint){
1287   assert( pVTab );
1288   return SQLITE_OK;
1289 }
1290
1291 static int echoRollbackTo(sqlite3_vtab *pVTab, int iSavepoint){
1292   assert( pVTab );
1293   return SQLITE_OK;
1294 }
1295
1296 /*
1297 ** A virtual table module that merely "echos" the contents of another
1298 ** table (like an SQL VIEW).
1299 */
1300 static sqlite3_module echoModule = {
1301   1,                         /* iVersion */
1302   echoCreate,
1303   echoConnect,
1304   echoBestIndex,
1305   echoDisconnect,
1306   echoDestroy,
1307   echoOpen,                  /* xOpen - open a cursor */
1308   echoClose,                 /* xClose - close a cursor */
1309   echoFilter,                /* xFilter - configure scan constraints */
1310   echoNext,                  /* xNext - advance a cursor */
1311   echoEof,                   /* xEof */
1312   echoColumn,                /* xColumn - read data */
1313   echoRowid,                 /* xRowid - read data */
1314   echoUpdate,                /* xUpdate - write data */
1315   echoBegin,                 /* xBegin - begin transaction */
1316   echoSync,                  /* xSync - sync transaction */
1317   echoCommit,                /* xCommit - commit transaction */
1318   echoRollback,              /* xRollback - rollback transaction */
1319   echoFindFunction,          /* xFindFunction - function overloading */
1320   echoRename                 /* xRename - rename the table */
1321 };
1322
1323 static sqlite3_module echoModuleV2 = {
1324   2,                         /* iVersion */
1325   echoCreate,
1326   echoConnect,
1327   echoBestIndex,
1328   echoDisconnect,
1329   echoDestroy,
1330   echoOpen,                  /* xOpen - open a cursor */
1331   echoClose,                 /* xClose - close a cursor */
1332   echoFilter,                /* xFilter - configure scan constraints */
1333   echoNext,                  /* xNext - advance a cursor */
1334   echoEof,                   /* xEof */
1335   echoColumn,                /* xColumn - read data */
1336   echoRowid,                 /* xRowid - read data */
1337   echoUpdate,                /* xUpdate - write data */
1338   echoBegin,                 /* xBegin - begin transaction */
1339   echoSync,                  /* xSync - sync transaction */
1340   echoCommit,                /* xCommit - commit transaction */
1341   echoRollback,              /* xRollback - rollback transaction */
1342   echoFindFunction,          /* xFindFunction - function overloading */
1343   echoRename,                /* xRename - rename the table */
1344   echoSavepoint,
1345   echoRelease,
1346   echoRollbackTo
1347 };
1348
1349 /*
1350 ** Decode a pointer to an sqlite3 object.
1351 */
1352 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
1353 extern const char *sqlite3ErrName(int);
1354
1355 static void moduleDestroy(void *p){
1356   EchoModule *pMod = (EchoModule*)p;
1357   sqlite3_create_function(pMod->db, "function_that_does_not_exist_0982ma98",
1358                           SQLITE_ANY, 1, 0, 0, 0, 0);
1359   sqlite3_free(p);
1360 }
1361
1362 /*
1363 ** Register the echo virtual table module.
1364 */
1365 static int SQLITE_TCLAPI register_echo_module(
1366   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1367   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
1368   int objc,              /* Number of arguments */
1369   Tcl_Obj *CONST objv[]  /* Command arguments */
1370 ){
1371   int rc;
1372   sqlite3 *db;
1373   EchoModule *pMod;
1374   if( objc!=2 ){
1375     Tcl_WrongNumArgs(interp, 1, objv, "DB");
1376     return TCL_ERROR;
1377   }
1378   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1379
1380   /* Virtual table module "echo" */
1381   pMod = sqlite3_malloc(sizeof(EchoModule));
1382   pMod->interp = interp;
1383   pMod->db = db;
1384   rc = sqlite3_create_module_v2(
1385       db, "echo", &echoModule, (void*)pMod, moduleDestroy
1386   );
1387
1388   /* Virtual table module "echo_v2" */
1389   if( rc==SQLITE_OK ){
1390     pMod = sqlite3_malloc(sizeof(EchoModule));
1391     pMod->interp = interp;
1392     pMod->db = db;
1393     rc = sqlite3_create_module_v2(db, "echo_v2",
1394         &echoModuleV2, (void*)pMod, moduleDestroy
1395     );
1396   }
1397
1398   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
1399   return TCL_OK;
1400 }
1401
1402 /*
1403 ** Tcl interface to sqlite3_declare_vtab, invoked as follows from Tcl:
1404 **
1405 ** sqlite3_declare_vtab DB SQL
1406 */
1407 static int SQLITE_TCLAPI declare_vtab(
1408   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1409   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
1410   int objc,              /* Number of arguments */
1411   Tcl_Obj *CONST objv[]  /* Command arguments */
1412 ){
1413   sqlite3 *db;
1414   int rc;
1415   if( objc!=3 ){
1416     Tcl_WrongNumArgs(interp, 1, objv, "DB SQL");
1417     return TCL_ERROR;
1418   }
1419   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1420   rc = sqlite3_declare_vtab(db, Tcl_GetString(objv[2]));
1421   if( rc!=SQLITE_OK ){
1422     Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
1423     return TCL_ERROR;
1424   }
1425   return TCL_OK;
1426 }
1427
1428 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
1429
1430 /*
1431 ** Register commands with the TCL interpreter.
1432 */
1433 int Sqlitetest8_Init(Tcl_Interp *interp){
1434 #ifndef SQLITE_OMIT_VIRTUALTABLE
1435   static struct {
1436      char *zName;
1437      Tcl_ObjCmdProc *xProc;
1438      void *clientData;
1439   } aObjCmd[] = {
1440      { "register_echo_module",       register_echo_module, 0 },
1441      { "sqlite3_declare_vtab",       declare_vtab, 0 },
1442   };
1443   int i;
1444   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
1445     Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
1446         aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
1447   }
1448 #endif
1449   return TCL_OK;
1450 }