src/test_bestindex.c

   1 /*
   2 ** 2016-03-01
   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 xBestIndex method and the query
  13 ** planner.
  14 */
  15
  16
  17 /*
  18 ** INSTRUCTIONS
  19 **
  20 ** This module exports a single tcl command - [register_tcl_module]. When
  21 ** invoked, it registers a special virtual table module with a database
  22 ** connection.
  23 **
  24 ** The virtual table is currently read-only. And always returns zero rows.
  25 ** It is created with a single argument - the name of a Tcl command - as
  26 ** follows:
  27 **
  28 **   CREATE VIRTUAL TABLE x1 USING tcl(tcl_command);
  29 **
  30 ** The command [tcl_command] is invoked when the table is first created (or
  31 ** connected), when the xBestIndex() method is invoked and when the xFilter()
  32 ** method is called. When it is created (or connected), it is invoked as
  33 ** follows:
  34 **
  35 **   tcl_command xConnect
  36 **
  37 ** In this case the return value of the script is passed to the
  38 ** sqlite3_declare_vtab() function to create the virtual table schema.
  39 **
  40 ** When the xBestIndex() method is called by SQLite, the Tcl command is
  41 ** invoked as:
  42 **
  43 **   tcl_command xBestIndex CONSTRAINTS ORDERBY MASK
  44 **
  45 ** where CONSTRAINTS is a tcl representation of the aConstraints[] array,
  46 ** ORDERBY is a representation of the contents of the aOrderBy[] array and
  47 ** MASK is a copy of sqlite3_index_info.colUsed. For example if the virtual
  48 ** table is declared as:
  49 **
  50 **   CREATE TABLE x1(a, b, c)
  51 **
  52 ** and the query is:
  53 **
  54 **   SELECT * FROM x1 WHERE a=? AND c<? ORDER BY b, c;
  55 **
  56 ** then the Tcl command is:
  57 **
  58 **   tcl_command xBestIndex                                  \
  59 **     {{op eq column 0 usable 1} {op lt column 2 usable 1}} \
  60 **     {{column 1 desc 0} {column 2 desc 0}}                 \
  61 **     7
  62 **
  63 ** The return value of the script is a list of key-value pairs used to
  64 ** populate the output fields of the sqlite3_index_info structure. Possible
  65 ** keys and the usage of the accompanying values are:
  66 **
  67 **   "orderby"          (value of orderByConsumed flag)
  68 **   "cost"             (value of estimatedCost field)
  69 **   "rows"             (value of estimatedRows field)
  70 **   "use"              (index of used constraint in aConstraint[])
  71 **   "omit"             (like "use", but also sets omit flag)
  72 **   "idxnum"           (value of idxNum field)
  73 **   "idxstr"           (value of idxStr field)
  74 **
  75 ** Refer to code below for further details.
  76 **
  77 ** When SQLite calls the xFilter() method, this module invokes the following
  78 ** Tcl script:
  79 **
  80 **   tcl_command xFilter IDXNUM IDXSTR ARGLIST
  81 **
  82 ** IDXNUM and IDXSTR are the values of the idxNum and idxStr parameters
  83 ** passed to xFilter. ARGLIST is a Tcl list containing each of the arguments
  84 ** passed to xFilter in text form.
  85 **
  86 ** As with xBestIndex(), the return value of the script is interpreted as a
  87 ** list of key-value pairs. There is currently only one key defined - "sql".
  88 ** The value must be the full text of an SQL statement that returns the data
  89 ** for the current scan. The leftmost column returned by the SELECT is assumed
  90 ** to contain the rowid. Other columns must follow, in order from left to
  91 ** right.
  92 */
  93
  94
  95 #include "sqliteInt.h"
  96 #if defined(INCLUDE_SQLITE_TCL_H)
  97 #  include "sqlite_tcl.h"
  98 #else
  99 #  include "tcl.h"
 100 #endif
 101
 102 #ifndef SQLITE_OMIT_VIRTUALTABLE
 103
 104 typedef struct tcl_vtab tcl_vtab;
 105 typedef struct tcl_cursor tcl_cursor;
 106
 107 /*
 108 ** A fs virtual-table object
 109 */
 110 struct tcl_vtab {
 111   sqlite3_vtab base;
 112   Tcl_Interp *interp;
 113   Tcl_Obj *pCmd;
 114   sqlite3 *db;
 115 };
 116
 117 /* A tcl cursor object */
 118 struct tcl_cursor {
 119   sqlite3_vtab_cursor base;
 120   sqlite3_stmt *pStmt;            /* Read data from here */
 121 };
 122
 123 /*
 124 ** Dequote string z in place.
 125 */
 126 static void tclDequote(char *z){
 127   char q = z[0];
 128
 129   /* Set stack variable q to the close-quote character */
 130   if( q=='[' || q=='\'' || q=='"' || q=='`' ){
 131     int iIn = 1;
 132     int iOut = 0;
 133     if( q=='[' ) q = ']';
 134
 135     while( ALWAYS(z[iIn]) ){
 136       if( z[iIn]==q ){
 137         if( z[iIn+1]!=q ){
 138           /* Character iIn was the close quote. */
 139           iIn++;
 140           break;
 141         }else{
 142           /* Character iIn and iIn+1 form an escaped quote character. Skip
 143           ** the input cursor past both and copy a single quote character
 144           ** to the output buffer. */
 145           iIn += 2;
 146           z[iOut++] = q;
 147         }
 148       }else{
 149         z[iOut++] = z[iIn++];
 150       }
 151     }
 152
 153     z[iOut] = '\0';
 154   }
 155 }
 156
 157 /*
 158 ** This function is the implementation of both the xConnect and xCreate
 159 ** methods of the fs virtual table.
 160 **
 161 ** The argv[] array contains the following:
 162 **
 163 **   argv[0]   -> module name  ("fs")
 164 **   argv[1]   -> database name
 165 **   argv[2]   -> table name
 166 **   argv[...] -> other module argument fields.
 167 */
 168 static int tclConnect(
 169   sqlite3 *db,
 170   void *pAux,
 171   int argc, const char *const*argv,
 172   sqlite3_vtab **ppVtab,
 173   char **pzErr
 174 ){
 175   Tcl_Interp *interp = (Tcl_Interp*)pAux;
 176   tcl_vtab *pTab = 0;
 177   char *zCmd = 0;
 178   Tcl_Obj *pScript = 0;
 179   int rc = SQLITE_OK;
 180
 181   if( argc!=4 ){
 182     *pzErr = sqlite3_mprintf("wrong number of arguments");
 183     return SQLITE_ERROR;
 184   }
 185
 186   zCmd = sqlite3_malloc64(strlen(argv[3])+1);
 187   pTab = (tcl_vtab*)sqlite3_malloc64(sizeof(tcl_vtab));
 188   if( zCmd && pTab ){
 189     memcpy(zCmd, argv[3], strlen(argv[3])+1);
 190     tclDequote(zCmd);
 191     memset(pTab, 0, sizeof(tcl_vtab));
 192
 193     pTab->pCmd = Tcl_NewStringObj(zCmd, -1);
 194     pTab->interp = interp;
 195     pTab->db = db;
 196     Tcl_IncrRefCount(pTab->pCmd);
 197
 198     pScript = Tcl_DuplicateObj(pTab->pCmd);
 199     Tcl_IncrRefCount(pScript);
 200     Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xConnect", -1));
 201
 202     rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL);
 203     if( rc!=TCL_OK ){
 204       *pzErr = sqlite3_mprintf("%s", Tcl_GetStringResult(interp));
 205       rc = SQLITE_ERROR;
 206     }else{
 207       rc = sqlite3_declare_vtab(db, Tcl_GetStringResult(interp));
 208     }
 209
 210     if( rc!=SQLITE_OK ){
 211       sqlite3_free(pTab);
 212       pTab = 0;
 213     }
 214   }else{
 215     rc = SQLITE_NOMEM;
 216   }
 217
 218   sqlite3_free(zCmd);
 219   *ppVtab = &pTab->base;
 220   return rc;
 221 }
 222
 223 /* The xDisconnect and xDestroy methods are also the same */
 224 static int tclDisconnect(sqlite3_vtab *pVtab){
 225   tcl_vtab *pTab = (tcl_vtab*)pVtab;
 226   Tcl_DecrRefCount(pTab->pCmd);
 227   sqlite3_free(pTab);
 228   return SQLITE_OK;
 229 }
 230
 231 /*
 232 ** Open a new tcl cursor.
 233 */
 234 static int tclOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
 235   tcl_cursor *pCur;
 236   pCur = sqlite3_malloc(sizeof(tcl_cursor));
 237   if( pCur==0 ) return SQLITE_NOMEM;
 238   memset(pCur, 0, sizeof(tcl_cursor));
 239   *ppCursor = &pCur->base;
 240   return SQLITE_OK;
 241 }
 242
 243 /*
 244 ** Close a tcl cursor.
 245 */
 246 static int tclClose(sqlite3_vtab_cursor *cur){
 247   tcl_cursor *pCur = (tcl_cursor *)cur;
 248   if( pCur ){
 249     sqlite3_finalize(pCur->pStmt);
 250     sqlite3_free(pCur);
 251   }
 252   return SQLITE_OK;
 253 }
 254
 255 static int tclNext(sqlite3_vtab_cursor *pVtabCursor){
 256   tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
 257   if( pCsr->pStmt ){
 258     tcl_vtab *pTab = (tcl_vtab*)(pVtabCursor->pVtab);
 259     int rc = sqlite3_step(pCsr->pStmt);
 260     if( rc!=SQLITE_ROW ){
 261       const char *zErr;
 262       rc = sqlite3_finalize(pCsr->pStmt);
 263       pCsr->pStmt = 0;
 264       if( rc!=SQLITE_OK ){
 265         zErr = sqlite3_errmsg(pTab->db);
 266         pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
 267       }
 268     }
 269   }
 270   return SQLITE_OK;
 271 }
 272
 273 static int tclFilter(
 274   sqlite3_vtab_cursor *pVtabCursor,
 275   int idxNum, const char *idxStr,
 276   int argc, sqlite3_value **argv
 277 ){
 278   tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
 279   tcl_vtab *pTab = (tcl_vtab*)(pVtabCursor->pVtab);
 280   Tcl_Interp *interp = pTab->interp;
 281   Tcl_Obj *pScript;
 282   Tcl_Obj *pArg;
 283   int ii;
 284   int rc;
 285
 286   pScript = Tcl_DuplicateObj(pTab->pCmd);
 287   Tcl_IncrRefCount(pScript);
 288   Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xFilter", -1));
 289   Tcl_ListObjAppendElement(interp, pScript, Tcl_NewIntObj(idxNum));
 290   if( idxStr ){
 291     Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj(idxStr, -1));
 292   }else{
 293     Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("", -1));
 294   }
 295
 296   pArg = Tcl_NewObj();
 297   Tcl_IncrRefCount(pArg);
 298   for(ii=0; ii<argc; ii++){
 299     const char *zVal = (const char*)sqlite3_value_text(argv[ii]);
 300     Tcl_Obj *pVal;
 301     if( zVal==0 ){
 302       sqlite3_value *pMem;
 303       pVal = Tcl_NewObj();
 304       for(rc=sqlite3_vtab_in_first(argv[ii], &pMem);
 305           rc==SQLITE_OK && pMem;
 306           rc=sqlite3_vtab_in_next(argv[ii], &pMem)
 307       ){
 308         Tcl_Obj *pVal2 = 0;
 309         zVal = (const char*)sqlite3_value_text(pMem);
 310         if( zVal ){
 311           pVal2 = Tcl_NewStringObj(zVal, -1);
 312         }else{
 313           pVal2 = Tcl_NewObj();
 314         }
 315         Tcl_ListObjAppendElement(interp, pVal, pVal2);
 316       }
 317     }else{
 318       pVal = Tcl_NewStringObj(zVal, -1);
 319     }
 320     Tcl_ListObjAppendElement(interp, pArg, pVal);
 321   }
 322   Tcl_ListObjAppendElement(interp, pScript, pArg);
 323   Tcl_DecrRefCount(pArg);
 324
 325   rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL);
 326   if( rc!=TCL_OK ){
 327     const char *zErr = Tcl_GetStringResult(interp);
 328     rc = SQLITE_ERROR;
 329     pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
 330   }else{
 331     /* Analyze the scripts return value. The return value should be a tcl
 332     ** list object with an even number of elements. The first element of each
 333     ** pair must be one of:
 334     **
 335     **   "sql"          (SQL statement to return data)
 336     */
 337     Tcl_Obj *pRes = Tcl_GetObjResult(interp);
 338     Tcl_Obj **apElem = 0;
 339     int nElem;
 340     rc = Tcl_ListObjGetElements(interp, pRes, &nElem, &apElem);
 341     if( rc!=TCL_OK ){
 342       const char *zErr = Tcl_GetStringResult(interp);
 343       rc = SQLITE_ERROR;
 344       pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
 345     }else{
 346       for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){
 347         const char *zCmd = Tcl_GetString(apElem[ii]);
 348         Tcl_Obj *p = apElem[ii+1];
 349         if( sqlite3_stricmp("sql", zCmd)==0 ){
 350           const char *zSql = Tcl_GetString(p);
 351           rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
 352           if( rc!=SQLITE_OK ){
 353             const char *zErr = sqlite3_errmsg(pTab->db);
 354             pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zErr);
 355           }
 356         }else{
 357           rc = SQLITE_ERROR;
 358           pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zCmd);
 359         }
 360       }
 361     }
 362   }
 363
 364   if( rc==SQLITE_OK ){
 365     rc = tclNext(pVtabCursor);
 366   }
 367   return rc;
 368 }
 369
 370 static int tclColumn(
 371   sqlite3_vtab_cursor *pVtabCursor,
 372   sqlite3_context *ctx,
 373   int i
 374 ){
 375   tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
 376   sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pStmt, i+1));
 377   return SQLITE_OK;
 378 }
 379
 380 static int tclRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){
 381   tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
 382   *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
 383   return SQLITE_OK;
 384 }
 385
 386 static int tclEof(sqlite3_vtab_cursor *pVtabCursor){
 387   tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
 388   return (pCsr->pStmt==0);
 389 }
 390
 391 static void testBestIndexObjConstraints(
 392   Tcl_Interp *interp,
 393   sqlite3_index_info *pIdxInfo
 394 ){
 395   int ii;
 396   Tcl_Obj *pRes = Tcl_NewObj();
 397   Tcl_IncrRefCount(pRes);
 398   for(ii=0; ii<pIdxInfo->nConstraint; ii++){
 399     struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];
 400     Tcl_Obj *pElem = Tcl_NewObj();
 401     const char *zOp = "?";
 402
 403     Tcl_IncrRefCount(pElem);
 404
 405     switch( pCons->op ){
 406       case SQLITE_INDEX_CONSTRAINT_EQ:
 407         zOp = "eq"; break;
 408       case SQLITE_INDEX_CONSTRAINT_GT:
 409         zOp = "gt"; break;
 410       case SQLITE_INDEX_CONSTRAINT_LE:
 411         zOp = "le"; break;
 412       case SQLITE_INDEX_CONSTRAINT_LT:
 413         zOp = "lt"; break;
 414       case SQLITE_INDEX_CONSTRAINT_GE:
 415         zOp = "ge"; break;
 416       case SQLITE_INDEX_CONSTRAINT_MATCH:
 417         zOp = "match"; break;
 418       case SQLITE_INDEX_CONSTRAINT_LIKE:
 419         zOp = "like"; break;
 420       case SQLITE_INDEX_CONSTRAINT_GLOB:
 421         zOp = "glob"; break;
 422       case SQLITE_INDEX_CONSTRAINT_REGEXP:
 423         zOp = "regexp"; break;
 424       case SQLITE_INDEX_CONSTRAINT_NE:
 425         zOp = "ne"; break;
 426       case SQLITE_INDEX_CONSTRAINT_ISNOT:
 427         zOp = "isnot"; break;
 428       case SQLITE_INDEX_CONSTRAINT_ISNOTNULL:
 429         zOp = "isnotnull"; break;
 430       case SQLITE_INDEX_CONSTRAINT_ISNULL:
 431         zOp = "isnull"; break;
 432       case SQLITE_INDEX_CONSTRAINT_IS:
 433         zOp = "is"; break;
 434       case SQLITE_INDEX_CONSTRAINT_LIMIT:
 435         zOp = "limit"; break;
 436       case SQLITE_INDEX_CONSTRAINT_OFFSET:
 437         zOp = "offset"; break;
 438     }
 439
 440     Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("op", -1));
 441     Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj(zOp, -1));
 442     Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("column", -1));
 443     Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->iColumn));
 444     Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("usable", -1));
 445     Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->usable));
 446
 447     Tcl_ListObjAppendElement(0, pRes, pElem);
 448     Tcl_DecrRefCount(pElem);
 449   }
 450
 451   Tcl_SetObjResult(interp, pRes);
 452   Tcl_DecrRefCount(pRes);
 453 }
 454
 455 static void testBestIndexObjOrderby(
 456   Tcl_Interp *interp,
 457   sqlite3_index_info *pIdxInfo
 458 ){
 459   int ii;
 460   Tcl_Obj *pRes = Tcl_NewObj();
 461   Tcl_IncrRefCount(pRes);
 462   for(ii=0; ii<pIdxInfo->nOrderBy; ii++){
 463     struct sqlite3_index_orderby const *pOrder = &pIdxInfo->aOrderBy[ii];
 464     Tcl_Obj *pElem = Tcl_NewObj();
 465     Tcl_IncrRefCount(pElem);
 466
 467     Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("column", -1));
 468     Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->iColumn));
 469     Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("desc", -1));
 470     Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->desc));
 471
 472     Tcl_ListObjAppendElement(0, pRes, pElem);
 473     Tcl_DecrRefCount(pElem);
 474   }
 475
 476   Tcl_SetObjResult(interp, pRes);
 477   Tcl_DecrRefCount(pRes);
 478 }
 479
 480 /*
 481 ** Implementation of the handle passed to each xBestIndex callback. This
 482 ** object features the following sub-commands:
 483 **
 484 **    $hdl constraints
 485 **    $hdl orderby
 486 **    $hdl mask
 487 **
 488 **    $hdl distinct
 489 **      Return the result (an integer) of calling sqlite3_vtab_distinct()
 490 **      on the index-info structure.
 491 **
 492 **    $hdl in IDX BOOLEAN
 493 **      Wrapper around sqlite3_vtab_in(). Returns an integer.
 494 **
 495 **    $hdl rhs_value IDX ?DEFAULT?
 496 **      Wrapper around sqlite3_vtab_rhs_value().
 497 */
 498 static int SQLITE_TCLAPI testBestIndexObj(
 499   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
 500   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 501   int objc,              /* Number of arguments */
 502   Tcl_Obj *CONST objv[]  /* Command arguments */
 503 ){
 504   const char *azSub[] = {
 505     "constraints",                /* 0 */
 506     "orderby",                    /* 1 */
 507     "mask",                       /* 2 */
 508     "distinct",                   /* 3 */
 509     "in",                         /* 4 */
 510     "rhs_value",                  /* 5 */
 511     0
 512   };
 513   int ii;
 514   sqlite3_index_info *pIdxInfo = (sqlite3_index_info*)clientData;
 515
 516   if( objc<2 ){
 517     Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND");
 518     return TCL_ERROR;
 519   }
 520   if( Tcl_GetIndexFromObj(interp, objv[1], azSub, "sub-command", 0, &ii) ){
 521     return TCL_ERROR;
 522   }
 523
 524   if( ii<4 && objc!=2 ){
 525     Tcl_WrongNumArgs(interp, 2, objv, "");
 526     return TCL_ERROR;
 527   }
 528   if( ii==4 && objc!=4 ){
 529     Tcl_WrongNumArgs(interp, 2, objv, "INDEX BOOLEAN");
 530     return TCL_ERROR;
 531   }
 532   if( ii==5 && objc!=3 && objc!=4 ){
 533     Tcl_WrongNumArgs(interp, 2, objv, "INDEX ?DEFAULT?");
 534     return TCL_ERROR;
 535   }
 536
 537   switch( ii ){
 538     case 0: assert( sqlite3_stricmp(azSub[ii], "constraints")==0 );
 539       testBestIndexObjConstraints(interp, pIdxInfo);
 540       break;
 541
 542     case 1: assert( sqlite3_stricmp(azSub[ii], "orderby")==0 );
 543       testBestIndexObjOrderby(interp, pIdxInfo);
 544       break;
 545
 546     case 2: assert( sqlite3_stricmp(azSub[ii], "mask")==0 );
 547       Tcl_SetObjResult(interp, Tcl_NewWideIntObj(pIdxInfo->colUsed));
 548       break;
 549
 550     case 3: assert( sqlite3_stricmp(azSub[ii], "distinct")==0 ); {
 551       int bDistinct = sqlite3_vtab_distinct(pIdxInfo);
 552       Tcl_SetObjResult(interp, Tcl_NewIntObj(bDistinct));
 553       break;
 554     }
 555
 556     case 4: assert( sqlite3_stricmp(azSub[ii], "in")==0 ); {
 557       int iCons;
 558       int bHandle;
 559       if( Tcl_GetIntFromObj(interp, objv[2], &iCons)
 560        || Tcl_GetBooleanFromObj(interp, objv[3], &bHandle)
 561       ){
 562         return TCL_ERROR;
 563       }
 564       Tcl_SetObjResult(interp,
 565           Tcl_NewIntObj(sqlite3_vtab_in(pIdxInfo, iCons, bHandle))
 566       );
 567       break;
 568     }
 569
 570     case 5: assert( sqlite3_stricmp(azSub[ii], "rhs_value")==0 ); {
 571       int iCons = 0;
 572       int rc;
 573       sqlite3_value *pVal = 0;
 574       const char *zVal = "";
 575       if( Tcl_GetIntFromObj(interp, objv[2], &iCons) ){
 576         return TCL_ERROR;
 577       }
 578       rc = sqlite3_vtab_rhs_value(pIdxInfo, iCons, &pVal);
 579       if( rc!=SQLITE_OK && rc!=SQLITE_NOTFOUND ){
 580         Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
 581         return TCL_ERROR;
 582       }
 583       if( pVal ){
 584         zVal = (const char*)sqlite3_value_text(pVal);
 585       }else if( objc==4 ){
 586         zVal = Tcl_GetString(objv[3]);
 587       }
 588       Tcl_SetObjResult(interp, Tcl_NewStringObj(zVal, -1));
 589       break;
 590     }
 591   }
 592
 593   return TCL_OK;
 594 }
 595
 596 static int tclBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
 597   tcl_vtab *pTab = (tcl_vtab*)tab;
 598   Tcl_Interp *interp = pTab->interp;
 599   int rc = SQLITE_OK;
 600
 601   static int iNext = 43;
 602   char zHdl[24];
 603   Tcl_Obj *pScript;
 604
 605   pScript = Tcl_DuplicateObj(pTab->pCmd);
 606   Tcl_IncrRefCount(pScript);
 607   Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xBestIndex", -1));
 608
 609   sqlite3_snprintf(sizeof(zHdl), zHdl, "bestindex%d", iNext++);
 610   Tcl_CreateObjCommand(interp, zHdl, testBestIndexObj, pIdxInfo, 0);
 611   Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj(zHdl, -1));
 612   rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL);
 613   Tcl_DeleteCommand(interp, zHdl);
 614   Tcl_DecrRefCount(pScript);
 615
 616   if( rc!=TCL_OK ){
 617     const char *zErr = Tcl_GetStringResult(interp);
 618     rc = SQLITE_ERROR;
 619     pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
 620   }else{
 621     /* Analyze the scripts return value. The return value should be a tcl
 622     ** list object with an even number of elements. The first element of each
 623     ** pair must be one of:
 624     **
 625     **   "orderby"          (value of orderByConsumed flag)
 626     **   "cost"             (value of estimatedCost field)
 627     **   "rows"             (value of estimatedRows field)
 628     **   "use"              (index of used constraint in aConstraint[])
 629     **   "idxnum"           (value of idxNum field)
 630     **   "idxstr"           (value of idxStr field)
 631     **   "omit"             (index of omitted constraint in aConstraint[])
 632     */
 633     Tcl_Obj *pRes = Tcl_GetObjResult(interp);
 634     Tcl_Obj **apElem = 0;
 635     int nElem;
 636     rc = Tcl_ListObjGetElements(interp, pRes, &nElem, &apElem);
 637     if( rc!=TCL_OK ){
 638       const char *zErr = Tcl_GetStringResult(interp);
 639       rc = SQLITE_ERROR;
 640       pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
 641     }else{
 642       int ii;
 643       int iArgv = 1;
 644       for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){
 645         const char *zCmd = Tcl_GetString(apElem[ii]);
 646         Tcl_Obj *p = apElem[ii+1];
 647         if( sqlite3_stricmp("cost", zCmd)==0 ){
 648           rc = Tcl_GetDoubleFromObj(interp, p, &pIdxInfo->estimatedCost);
 649         }else
 650         if( sqlite3_stricmp("orderby", zCmd)==0 ){
 651           rc = Tcl_GetIntFromObj(interp, p, &pIdxInfo->orderByConsumed);
 652         }else
 653         if( sqlite3_stricmp("idxnum", zCmd)==0 ){
 654           rc = Tcl_GetIntFromObj(interp, p, &pIdxInfo->idxNum);
 655         }else
 656         if( sqlite3_stricmp("idxstr", zCmd)==0 ){
 657           sqlite3_free(pIdxInfo->idxStr);
 658           pIdxInfo->idxStr = sqlite3_mprintf("%s", Tcl_GetString(p));
 659           pIdxInfo->needToFreeIdxStr = 1;
 660         }else
 661         if( sqlite3_stricmp("rows", zCmd)==0 ){
 662           Tcl_WideInt x = 0;
 663           rc = Tcl_GetWideIntFromObj(interp, p, &x);
 664           pIdxInfo->estimatedRows = (tRowcnt)x;
 665         }else
 666         if( sqlite3_stricmp("use", zCmd)==0
 667          || sqlite3_stricmp("omit", zCmd)==0
 668         ){
 669           int iCons;
 670           rc = Tcl_GetIntFromObj(interp, p, &iCons);
 671           if( rc==SQLITE_OK ){
 672             if( iCons<0 || iCons>=pIdxInfo->nConstraint ){
 673               rc = SQLITE_ERROR;
 674               pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %d", iCons);
 675             }else{
 676               int bOmit = (zCmd[0]=='o' || zCmd[0]=='O');
 677               pIdxInfo->aConstraintUsage[iCons].argvIndex = iArgv++;
 678               pIdxInfo->aConstraintUsage[iCons].omit = bOmit;
 679             }
 680           }
 681         }else{
 682           rc = SQLITE_ERROR;
 683           pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zCmd);
 684         }
 685         if( rc!=SQLITE_OK && pTab->base.zErrMsg==0 ){
 686           const char *zErr = Tcl_GetStringResult(interp);
 687           pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
 688         }
 689       }
 690     }
 691   }
 692
 693   return rc;
 694 }
 695
 696 /*
 697 ** A virtual table module that provides read-only access to a
 698 ** Tcl global variable namespace.
 699 */
 700 static sqlite3_module tclModule = {
 701   0,                         /* iVersion */
 702   tclConnect,
 703   tclConnect,
 704   tclBestIndex,
 705   tclDisconnect,
 706   tclDisconnect,
 707   tclOpen,                      /* xOpen - open a cursor */
 708   tclClose,                     /* xClose - close a cursor */
 709   tclFilter,                    /* xFilter - configure scan constraints */
 710   tclNext,                      /* xNext - advance a cursor */
 711   tclEof,                       /* xEof - check for end of scan */
 712   tclColumn,                    /* xColumn - read data */
 713   tclRowid,                     /* xRowid - read data */
 714   0,                           /* xUpdate */
 715   0,                           /* xBegin */
 716   0,                           /* xSync */
 717   0,                           /* xCommit */
 718   0,                           /* xRollback */
 719   0,                           /* xFindMethod */
 720   0,                           /* xRename */
 721 };
 722
 723 /*
 724 ** Decode a pointer to an sqlite3 object.
 725 */
 726 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
 727
 728 /*
 729 ** Register the echo virtual table module.
 730 */
 731 static int SQLITE_TCLAPI register_tcl_module(
 732   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
 733   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 734   int objc,              /* Number of arguments */
 735   Tcl_Obj *CONST objv[]  /* Command arguments */
 736 ){
 737   sqlite3 *db;
 738   if( objc!=2 ){
 739     Tcl_WrongNumArgs(interp, 1, objv, "DB");
 740     return TCL_ERROR;
 741   }
 742   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
 743 #ifndef SQLITE_OMIT_VIRTUALTABLE
 744   sqlite3_create_module(db, "tcl", &tclModule, (void *)interp);
 745 #endif
 746   return TCL_OK;
 747 }
 748
 749 #endif
 750
 751
 752 /*
 753 ** Register commands with the TCL interpreter.
 754 */
 755 int Sqlitetesttcl_Init(Tcl_Interp *interp){
 756 #ifndef SQLITE_OMIT_VIRTUALTABLE
 757   static struct {
 758      char *zName;
 759      Tcl_ObjCmdProc *xProc;
 760      void *clientData;
 761   } aObjCmd[] = {
 762      { "register_tcl_module",   register_tcl_module, 0 },
 763   };
 764   int i;
 765   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
 766     Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
 767         aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
 768   }
 769 #endif
 770   return TCL_OK;
 771 }