src/vtab.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 ** This file contains code used to help implement virtual tables.
  13 */
  14 #ifndef SQLITE_OMIT_VIRTUALTABLE
  15 #include "sqliteInt.h"
  16
  17 /*
  18 ** Before a virtual table xCreate() or xConnect() method is invoked, the
  19 ** sqlite3.pVtabCtx member variable is set to point to an instance of
  20 ** this struct allocated on the stack. It is used by the implementation of
  21 ** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which
  22 ** are invoked only from within xCreate and xConnect methods.
  23 */
  24 struct VtabCtx {
  25   VTable *pVTable;    /* The virtual table being constructed */
  26   Table *pTab;        /* The Table object to which the virtual table belongs */
  27   VtabCtx *pPrior;    /* Parent context (if any) */
  28   int bDeclared;      /* True after sqlite3_declare_vtab() is called */
  29 };
  30
  31 /*
  32 ** Construct and install a Module object for a virtual table.  When this
  33 ** routine is called, it is guaranteed that all appropriate locks are held
  34 ** and the module is not already part of the connection.
  35 **
  36 ** If there already exists a module with zName, replace it with the new one.
  37 ** If pModule==0, then delete the module zName if it exists.
  38 */
  39 Module *sqlite3VtabCreateModule(
  40   sqlite3 *db,                    /* Database in which module is registered */
  41   const char *zName,              /* Name assigned to this module */
  42   const sqlite3_module *pModule,  /* The definition of the module */
  43   void *pAux,                     /* Context pointer for xCreate/xConnect */
  44   void (*xDestroy)(void *)        /* Module destructor function */
  45 ){
  46   Module *pMod;
  47   Module *pDel;
  48   char *zCopy;
  49   if( pModule==0 ){
  50     zCopy = (char*)zName;
  51     pMod = 0;
  52   }else{
  53     int nName = sqlite3Strlen30(zName);
  54     pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1);
  55     if( pMod==0 ){
  56       sqlite3OomFault(db);
  57       return 0;
  58     }
  59     zCopy = (char *)(&pMod[1]);
  60     memcpy(zCopy, zName, nName+1);
  61     pMod->zName = zCopy;
  62     pMod->pModule = pModule;
  63     pMod->pAux = pAux;
  64     pMod->xDestroy = xDestroy;
  65     pMod->pEpoTab = 0;
  66     pMod->nRefModule = 1;
  67   }
  68   pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
  69   if( pDel ){
  70     if( pDel==pMod ){
  71       sqlite3OomFault(db);
  72       sqlite3DbFree(db, pDel);
  73       pMod = 0;
  74     }else{
  75       sqlite3VtabEponymousTableClear(db, pDel);
  76       sqlite3VtabModuleUnref(db, pDel);
  77     }
  78   }
  79   return pMod;
  80 }
  81
  82 /*
  83 ** The actual function that does the work of creating a new module.
  84 ** This function implements the sqlite3_create_module() and
  85 ** sqlite3_create_module_v2() interfaces.
  86 */
  87 static int createModule(
  88   sqlite3 *db,                    /* Database in which module is registered */
  89   const char *zName,              /* Name assigned to this module */
  90   const sqlite3_module *pModule,  /* The definition of the module */
  91   void *pAux,                     /* Context pointer for xCreate/xConnect */
  92   void (*xDestroy)(void *)        /* Module destructor function */
  93 ){
  94   int rc = SQLITE_OK;
  95
  96   sqlite3_mutex_enter(db->mutex);
  97   (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
  98   rc = sqlite3ApiExit(db, rc);
  99   if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
 100   sqlite3_mutex_leave(db->mutex);
 101   return rc;
 102 }
 103
 104
 105 /*
 106 ** External API function used to create a new virtual-table module.
 107 */
 108 int sqlite3_create_module(
 109   sqlite3 *db,                    /* Database in which module is registered */
 110   const char *zName,              /* Name assigned to this module */
 111   const sqlite3_module *pModule,  /* The definition of the module */
 112   void *pAux                      /* Context pointer for xCreate/xConnect */
 113 ){
 114 #ifdef SQLITE_ENABLE_API_ARMOR
 115   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
 116 #endif
 117   return createModule(db, zName, pModule, pAux, 0);
 118 }
 119
 120 /*
 121 ** External API function used to create a new virtual-table module.
 122 */
 123 int sqlite3_create_module_v2(
 124   sqlite3 *db,                    /* Database in which module is registered */
 125   const char *zName,              /* Name assigned to this module */
 126   const sqlite3_module *pModule,  /* The definition of the module */
 127   void *pAux,                     /* Context pointer for xCreate/xConnect */
 128   void (*xDestroy)(void *)        /* Module destructor function */
 129 ){
 130 #ifdef SQLITE_ENABLE_API_ARMOR
 131   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
 132 #endif
 133   return createModule(db, zName, pModule, pAux, xDestroy);
 134 }
 135
 136 /*
 137 ** External API to drop all virtual-table modules, except those named
 138 ** on the azNames list.
 139 */
 140 int sqlite3_drop_modules(sqlite3 *db, const char** azNames){
 141   HashElem *pThis, *pNext;
 142 #ifdef SQLITE_ENABLE_API_ARMOR
 143   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 144 #endif
 145   for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){
 146     Module *pMod = (Module*)sqliteHashData(pThis);
 147     pNext = sqliteHashNext(pThis);
 148     if( azNames ){
 149       int ii;
 150       for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
 151       if( azNames[ii]!=0 ) continue;
 152     }
 153     createModule(db, pMod->zName, 0, 0, 0);
 154   }
 155   return SQLITE_OK;
 156 }
 157
 158 /*
 159 ** Decrement the reference count on a Module object.  Destroy the
 160 ** module when the reference count reaches zero.
 161 */
 162 void sqlite3VtabModuleUnref(sqlite3 *db, Module *pMod){
 163   assert( pMod->nRefModule>0 );
 164   pMod->nRefModule--;
 165   if( pMod->nRefModule==0 ){
 166     if( pMod->xDestroy ){
 167       pMod->xDestroy(pMod->pAux);
 168     }
 169     assert( pMod->pEpoTab==0 );
 170     sqlite3DbFree(db, pMod);
 171   }
 172 }
 173
 174 /*
 175 ** Lock the virtual table so that it cannot be disconnected.
 176 ** Locks nest.  Every lock should have a corresponding unlock.
 177 ** If an unlock is omitted, resources leaks will occur.
 178 **
 179 ** If a disconnect is attempted while a virtual table is locked,
 180 ** the disconnect is deferred until all locks have been removed.
 181 */
 182 void sqlite3VtabLock(VTable *pVTab){
 183   pVTab->nRef++;
 184 }
 185
 186
 187 /*
 188 ** pTab is a pointer to a Table structure representing a virtual-table.
 189 ** Return a pointer to the VTable object used by connection db to access
 190 ** this virtual-table, if one has been created, or NULL otherwise.
 191 */
 192 VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
 193   VTable *pVtab;
 194   assert( IsVirtual(pTab) );
 195   for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
 196   return pVtab;
 197 }
 198
 199 /*
 200 ** Decrement the ref-count on a virtual table object. When the ref-count
 201 ** reaches zero, call the xDisconnect() method to delete the object.
 202 */
 203 void sqlite3VtabUnlock(VTable *pVTab){
 204   sqlite3 *db = pVTab->db;
 205
 206   assert( db );
 207   assert( pVTab->nRef>0 );
 208   assert( db->eOpenState==SQLITE_STATE_OPEN
 209        || db->eOpenState==SQLITE_STATE_ZOMBIE );
 210
 211   pVTab->nRef--;
 212   if( pVTab->nRef==0 ){
 213     sqlite3_vtab *p = pVTab->pVtab;
 214     if( p ){
 215       p->pModule->xDisconnect(p);
 216     }
 217     sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod);
 218     sqlite3DbFree(db, pVTab);
 219   }
 220 }
 221
 222 /*
 223 ** Table p is a virtual table. This function moves all elements in the
 224 ** p->u.vtab.p list to the sqlite3.pDisconnect lists of their associated
 225 ** database connections to be disconnected at the next opportunity.
 226 ** Except, if argument db is not NULL, then the entry associated with
 227 ** connection db is left in the p->u.vtab.p list.
 228 */
 229 static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
 230   VTable *pRet = 0;
 231   VTable *pVTable;
 232
 233   assert( IsVirtual(p) );
 234   pVTable = p->u.vtab.p;
 235   p->u.vtab.p = 0;
 236
 237   /* Assert that the mutex (if any) associated with the BtShared database
 238   ** that contains table p is held by the caller. See header comments
 239   ** above function sqlite3VtabUnlockList() for an explanation of why
 240   ** this makes it safe to access the sqlite3.pDisconnect list of any
 241   ** database connection that may have an entry in the p->u.vtab.p list.
 242   */
 243   assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
 244
 245   while( pVTable ){
 246     sqlite3 *db2 = pVTable->db;
 247     VTable *pNext = pVTable->pNext;
 248     assert( db2 );
 249     if( db2==db ){
 250       pRet = pVTable;
 251       p->u.vtab.p = pRet;
 252       pRet->pNext = 0;
 253     }else{
 254       pVTable->pNext = db2->pDisconnect;
 255       db2->pDisconnect = pVTable;
 256     }
 257     pVTable = pNext;
 258   }
 259
 260   assert( !db || pRet );
 261   return pRet;
 262 }
 263
 264 /*
 265 ** Table *p is a virtual table. This function removes the VTable object
 266 ** for table *p associated with database connection db from the linked
 267 ** list in p->pVTab. It also decrements the VTable ref count. This is
 268 ** used when closing database connection db to free all of its VTable
 269 ** objects without disturbing the rest of the Schema object (which may
 270 ** be being used by other shared-cache connections).
 271 */
 272 void sqlite3VtabDisconnect(sqlite3 *db, Table *p){
 273   VTable **ppVTab;
 274
 275   assert( IsVirtual(p) );
 276   assert( sqlite3BtreeHoldsAllMutexes(db) );
 277   assert( sqlite3_mutex_held(db->mutex) );
 278
 279   for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){
 280     if( (*ppVTab)->db==db  ){
 281       VTable *pVTab = *ppVTab;
 282       *ppVTab = pVTab->pNext;
 283       sqlite3VtabUnlock(pVTab);
 284       break;
 285     }
 286   }
 287 }
 288
 289
 290 /*
 291 ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
 292 **
 293 ** This function may only be called when the mutexes associated with all
 294 ** shared b-tree databases opened using connection db are held by the
 295 ** caller. This is done to protect the sqlite3.pDisconnect list. The
 296 ** sqlite3.pDisconnect list is accessed only as follows:
 297 **
 298 **   1) By this function. In this case, all BtShared mutexes and the mutex
 299 **      associated with the database handle itself must be held.
 300 **
 301 **   2) By function vtabDisconnectAll(), when it adds a VTable entry to
 302 **      the sqlite3.pDisconnect list. In this case either the BtShared mutex
 303 **      associated with the database the virtual table is stored in is held
 304 **      or, if the virtual table is stored in a non-sharable database, then
 305 **      the database handle mutex is held.
 306 **
 307 ** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously
 308 ** by multiple threads. It is thread-safe.
 309 */
 310 void sqlite3VtabUnlockList(sqlite3 *db){
 311   VTable *p = db->pDisconnect;
 312
 313   assert( sqlite3BtreeHoldsAllMutexes(db) );
 314   assert( sqlite3_mutex_held(db->mutex) );
 315
 316   if( p ){
 317     db->pDisconnect = 0;
 318     do {
 319       VTable *pNext = p->pNext;
 320       sqlite3VtabUnlock(p);
 321       p = pNext;
 322     }while( p );
 323   }
 324 }
 325
 326 /*
 327 ** Clear any and all virtual-table information from the Table record.
 328 ** This routine is called, for example, just before deleting the Table
 329 ** record.
 330 **
 331 ** Since it is a virtual-table, the Table structure contains a pointer
 332 ** to the head of a linked list of VTable structures. Each VTable
 333 ** structure is associated with a single sqlite3* user of the schema.
 334 ** The reference count of the VTable structure associated with database
 335 ** connection db is decremented immediately (which may lead to the
 336 ** structure being xDisconnected and free). Any other VTable structures
 337 ** in the list are moved to the sqlite3.pDisconnect list of the associated
 338 ** database connection.
 339 */
 340 void sqlite3VtabClear(sqlite3 *db, Table *p){
 341   assert( IsVirtual(p) );
 342   assert( db!=0 );
 343   if( db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
 344   if( p->u.vtab.azArg ){
 345     int i;
 346     for(i=0; i<p->u.vtab.nArg; i++){
 347       if( i!=1 ) sqlite3DbFree(db, p->u.vtab.azArg[i]);
 348     }
 349     sqlite3DbFree(db, p->u.vtab.azArg);
 350   }
 351 }
 352
 353 /*
 354 ** Add a new module argument to pTable->u.vtab.azArg[].
 355 ** The string is not copied - the pointer is stored.  The
 356 ** string will be freed automatically when the table is
 357 ** deleted.
 358 */
 359 static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){
 360   sqlite3_int64 nBytes;
 361   char **azModuleArg;
 362   sqlite3 *db = pParse->db;
 363
 364   assert( IsVirtual(pTable) );
 365   nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg);
 366   if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
 367     sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
 368   }
 369   azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes);
 370   if( azModuleArg==0 ){
 371     sqlite3DbFree(db, zArg);
 372   }else{
 373     int i = pTable->u.vtab.nArg++;
 374     azModuleArg[i] = zArg;
 375     azModuleArg[i+1] = 0;
 376     pTable->u.vtab.azArg = azModuleArg;
 377   }
 378 }
 379
 380 /*
 381 ** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
 382 ** statement.  The module name has been parsed, but the optional list
 383 ** of parameters that follow the module name are still pending.
 384 */
 385 void sqlite3VtabBeginParse(
 386   Parse *pParse,        /* Parsing context */
 387   Token *pName1,        /* Name of new table, or database name */
 388   Token *pName2,        /* Name of new table or NULL */
 389   Token *pModuleName,   /* Name of the module for the virtual table */
 390   int ifNotExists       /* No error if the table already exists */
 391 ){
 392   Table *pTable;        /* The new virtual table */
 393   sqlite3 *db;          /* Database connection */
 394
 395   sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);
 396   pTable = pParse->pNewTable;
 397   if( pTable==0 ) return;
 398   assert( 0==pTable->pIndex );
 399   pTable->eTabType = TABTYP_VTAB;
 400
 401   db = pParse->db;
 402
 403   assert( pTable->u.vtab.nArg==0 );
 404   addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName));
 405   addModuleArgument(pParse, pTable, 0);
 406   addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
 407   assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
 408        || (pParse->sNameToken.z==pName1->z && pName2->z==0)
 409   );
 410   pParse->sNameToken.n = (int)(
 411       &pModuleName->z[pModuleName->n] - pParse->sNameToken.z
 412   );
 413
 414 #ifndef SQLITE_OMIT_AUTHORIZATION
 415   /* Creating a virtual table invokes the authorization callback twice.
 416   ** The first invocation, to obtain permission to INSERT a row into the
 417   ** sqlite_schema table, has already been made by sqlite3StartTable().
 418   ** The second call, to obtain permission to create the table, is made now.
 419   */
 420   if( pTable->u.vtab.azArg ){
 421     int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
 422     assert( iDb>=0 ); /* The database the table is being created in */
 423     sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
 424             pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
 425   }
 426 #endif
 427 }
 428
 429 /*
 430 ** This routine takes the module argument that has been accumulating
 431 ** in pParse->zArg[] and appends it to the list of arguments on the
 432 ** virtual table currently under construction in pParse->pTable.
 433 */
 434 static void addArgumentToVtab(Parse *pParse){
 435   if( pParse->sArg.z && pParse->pNewTable ){
 436     const char *z = (const char*)pParse->sArg.z;
 437     int n = pParse->sArg.n;
 438     sqlite3 *db = pParse->db;
 439     addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
 440   }
 441 }
 442
 443 /*
 444 ** The parser calls this routine after the CREATE VIRTUAL TABLE statement
 445 ** has been completely parsed.
 446 */
 447 void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
 448   Table *pTab = pParse->pNewTable;  /* The table being constructed */
 449   sqlite3 *db = pParse->db;         /* The database connection */
 450
 451   if( pTab==0 ) return;
 452   assert( IsVirtual(pTab) );
 453   addArgumentToVtab(pParse);
 454   pParse->sArg.z = 0;
 455   if( pTab->u.vtab.nArg<1 ) return;
 456
 457   /* If the CREATE VIRTUAL TABLE statement is being entered for the
 458   ** first time (in other words if the virtual table is actually being
 459   ** created now instead of just being read out of sqlite_schema) then
 460   ** do additional initialization work and store the statement text
 461   ** in the sqlite_schema table.
 462   */
 463   if( !db->init.busy ){
 464     char *zStmt;
 465     char *zWhere;
 466     int iDb;
 467     int iReg;
 468     Vdbe *v;
 469
 470     sqlite3MayAbort(pParse);
 471
 472     /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
 473     if( pEnd ){
 474       pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
 475     }
 476     zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
 477
 478     /* A slot for the record has already been allocated in the
 479     ** schema table.  We just need to update that slot with all
 480     ** the information we've collected.
 481     **
 482     ** The VM register number pParse->regRowid holds the rowid of an
 483     ** entry in the sqlite_schema table that was created for this vtab
 484     ** by sqlite3StartTable().
 485     */
 486     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 487     sqlite3NestedParse(pParse,
 488       "UPDATE %Q." LEGACY_SCHEMA_TABLE " "
 489          "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
 490        "WHERE rowid=#%d",
 491       db->aDb[iDb].zDbSName,
 492       pTab->zName,
 493       pTab->zName,
 494       zStmt,
 495       pParse->regRowid
 496     );
 497     v = sqlite3GetVdbe(pParse);
 498     sqlite3ChangeCookie(pParse, iDb);
 499
 500     sqlite3VdbeAddOp0(v, OP_Expire);
 501     zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
 502     sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
 503     sqlite3DbFree(db, zStmt);
 504
 505     iReg = ++pParse->nMem;
 506     sqlite3VdbeLoadString(v, iReg, pTab->zName);
 507     sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
 508   }else{
 509     /* If we are rereading the sqlite_schema table create the in-memory
 510     ** record of the table. */
 511     Table *pOld;
 512     Schema *pSchema = pTab->pSchema;
 513     const char *zName = pTab->zName;
 514     assert( zName!=0 );
 515     sqlite3MarkAllShadowTablesOf(db, pTab);
 516     pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
 517     if( pOld ){
 518       sqlite3OomFault(db);
 519       assert( pTab==pOld );  /* Malloc must have failed inside HashInsert() */
 520       return;
 521     }
 522     pParse->pNewTable = 0;
 523   }
 524 }
 525
 526 /*
 527 ** The parser calls this routine when it sees the first token
 528 ** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
 529 */
 530 void sqlite3VtabArgInit(Parse *pParse){
 531   addArgumentToVtab(pParse);
 532   pParse->sArg.z = 0;
 533   pParse->sArg.n = 0;
 534 }
 535
 536 /*
 537 ** The parser calls this routine for each token after the first token
 538 ** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
 539 */
 540 void sqlite3VtabArgExtend(Parse *pParse, Token *p){
 541   Token *pArg = &pParse->sArg;
 542   if( pArg->z==0 ){
 543     pArg->z = p->z;
 544     pArg->n = p->n;
 545   }else{
 546     assert(pArg->z <= p->z);
 547     pArg->n = (int)(&p->z[p->n] - pArg->z);
 548   }
 549 }
 550
 551 /*
 552 ** Invoke a virtual table constructor (either xCreate or xConnect). The
 553 ** pointer to the function to invoke is passed as the fourth parameter
 554 ** to this procedure.
 555 */
 556 static int vtabCallConstructor(
 557   sqlite3 *db,
 558   Table *pTab,
 559   Module *pMod,
 560   int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
 561   char **pzErr
 562 ){
 563   VtabCtx sCtx;
 564   VTable *pVTable;
 565   int rc;
 566   const char *const*azArg;
 567   int nArg = pTab->u.vtab.nArg;
 568   char *zErr = 0;
 569   char *zModuleName;
 570   int iDb;
 571   VtabCtx *pCtx;
 572
 573   assert( IsVirtual(pTab) );
 574   azArg = (const char *const*)pTab->u.vtab.azArg;
 575
 576   /* Check that the virtual-table is not already being initialized */
 577   for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
 578     if( pCtx->pTab==pTab ){
 579       *pzErr = sqlite3MPrintf(db,
 580           "vtable constructor called recursively: %s", pTab->zName
 581       );
 582       return SQLITE_LOCKED;
 583     }
 584   }
 585
 586   zModuleName = sqlite3DbStrDup(db, pTab->zName);
 587   if( !zModuleName ){
 588     return SQLITE_NOMEM_BKPT;
 589   }
 590
 591   pVTable = sqlite3MallocZero(sizeof(VTable));
 592   if( !pVTable ){
 593     sqlite3OomFault(db);
 594     sqlite3DbFree(db, zModuleName);
 595     return SQLITE_NOMEM_BKPT;
 596   }
 597   pVTable->db = db;
 598   pVTable->pMod = pMod;
 599   pVTable->eVtabRisk = SQLITE_VTABRISK_Normal;
 600
 601   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 602   pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
 603
 604   /* Invoke the virtual table constructor */
 605   assert( &db->pVtabCtx );
 606   assert( xConstruct );
 607   sCtx.pTab = pTab;
 608   sCtx.pVTable = pVTable;
 609   sCtx.pPrior = db->pVtabCtx;
 610   sCtx.bDeclared = 0;
 611   db->pVtabCtx = &sCtx;
 612   pTab->nTabRef++;
 613   rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
 614   assert( pTab!=0 );
 615   assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
 616   sqlite3DeleteTable(db, pTab);
 617   db->pVtabCtx = sCtx.pPrior;
 618   if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
 619   assert( sCtx.pTab==pTab );
 620
 621   if( SQLITE_OK!=rc ){
 622     if( zErr==0 ){
 623       *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
 624     }else {
 625       *pzErr = sqlite3MPrintf(db, "%s", zErr);
 626       sqlite3_free(zErr);
 627     }
 628     sqlite3DbFree(db, pVTable);
 629   }else if( ALWAYS(pVTable->pVtab) ){
 630     /* Justification of ALWAYS():  A correct vtab constructor must allocate
 631     ** the sqlite3_vtab object if successful.  */
 632     memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0]));
 633     pVTable->pVtab->pModule = pMod->pModule;
 634     pMod->nRefModule++;
 635     pVTable->nRef = 1;
 636     if( sCtx.bDeclared==0 ){
 637       const char *zFormat = "vtable constructor did not declare schema: %s";
 638       *pzErr = sqlite3MPrintf(db, zFormat, zModuleName);
 639       sqlite3VtabUnlock(pVTable);
 640       rc = SQLITE_ERROR;
 641     }else{
 642       int iCol;
 643       u16 oooHidden = 0;
 644       /* If everything went according to plan, link the new VTable structure
 645       ** into the linked list headed by pTab->u.vtab.p. Then loop through the
 646       ** columns of the table to see if any of them contain the token "hidden".
 647       ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from
 648       ** the type string.  */
 649       pVTable->pNext = pTab->u.vtab.p;
 650       pTab->u.vtab.p = pVTable;
 651
 652       for(iCol=0; iCol<pTab->nCol; iCol++){
 653         char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
 654         int nType;
 655         int i = 0;
 656         nType = sqlite3Strlen30(zType);
 657         for(i=0; i<nType; i++){
 658           if( 0==sqlite3StrNICmp("hidden", &zType[i], 6)
 659            && (i==0 || zType[i-1]==' ')
 660            && (zType[i+6]=='\0' || zType[i+6]==' ')
 661           ){
 662             break;
 663           }
 664         }
 665         if( i<nType ){
 666           int j;
 667           int nDel = 6 + (zType[i+6] ? 1 : 0);
 668           for(j=i; (j+nDel)<=nType; j++){
 669             zType[j] = zType[j+nDel];
 670           }
 671           if( zType[i]=='\0' && i>0 ){
 672             assert(zType[i-1]==' ');
 673             zType[i-1] = '\0';
 674           }
 675           pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
 676           pTab->tabFlags |= TF_HasHidden;
 677           oooHidden = TF_OOOHidden;
 678         }else{
 679           pTab->tabFlags |= oooHidden;
 680         }
 681       }
 682     }
 683   }
 684
 685   sqlite3DbFree(db, zModuleName);
 686   return rc;
 687 }
 688
 689 /*
 690 ** This function is invoked by the parser to call the xConnect() method
 691 ** of the virtual table pTab. If an error occurs, an error code is returned
 692 ** and an error left in pParse.
 693 **
 694 ** This call is a no-op if table pTab is not a virtual table.
 695 */
 696 int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
 697   sqlite3 *db = pParse->db;
 698   const char *zMod;
 699   Module *pMod;
 700   int rc;
 701
 702   assert( pTab );
 703   assert( IsVirtual(pTab) );
 704   if( sqlite3GetVTable(db, pTab) ){
 705     return SQLITE_OK;
 706   }
 707
 708   /* Locate the required virtual table module */
 709   zMod = pTab->u.vtab.azArg[0];
 710   pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
 711
 712   if( !pMod ){
 713     const char *zModule = pTab->u.vtab.azArg[0];
 714     sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
 715     rc = SQLITE_ERROR;
 716   }else{
 717     char *zErr = 0;
 718     rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
 719     if( rc!=SQLITE_OK ){
 720       sqlite3ErrorMsg(pParse, "%s", zErr);
 721       pParse->rc = rc;
 722     }
 723     sqlite3DbFree(db, zErr);
 724   }
 725
 726   return rc;
 727 }
 728 /*
 729 ** Grow the db->aVTrans[] array so that there is room for at least one
 730 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
 731 */
 732 static int growVTrans(sqlite3 *db){
 733   const int ARRAY_INCR = 5;
 734
 735   /* Grow the sqlite3.aVTrans array if required */
 736   if( (db->nVTrans%ARRAY_INCR)==0 ){
 737     VTable **aVTrans;
 738     sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)*
 739                                  ((sqlite3_int64)db->nVTrans + ARRAY_INCR);
 740     aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
 741     if( !aVTrans ){
 742       return SQLITE_NOMEM_BKPT;
 743     }
 744     memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
 745     db->aVTrans = aVTrans;
 746   }
 747
 748   return SQLITE_OK;
 749 }
 750
 751 /*
 752 ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should
 753 ** have already been reserved using growVTrans().
 754 */
 755 static void addToVTrans(sqlite3 *db, VTable *pVTab){
 756   /* Add pVtab to the end of sqlite3.aVTrans */
 757   db->aVTrans[db->nVTrans++] = pVTab;
 758   sqlite3VtabLock(pVTab);
 759 }
 760
 761 /*
 762 ** This function is invoked by the vdbe to call the xCreate method
 763 ** of the virtual table named zTab in database iDb.
 764 **
 765 ** If an error occurs, *pzErr is set to point to an English language
 766 ** description of the error and an SQLITE_XXX error code is returned.
 767 ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
 768 */
 769 int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
 770   int rc = SQLITE_OK;
 771   Table *pTab;
 772   Module *pMod;
 773   const char *zMod;
 774
 775   pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
 776   assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p );
 777
 778   /* Locate the required virtual table module */
 779   zMod = pTab->u.vtab.azArg[0];
 780   pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
 781
 782   /* If the module has been registered and includes a Create method,
 783   ** invoke it now. If the module has not been registered, return an
 784   ** error. Otherwise, do nothing.
 785   */
 786   if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){
 787     *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);
 788     rc = SQLITE_ERROR;
 789   }else{
 790     rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
 791   }
 792
 793   /* Justification of ALWAYS():  The xConstructor method is required to
 794   ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
 795   if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
 796     rc = growVTrans(db);
 797     if( rc==SQLITE_OK ){
 798       addToVTrans(db, sqlite3GetVTable(db, pTab));
 799     }
 800   }
 801
 802   return rc;
 803 }
 804
 805 /*
 806 ** This function is used to set the schema of a virtual table.  It is only
 807 ** valid to call this function from within the xCreate() or xConnect() of a
 808 ** virtual table module.
 809 */
 810 int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
 811   VtabCtx *pCtx;
 812   int rc = SQLITE_OK;
 813   Table *pTab;
 814   Parse sParse;
 815   int initBusy;
 816   int i;
 817   const unsigned char *z;
 818   static const u8 aKeyword[] = { TK_CREATE, TK_TABLE, 0 };
 819
 820 #ifdef SQLITE_ENABLE_API_ARMOR
 821   if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
 822     return SQLITE_MISUSE_BKPT;
 823   }
 824 #endif
 825
 826   /* Verify that the first two keywords in the CREATE TABLE statement
 827   ** really are "CREATE" and "TABLE".  If this is not the case, then
 828   ** sqlite3_declare_vtab() is being misused.
 829   */
 830   z = (const unsigned char*)zCreateTable;
 831   for(i=0; aKeyword[i]; i++){
 832     int tokenType = 0;
 833     do{ z += sqlite3GetToken(z, &tokenType); }while( tokenType==TK_SPACE );
 834     if( tokenType!=aKeyword[i] ) return SQLITE_MISUSE_BKPT;
 835   }
 836
 837   sqlite3_mutex_enter(db->mutex);
 838   pCtx = db->pVtabCtx;
 839   if( !pCtx || pCtx->bDeclared ){
 840     sqlite3Error(db, SQLITE_MISUSE_BKPT);
 841     sqlite3_mutex_leave(db->mutex);
 842     return SQLITE_MISUSE_BKPT;
 843   }
 844
 845   pTab = pCtx->pTab;
 846   assert( IsVirtual(pTab) );
 847
 848   sqlite3ParseObjectInit(&sParse, db);
 849   sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
 850   sParse.disableTriggers = 1;
 851   /* We should never be able to reach this point while loading the
 852   ** schema.  Nevertheless, defend against that (turn off db->init.busy)
 853   ** in case a bug arises. */
 854   assert( db->init.busy==0 );
 855   initBusy = db->init.busy;
 856   db->init.busy = 0;
 857   sParse.nQueryLoop = 1;
 858   if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) ){
 859     assert( sParse.pNewTable!=0 );
 860     assert( !db->mallocFailed );
 861     assert( IsOrdinaryTable(sParse.pNewTable) );
 862     assert( sParse.zErrMsg==0 );
 863     if( !pTab->aCol ){
 864       Table *pNew = sParse.pNewTable;
 865       Index *pIdx;
 866       pTab->aCol = pNew->aCol;
 867       sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
 868       pTab->nNVCol = pTab->nCol = pNew->nCol;
 869       pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
 870       pNew->nCol = 0;
 871       pNew->aCol = 0;
 872       assert( pTab->pIndex==0 );
 873       assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
 874       if( !HasRowid(pNew)
 875        && pCtx->pVTable->pMod->pModule->xUpdate!=0
 876        && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
 877       ){
 878         /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
 879         ** or else must have a single-column PRIMARY KEY */
 880         rc = SQLITE_ERROR;
 881       }
 882       pIdx = pNew->pIndex;
 883       if( pIdx ){
 884         assert( pIdx->pNext==0 );
 885         pTab->pIndex = pIdx;
 886         pNew->pIndex = 0;
 887         pIdx->pTable = pTab;
 888       }
 889     }
 890     pCtx->bDeclared = 1;
 891   }else{
 892     sqlite3ErrorWithMsg(db, SQLITE_ERROR,
 893           (sParse.zErrMsg ? "%s" : 0), sParse.zErrMsg);
 894     sqlite3DbFree(db, sParse.zErrMsg);
 895     rc = SQLITE_ERROR;
 896   }
 897   sParse.eParseMode = PARSE_MODE_NORMAL;
 898
 899   if( sParse.pVdbe ){
 900     sqlite3VdbeFinalize(sParse.pVdbe);
 901   }
 902   sqlite3DeleteTable(db, sParse.pNewTable);
 903   sqlite3ParseObjectReset(&sParse);
 904   db->init.busy = initBusy;
 905
 906   assert( (rc&0xff)==rc );
 907   rc = sqlite3ApiExit(db, rc);
 908   sqlite3_mutex_leave(db->mutex);
 909   return rc;
 910 }
 911
 912 /*
 913 ** This function is invoked by the vdbe to call the xDestroy method
 914 ** of the virtual table named zTab in database iDb. This occurs
 915 ** when a DROP TABLE is mentioned.
 916 **
 917 ** This call is a no-op if zTab is not a virtual table.
 918 */
 919 int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
 920   int rc = SQLITE_OK;
 921   Table *pTab;
 922
 923   pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
 924   if( ALWAYS(pTab!=0)
 925    && ALWAYS(IsVirtual(pTab))
 926    && ALWAYS(pTab->u.vtab.p!=0)
 927   ){
 928     VTable *p;
 929     int (*xDestroy)(sqlite3_vtab *);
 930     for(p=pTab->u.vtab.p; p; p=p->pNext){
 931       assert( p->pVtab );
 932       if( p->pVtab->nRef>0 ){
 933         return SQLITE_LOCKED;
 934       }
 935     }
 936     p = vtabDisconnectAll(db, pTab);
 937     xDestroy = p->pMod->pModule->xDestroy;
 938     if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;
 939     assert( xDestroy!=0 );
 940     pTab->nTabRef++;
 941     rc = xDestroy(p->pVtab);
 942     /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
 943     if( rc==SQLITE_OK ){
 944       assert( pTab->u.vtab.p==p && p->pNext==0 );
 945       p->pVtab = 0;
 946       pTab->u.vtab.p = 0;
 947       sqlite3VtabUnlock(p);
 948     }
 949     sqlite3DeleteTable(db, pTab);
 950   }
 951
 952   return rc;
 953 }
 954
 955 /*
 956 ** This function invokes either the xRollback or xCommit method
 957 ** of each of the virtual tables in the sqlite3.aVTrans array. The method
 958 ** called is identified by the second argument, "offset", which is
 959 ** the offset of the method to call in the sqlite3_module structure.
 960 **
 961 ** The array is cleared after invoking the callbacks.
 962 */
 963 static void callFinaliser(sqlite3 *db, int offset){
 964   int i;
 965   if( db->aVTrans ){
 966     VTable **aVTrans = db->aVTrans;
 967     db->aVTrans = 0;
 968     for(i=0; i<db->nVTrans; i++){
 969       VTable *pVTab = aVTrans[i];
 970       sqlite3_vtab *p = pVTab->pVtab;
 971       if( p ){
 972         int (*x)(sqlite3_vtab *);
 973         x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
 974         if( x ) x(p);
 975       }
 976       pVTab->iSavepoint = 0;
 977       sqlite3VtabUnlock(pVTab);
 978     }
 979     sqlite3DbFree(db, aVTrans);
 980     db->nVTrans = 0;
 981   }
 982 }
 983
 984 /*
 985 ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
 986 ** array. Return the error code for the first error that occurs, or
 987 ** SQLITE_OK if all xSync operations are successful.
 988 **
 989 ** If an error message is available, leave it in p->zErrMsg.
 990 */
 991 int sqlite3VtabSync(sqlite3 *db, Vdbe *p){
 992   int i;
 993   int rc = SQLITE_OK;
 994   VTable **aVTrans = db->aVTrans;
 995
 996   db->aVTrans = 0;
 997   for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
 998     int (*x)(sqlite3_vtab *);
 999     sqlite3_vtab *pVtab = aVTrans[i]->pVtab;
1000     if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
1001       rc = x(pVtab);
1002       sqlite3VtabImportErrmsg(p, pVtab);
1003     }
1004   }
1005   db->aVTrans = aVTrans;
1006   return rc;
1007 }
1008
1009 /*
1010 ** Invoke the xRollback method of all virtual tables in the
1011 ** sqlite3.aVTrans array. Then clear the array itself.
1012 */
1013 int sqlite3VtabRollback(sqlite3 *db){
1014   callFinaliser(db, offsetof(sqlite3_module,xRollback));
1015   return SQLITE_OK;
1016 }
1017
1018 /*
1019 ** Invoke the xCommit method of all virtual tables in the
1020 ** sqlite3.aVTrans array. Then clear the array itself.
1021 */
1022 int sqlite3VtabCommit(sqlite3 *db){
1023   callFinaliser(db, offsetof(sqlite3_module,xCommit));
1024   return SQLITE_OK;
1025 }
1026
1027 /*
1028 ** If the virtual table pVtab supports the transaction interface
1029 ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
1030 ** not currently open, invoke the xBegin method now.
1031 **
1032 ** If the xBegin call is successful, place the sqlite3_vtab pointer
1033 ** in the sqlite3.aVTrans array.
1034 */
1035 int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){
1036   int rc = SQLITE_OK;
1037   const sqlite3_module *pModule;
1038
1039   /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
1040   ** than zero, then this function is being called from within a
1041   ** virtual module xSync() callback. It is illegal to write to
1042   ** virtual module tables in this case, so return SQLITE_LOCKED.
1043   */
1044   if( sqlite3VtabInSync(db) ){
1045     return SQLITE_LOCKED;
1046   }
1047   if( !pVTab ){
1048     return SQLITE_OK;
1049   }
1050   pModule = pVTab->pVtab->pModule;
1051
1052   if( pModule->xBegin ){
1053     int i;
1054
1055     /* If pVtab is already in the aVTrans array, return early */
1056     for(i=0; i<db->nVTrans; i++){
1057       if( db->aVTrans[i]==pVTab ){
1058         return SQLITE_OK;
1059       }
1060     }
1061
1062     /* Invoke the xBegin method. If successful, add the vtab to the
1063     ** sqlite3.aVTrans[] array. */
1064     rc = growVTrans(db);
1065     if( rc==SQLITE_OK ){
1066       rc = pModule->xBegin(pVTab->pVtab);
1067       if( rc==SQLITE_OK ){
1068         int iSvpt = db->nStatement + db->nSavepoint;
1069         addToVTrans(db, pVTab);
1070         if( iSvpt && pModule->xSavepoint ){
1071           pVTab->iSavepoint = iSvpt;
1072           rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1);
1073         }
1074       }
1075     }
1076   }
1077   return rc;
1078 }
1079
1080 /*
1081 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
1082 ** virtual tables that currently have an open transaction. Pass iSavepoint
1083 ** as the second argument to the virtual table method invoked.
1084 **
1085 ** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is
1086 ** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is
1087 ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
1088 ** an open transaction is invoked.
1089 **
1090 ** If any virtual table method returns an error code other than SQLITE_OK,
1091 ** processing is abandoned and the error returned to the caller of this
1092 ** function immediately. If all calls to virtual table methods are successful,
1093 ** SQLITE_OK is returned.
1094 */
1095 int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
1096   int rc = SQLITE_OK;
1097
1098   assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
1099   assert( iSavepoint>=-1 );
1100   if( db->aVTrans ){
1101     int i;
1102     for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
1103       VTable *pVTab = db->aVTrans[i];
1104       const sqlite3_module *pMod = pVTab->pMod->pModule;
1105       if( pVTab->pVtab && pMod->iVersion>=2 ){
1106         int (*xMethod)(sqlite3_vtab *, int);
1107         sqlite3VtabLock(pVTab);
1108         switch( op ){
1109           case SAVEPOINT_BEGIN:
1110             xMethod = pMod->xSavepoint;
1111             pVTab->iSavepoint = iSavepoint+1;
1112             break;
1113           case SAVEPOINT_ROLLBACK:
1114             xMethod = pMod->xRollbackTo;
1115             break;
1116           default:
1117             xMethod = pMod->xRelease;
1118             break;
1119         }
1120         if( xMethod && pVTab->iSavepoint>iSavepoint ){
1121           u64 savedFlags = (db->flags & SQLITE_Defensive);
1122           db->flags &= ~(u64)SQLITE_Defensive;
1123           rc = xMethod(pVTab->pVtab, iSavepoint);
1124           db->flags |= savedFlags;
1125         }
1126         sqlite3VtabUnlock(pVTab);
1127       }
1128     }
1129   }
1130   return rc;
1131 }
1132
1133 /*
1134 ** The first parameter (pDef) is a function implementation.  The
1135 ** second parameter (pExpr) is the first argument to this function.
1136 ** If pExpr is a column in a virtual table, then let the virtual
1137 ** table implementation have an opportunity to overload the function.
1138 **
1139 ** This routine is used to allow virtual table implementations to
1140 ** overload MATCH, LIKE, GLOB, and REGEXP operators.
1141 **
1142 ** Return either the pDef argument (indicating no change) or a
1143 ** new FuncDef structure that is marked as ephemeral using the
1144 ** SQLITE_FUNC_EPHEM flag.
1145 */
1146 FuncDef *sqlite3VtabOverloadFunction(
1147   sqlite3 *db,    /* Database connection for reporting malloc problems */
1148   FuncDef *pDef,  /* Function to possibly overload */
1149   int nArg,       /* Number of arguments to the function */
1150   Expr *pExpr     /* First argument to the function */
1151 ){
1152   Table *pTab;
1153   sqlite3_vtab *pVtab;
1154   sqlite3_module *pMod;
1155   void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
1156   void *pArg = 0;
1157   FuncDef *pNew;
1158   int rc = 0;
1159
1160   /* Check to see the left operand is a column in a virtual table */
1161   if( NEVER(pExpr==0) ) return pDef;
1162   if( pExpr->op!=TK_COLUMN ) return pDef;
1163   assert( ExprUseYTab(pExpr) );
1164   pTab = pExpr->y.pTab;
1165   if( NEVER(pTab==0) ) return pDef;
1166   if( !IsVirtual(pTab) ) return pDef;
1167   pVtab = sqlite3GetVTable(db, pTab)->pVtab;
1168   assert( pVtab!=0 );
1169   assert( pVtab->pModule!=0 );
1170   pMod = (sqlite3_module *)pVtab->pModule;
1171   if( pMod->xFindFunction==0 ) return pDef;
1172
1173   /* Call the xFindFunction method on the virtual table implementation
1174   ** to see if the implementation wants to overload this function.
1175   **
1176   ** Though undocumented, we have historically always invoked xFindFunction
1177   ** with an all lower-case function name.  Continue in this tradition to
1178   ** avoid any chance of an incompatibility.
1179   */
1180 #ifdef SQLITE_DEBUG
1181   {
1182     int i;
1183     for(i=0; pDef->zName[i]; i++){
1184       unsigned char x = (unsigned char)pDef->zName[i];
1185       assert( x==sqlite3UpperToLower[x] );
1186     }
1187   }
1188 #endif
1189   rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
1190   if( rc==0 ){
1191     return pDef;
1192   }
1193
1194   /* Create a new ephemeral function definition for the overloaded
1195   ** function */
1196   pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
1197                              + sqlite3Strlen30(pDef->zName) + 1);
1198   if( pNew==0 ){
1199     return pDef;
1200   }
1201   *pNew = *pDef;
1202   pNew->zName = (const char*)&pNew[1];
1203   memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
1204   pNew->xSFunc = xSFunc;
1205   pNew->pUserData = pArg;
1206   pNew->funcFlags |= SQLITE_FUNC_EPHEM;
1207   return pNew;
1208 }
1209
1210 /*
1211 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
1212 ** array so that an OP_VBegin will get generated for it.  Add pTab to the
1213 ** array if it is missing.  If pTab is already in the array, this routine
1214 ** is a no-op.
1215 */
1216 void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
1217   Parse *pToplevel = sqlite3ParseToplevel(pParse);
1218   int i, n;
1219   Table **apVtabLock;
1220
1221   assert( IsVirtual(pTab) );
1222   for(i=0; i<pToplevel->nVtabLock; i++){
1223     if( pTab==pToplevel->apVtabLock[i] ) return;
1224   }
1225   n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
1226   apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n);
1227   if( apVtabLock ){
1228     pToplevel->apVtabLock = apVtabLock;
1229     pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
1230   }else{
1231     sqlite3OomFault(pToplevel->db);
1232   }
1233 }
1234
1235 /*
1236 ** Check to see if virtual table module pMod can be have an eponymous
1237 ** virtual table instance.  If it can, create one if one does not already
1238 ** exist. Return non-zero if either the eponymous virtual table instance
1239 ** exists when this routine returns or if an attempt to create it failed
1240 ** and an error message was left in pParse.
1241 **
1242 ** An eponymous virtual table instance is one that is named after its
1243 ** module, and more importantly, does not require a CREATE VIRTUAL TABLE
1244 ** statement in order to come into existence.  Eponymous virtual table
1245 ** instances always exist.  They cannot be DROP-ed.
1246 **
1247 ** Any virtual table module for which xConnect and xCreate are the same
1248 ** method can have an eponymous virtual table instance.
1249 */
1250 int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){
1251   const sqlite3_module *pModule = pMod->pModule;
1252   Table *pTab;
1253   char *zErr = 0;
1254   int rc;
1255   sqlite3 *db = pParse->db;
1256   if( pMod->pEpoTab ) return 1;
1257   if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0;
1258   pTab = sqlite3DbMallocZero(db, sizeof(Table));
1259   if( pTab==0 ) return 0;
1260   pTab->zName = sqlite3DbStrDup(db, pMod->zName);
1261   if( pTab->zName==0 ){
1262     sqlite3DbFree(db, pTab);
1263     return 0;
1264   }
1265   pMod->pEpoTab = pTab;
1266   pTab->nTabRef = 1;
1267   pTab->eTabType = TABTYP_VTAB;
1268   pTab->pSchema = db->aDb[0].pSchema;
1269   assert( pTab->u.vtab.nArg==0 );
1270   pTab->iPKey = -1;
1271   pTab->tabFlags |= TF_Eponymous;
1272   addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
1273   addModuleArgument(pParse, pTab, 0);
1274   addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
1275   rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
1276   if( rc ){
1277     sqlite3ErrorMsg(pParse, "%s", zErr);
1278     sqlite3DbFree(db, zErr);
1279     sqlite3VtabEponymousTableClear(db, pMod);
1280   }
1281   return 1;
1282 }
1283
1284 /*
1285 ** Erase the eponymous virtual table instance associated with
1286 ** virtual table module pMod, if it exists.
1287 */
1288 void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){
1289   Table *pTab = pMod->pEpoTab;
1290   if( pTab!=0 ){
1291     /* Mark the table as Ephemeral prior to deleting it, so that the
1292     ** sqlite3DeleteTable() routine will know that it is not stored in
1293     ** the schema. */
1294     pTab->tabFlags |= TF_Ephemeral;
1295     sqlite3DeleteTable(db, pTab);
1296     pMod->pEpoTab = 0;
1297   }
1298 }
1299
1300 /*
1301 ** Return the ON CONFLICT resolution mode in effect for the virtual
1302 ** table update operation currently in progress.
1303 **
1304 ** The results of this routine are undefined unless it is called from
1305 ** within an xUpdate method.
1306 */
1307 int sqlite3_vtab_on_conflict(sqlite3 *db){
1308   static const unsigned char aMap[] = {
1309     SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
1310   };
1311 #ifdef SQLITE_ENABLE_API_ARMOR
1312   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1313 #endif
1314   assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
1315   assert( OE_Ignore==4 && OE_Replace==5 );
1316   assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
1317   return (int)aMap[db->vtabOnConflict-1];
1318 }
1319
1320 /*
1321 ** Call from within the xCreate() or xConnect() methods to provide
1322 ** the SQLite core with additional information about the behavior
1323 ** of the virtual table being implemented.
1324 */
1325 int sqlite3_vtab_config(sqlite3 *db, int op, ...){
1326   va_list ap;
1327   int rc = SQLITE_OK;
1328   VtabCtx *p;
1329
1330 #ifdef SQLITE_ENABLE_API_ARMOR
1331   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1332 #endif
1333   sqlite3_mutex_enter(db->mutex);
1334   p = db->pVtabCtx;
1335   if( !p ){
1336     rc = SQLITE_MISUSE_BKPT;
1337   }else{
1338     assert( p->pTab==0 || IsVirtual(p->pTab) );
1339     va_start(ap, op);
1340     switch( op ){
1341       case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
1342         p->pVTable->bConstraint = (u8)va_arg(ap, int);
1343         break;
1344       }
1345       case SQLITE_VTAB_INNOCUOUS: {
1346         p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low;
1347         break;
1348       }
1349       case SQLITE_VTAB_DIRECTONLY: {
1350         p->pVTable->eVtabRisk = SQLITE_VTABRISK_High;
1351         break;
1352       }
1353       case SQLITE_VTAB_USES_ALL_SCHEMAS: {
1354         p->pVTable->bAllSchemas = 1;
1355         break;
1356       }
1357       default: {
1358         rc = SQLITE_MISUSE_BKPT;
1359         break;
1360       }
1361     }
1362     va_end(ap);
1363   }
1364
1365   if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
1366   sqlite3_mutex_leave(db->mutex);
1367   return rc;
1368 }
1369
1370 #endif /* SQLITE_OMIT_VIRTUALTABLE */