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