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