AryaWu/sqlite
0
1/*2** 2006 June 103**4** The author disclaims copyright to this source code. In place of5** 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_VIRTUALTABLE15#include "sqliteInt.h"16 17/*18** Before a virtual table xCreate() or xConnect() method is invoked, the19** sqlite3.pVtabCtx member variable is set to point to an instance of20** this struct allocated on the stack. It is used by the implementation of21** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which22** are invoked only from within xCreate and xConnect methods.23*/24struct 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 this33** routine is called, it is guaranteed that all appropriate locks are held34** 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*/39Module *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() and85** sqlite3_create_module_v2() interfaces.86*/87static 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*/108int 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_ARMOR115 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;116#endif117 return createModule(db, zName, pModule, pAux, 0);118}119 120/*121** External API function used to create a new virtual-table module.122*/123int 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_ARMOR131 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;132#endif133 return createModule(db, zName, pModule, pAux, xDestroy);134}135 136/*137** External API to drop all virtual-table modules, except those named138** on the azNames list.139*/140int sqlite3_drop_modules(sqlite3 *db, const char** azNames){141 HashElem *pThis, *pNext;142#ifdef SQLITE_ENABLE_API_ARMOR143 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;144#endif145 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 the160** module when the reference count reaches zero.161*/162void 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*/182void 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 access190** this virtual-table, if one has been created, or NULL otherwise.191*/192VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){193 VTable *pVtab;194 assert( IsVirtual(pTab) );195 for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);196 return pVtab;197}198 199/*200** Decrement the ref-count on a virtual table object. When the ref-count201** reaches zero, call the xDisconnect() method to delete the object.202*/203void sqlite3VtabUnlock(VTable *pVTab){204 sqlite3 *db = pVTab->db;205 206 assert( db );207 assert( pVTab->nRef>0 );208 assert( db->eOpenState==SQLITE_STATE_OPEN209 || db->eOpenState==SQLITE_STATE_ZOMBIE );210 211 pVTab->nRef--;212 if( pVTab->nRef==0 ){213 sqlite3_vtab *p = pVTab->pVtab;214 if( p ){215 p->pModule->xDisconnect(p);216 }217 sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod);218 sqlite3DbFree(db, pVTab);219 }220}221 222/*223** Table p is a virtual table. This function moves all elements in the224** p->u.vtab.p list to the sqlite3.pDisconnect lists of their associated225** database connections to be disconnected at the next opportunity.226** Except, if argument db is not NULL, then the entry associated with227** connection db is left in the p->u.vtab.p list.228*/229static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){230 VTable *pRet = 0;231 VTable *pVTable;232 233 assert( IsVirtual(p) );234 pVTable = p->u.vtab.p;235 p->u.vtab.p = 0;236 237 /* Assert that the mutex (if any) associated with the BtShared database238 ** that contains table p is held by the caller. See header comments239 ** above function sqlite3VtabUnlockList() for an explanation of why240 ** this makes it safe to access the sqlite3.pDisconnect list of any241 ** database connection that may have an entry in the p->u.vtab.p list.242 */243 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );244 245 while( pVTable ){246 sqlite3 *db2 = pVTable->db;247 VTable *pNext = pVTable->pNext;248 assert( db2 );249 if( db2==db ){250 pRet = pVTable;251 p->u.vtab.p = pRet;252 pRet->pNext = 0;253 }else{254 pVTable->pNext = db2->pDisconnect;255 db2->pDisconnect = pVTable;256 }257 pVTable = pNext;258 }259 260 assert( !db || pRet );261 return pRet;262}263 264/*265** Table *p is a virtual table. This function removes the VTable object266** for table *p associated with database connection db from the linked267** list in p->pVTab. It also decrements the VTable ref count. This is268** used when closing database connection db to free all of its VTable269** objects without disturbing the rest of the Schema object (which may270** be being used by other shared-cache connections).271*/272void sqlite3VtabDisconnect(sqlite3 *db, Table *p){273 VTable **ppVTab;274 275 assert( IsVirtual(p) );276 assert( sqlite3BtreeHoldsAllMutexes(db) );277 assert( sqlite3_mutex_held(db->mutex) );278 279 for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){280 if( (*ppVTab)->db==db ){281 VTable *pVTab = *ppVTab;282 *ppVTab = pVTab->pNext;283 sqlite3VtabUnlock(pVTab);284 break;285 }286 }287}288 289 290/*291** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.292**293** This function may only be called when the mutexes associated with all294** shared b-tree databases opened using connection db are held by the295** caller. This is done to protect the sqlite3.pDisconnect list. The296** sqlite3.pDisconnect list is accessed only as follows:297**298** 1) By this function. In this case, all BtShared mutexes and the mutex299** associated with the database handle itself must be held.300**301** 2) By function vtabDisconnectAll(), when it adds a VTable entry to302** the sqlite3.pDisconnect list. In this case either the BtShared mutex303** associated with the database the virtual table is stored in is held304** or, if the virtual table is stored in a non-sharable database, then305** the database handle mutex is held.306**307** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously308** by multiple threads. It is thread-safe.309*/310void sqlite3VtabUnlockList(sqlite3 *db){311 VTable *p = db->pDisconnect;312 313 assert( sqlite3BtreeHoldsAllMutexes(db) );314 assert( sqlite3_mutex_held(db->mutex) );315 316 if( p ){317 db->pDisconnect = 0;318 do {319 VTable *pNext = p->pNext;320 sqlite3VtabUnlock(p);321 p = pNext;322 }while( p );323 }324}325 326/*327** Clear any and all virtual-table information from the Table record.328** This routine is called, for example, just before deleting the Table329** record.330**331** Since it is a virtual-table, the Table structure contains a pointer332** to the head of a linked list of VTable structures. Each VTable333** structure is associated with a single sqlite3* user of the schema.334** The reference count of the VTable structure associated with database335** connection db is decremented immediately (which may lead to the336** structure being xDisconnected and free). Any other VTable structures337** in the list are moved to the sqlite3.pDisconnect list of the associated338** database connection.339*/340void sqlite3VtabClear(sqlite3 *db, Table *p){341 assert( IsVirtual(p) );342 assert( db!=0 );343 if( db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);344 if( p->u.vtab.azArg ){345 int i;346 for(i=0; i<p->u.vtab.nArg; i++){347 if( i!=1 ) sqlite3DbFree(db, p->u.vtab.azArg[i]);348 }349 sqlite3DbFree(db, p->u.vtab.azArg);350 }351}352 353/*354** Add a new module argument to pTable->u.vtab.azArg[].355** The string is not copied - the pointer is stored. The356** string will be freed automatically when the table is357** deleted.358*/359static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){360 sqlite3_int64 nBytes;361 char **azModuleArg;362 sqlite3 *db = pParse->db;363 364 assert( IsVirtual(pTable) );365 nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg);366 if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){367 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);368 }369 azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes);370 if( azModuleArg==0 ){371 sqlite3DbFree(db, zArg);372 }else{373 int i = pTable->u.vtab.nArg++;374 azModuleArg[i] = zArg;375 azModuleArg[i+1] = 0;376 pTable->u.vtab.azArg = azModuleArg;377 }378}379 380/*381** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE382** statement. The module name has been parsed, but the optional list383** of parameters that follow the module name are still pending.384*/385void sqlite3VtabBeginParse(386 Parse *pParse, /* Parsing context */387 Token *pName1, /* Name of new table, or database name */388 Token *pName2, /* Name of new table or NULL */389 Token *pModuleName, /* Name of the module for the virtual table */390 int ifNotExists /* No error if the table already exists */391){392 Table *pTable; /* The new virtual table */393 sqlite3 *db; /* Database connection */394 395 sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);396 pTable = pParse->pNewTable;397 if( pTable==0 ) return;398 assert( 0==pTable->pIndex );399 pTable->eTabType = TABTYP_VTAB;400 401 db = pParse->db;402 403 assert( pTable->u.vtab.nArg==0 );404 addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName));405 addModuleArgument(pParse, pTable, 0);406 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));407 assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)408 || (pParse->sNameToken.z==pName1->z && pName2->z==0)409 );410 pParse->sNameToken.n = (int)(411 &pModuleName->z[pModuleName->n] - pParse->sNameToken.z412 );413 414#ifndef SQLITE_OMIT_AUTHORIZATION415 /* Creating a virtual table invokes the authorization callback twice.416 ** The first invocation, to obtain permission to INSERT a row into the417 ** sqlite_schema table, has already been made by sqlite3StartTable().418 ** The second call, to obtain permission to create the table, is made now.419 */420 if( pTable->u.vtab.azArg ){421 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);422 assert( iDb>=0 ); /* The database the table is being created in */423 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,424 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);425 }426#endif427}428 429/*430** This routine takes the module argument that has been accumulating431** in pParse->zArg[] and appends it to the list of arguments on the432** virtual table currently under construction in pParse->pTable.433*/434static void addArgumentToVtab(Parse *pParse){435 if( pParse->sArg.z && pParse->pNewTable ){436 const char *z = (const char*)pParse->sArg.z;437 int n = pParse->sArg.n;438 sqlite3 *db = pParse->db;439 addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));440 }441}442 443/*444** The parser calls this routine after the CREATE VIRTUAL TABLE statement445** has been completely parsed.446*/447void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){448 Table *pTab = pParse->pNewTable; /* The table being constructed */449 sqlite3 *db = pParse->db; /* The database connection */450 451 if( pTab==0 ) return;452 assert( IsVirtual(pTab) );453 addArgumentToVtab(pParse);454 pParse->sArg.z = 0;455 if( pTab->u.vtab.nArg<1 ) return;456 457 /* If the CREATE VIRTUAL TABLE statement is being entered for the458 ** first time (in other words if the virtual table is actually being459 ** created now instead of just being read out of sqlite_schema) then460 ** do additional initialization work and store the statement text461 ** in the sqlite_schema table.462 */463 if( !db->init.busy ){464 char *zStmt;465 char *zWhere;466 int iDb;467 int iReg;468 Vdbe *v;469 470 sqlite3MayAbort(pParse);471 472 /* Compute the complete text of the CREATE VIRTUAL TABLE statement */473 if( pEnd ){474 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;475 }476 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);477 478 /* A slot for the record has already been allocated in the479 ** schema table. We just need to update that slot with all480 ** the information we've collected.481 **482 ** The VM register number pParse->u1.cr.regRowid holds the rowid of an483 ** entry in the sqlite_schema table that was created for this vtab484 ** by sqlite3StartTable().485 */486 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);487 assert( pParse->isCreate );488 sqlite3NestedParse(pParse,489 "UPDATE %Q." LEGACY_SCHEMA_TABLE " "490 "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "491 "WHERE rowid=#%d",492 db->aDb[iDb].zDbSName,493 pTab->zName,494 pTab->zName,495 zStmt,496 pParse->u1.cr.regRowid497 );498 v = sqlite3GetVdbe(pParse);499 sqlite3ChangeCookie(pParse, iDb);500 501 sqlite3VdbeAddOp0(v, OP_Expire);502 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);503 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);504 sqlite3DbFree(db, zStmt);505 506 iReg = ++pParse->nMem;507 sqlite3VdbeLoadString(v, iReg, pTab->zName);508 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);509 }else{510 /* If we are rereading the sqlite_schema table create the in-memory511 ** record of the table. */512 Table *pOld;513 Schema *pSchema = pTab->pSchema;514 const char *zName = pTab->zName;515 assert( zName!=0 );516 sqlite3MarkAllShadowTablesOf(db, pTab);517 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);518 if( pOld ){519 sqlite3OomFault(db);520 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */521 return;522 }523 pParse->pNewTable = 0;524 }525}526 527/*528** The parser calls this routine when it sees the first token529** of an argument to the module name in a CREATE VIRTUAL TABLE statement.530*/531void sqlite3VtabArgInit(Parse *pParse){532 addArgumentToVtab(pParse);533 pParse->sArg.z = 0;534 pParse->sArg.n = 0;535}536 537/*538** The parser calls this routine for each token after the first token539** in an argument to the module name in a CREATE VIRTUAL TABLE statement.540*/541void sqlite3VtabArgExtend(Parse *pParse, Token *p){542 Token *pArg = &pParse->sArg;543 if( pArg->z==0 ){544 pArg->z = p->z;545 pArg->n = p->n;546 }else{547 assert(pArg->z <= p->z);548 pArg->n = (int)(&p->z[p->n] - pArg->z);549 }550}551 552/*553** Invoke a virtual table constructor (either xCreate or xConnect). The554** pointer to the function to invoke is passed as the fourth parameter555** to this procedure.556*/557static int vtabCallConstructor(558 sqlite3 *db,559 Table *pTab,560 Module *pMod,561 int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),562 char **pzErr563){564 VtabCtx sCtx;565 VTable *pVTable;566 int rc;567 const char *const*azArg;568 int nArg = pTab->u.vtab.nArg;569 char *zErr = 0;570 char *zModuleName;571 int iDb;572 VtabCtx *pCtx;573 574 assert( IsVirtual(pTab) );575 azArg = (const char *const*)pTab->u.vtab.azArg;576 577 /* Check that the virtual-table is not already being initialized */578 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){579 if( pCtx->pTab==pTab ){580 *pzErr = sqlite3MPrintf(db,581 "vtable constructor called recursively: %s", pTab->zName582 );583 return SQLITE_LOCKED;584 }585 }586 587 zModuleName = sqlite3DbStrDup(db, pTab->zName);588 if( !zModuleName ){589 return SQLITE_NOMEM_BKPT;590 }591 592 pVTable = sqlite3MallocZero(sizeof(VTable));593 if( !pVTable ){594 sqlite3OomFault(db);595 sqlite3DbFree(db, zModuleName);596 return SQLITE_NOMEM_BKPT;597 }598 pVTable->db = db;599 pVTable->pMod = pMod;600 pVTable->eVtabRisk = SQLITE_VTABRISK_Normal;601 602 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);603 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;604 605 /* Invoke the virtual table constructor */606 assert( &db->pVtabCtx );607 assert( xConstruct );608 sCtx.pTab = pTab;609 sCtx.pVTable = pVTable;610 sCtx.pPrior = db->pVtabCtx;611 sCtx.bDeclared = 0;612 db->pVtabCtx = &sCtx;613 pTab->nTabRef++;614 rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);615 assert( pTab!=0 );616 assert( pTab->nTabRef>1 || rc!=SQLITE_OK );617 sqlite3DeleteTable(db, pTab);618 db->pVtabCtx = sCtx.pPrior;619 if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);620 assert( sCtx.pTab==pTab );621 622 if( SQLITE_OK!=rc ){623 if( zErr==0 ){624 *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);625 }else {626 *pzErr = sqlite3MPrintf(db, "%s", zErr);627 sqlite3_free(zErr);628 }629 sqlite3DbFree(db, pVTable);630 }else if( ALWAYS(pVTable->pVtab) ){631 /* Justification of ALWAYS(): A correct vtab constructor must allocate632 ** the sqlite3_vtab object if successful. */633 memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0]));634 pVTable->pVtab->pModule = pMod->pModule;635 pMod->nRefModule++;636 pVTable->nRef = 1;637 if( sCtx.bDeclared==0 ){638 const char *zFormat = "vtable constructor did not declare schema: %s";639 *pzErr = sqlite3MPrintf(db, zFormat, zModuleName);640 sqlite3VtabUnlock(pVTable);641 rc = SQLITE_ERROR;642 }else{643 int iCol;644 u16 oooHidden = 0;645 /* If everything went according to plan, link the new VTable structure646 ** into the linked list headed by pTab->u.vtab.p. Then loop through the647 ** columns of the table to see if any of them contain the token "hidden".648 ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from649 ** the type string. */650 pVTable->pNext = pTab->u.vtab.p;651 pTab->u.vtab.p = pVTable;652 653 for(iCol=0; iCol<pTab->nCol; iCol++){654 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");655 int nType;656 int i = 0;657 nType = sqlite3Strlen30(zType);658 for(i=0; i<nType; i++){659 if( 0==sqlite3StrNICmp("hidden", &zType[i], 6)660 && (i==0 || zType[i-1]==' ')661 && (zType[i+6]=='\0' || zType[i+6]==' ')662 ){663 break;664 }665 }666 if( i<nType ){667 int j;668 int nDel = 6 + (zType[i+6] ? 1 : 0);669 for(j=i; (j+nDel)<=nType; j++){670 zType[j] = zType[j+nDel];671 }672 if( zType[i]=='\0' && i>0 ){673 assert(zType[i-1]==' ');674 zType[i-1] = '\0';675 }676 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;677 pTab->tabFlags |= TF_HasHidden;678 oooHidden = TF_OOOHidden;679 }else{680 pTab->tabFlags |= oooHidden;681 }682 }683 }684 }685 686 sqlite3DbFree(db, zModuleName);687 return rc;688}689 690/*691** This function is invoked by the parser to call the xConnect() method692** of the virtual table pTab. If an error occurs, an error code is returned693** and an error left in pParse.694**695** This call is a no-op if table pTab is not a virtual table.696*/697int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){698 sqlite3 *db = pParse->db;699 const char *zMod;700 Module *pMod;701 int rc;702 703 assert( pTab );704 assert( IsVirtual(pTab) );705 if( sqlite3GetVTable(db, pTab) ){706 return SQLITE_OK;707 }708 709 /* Locate the required virtual table module */710 zMod = pTab->u.vtab.azArg[0];711 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);712 713 if( !pMod ){714 const char *zModule = pTab->u.vtab.azArg[0];715 sqlite3ErrorMsg(pParse, "no such module: %s", zModule);716 rc = SQLITE_ERROR;717 }else{718 char *zErr = 0;719 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);720 if( rc!=SQLITE_OK ){721 sqlite3ErrorMsg(pParse, "%s", zErr);722 pParse->rc = rc;723 }724 sqlite3DbFree(db, zErr);725 }726 727 return rc;728}729/*730** Grow the db->aVTrans[] array so that there is room for at least one731** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.732*/733static int growVTrans(sqlite3 *db){734 const int ARRAY_INCR = 5;735 736 /* Grow the sqlite3.aVTrans array if required */737 if( (db->nVTrans%ARRAY_INCR)==0 ){738 VTable **aVTrans;739 sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)*740 ((sqlite3_int64)db->nVTrans + ARRAY_INCR);741 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);742 if( !aVTrans ){743 return SQLITE_NOMEM_BKPT;744 }745 memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);746 db->aVTrans = aVTrans;747 }748 749 return SQLITE_OK;750}751 752/*753** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should754** have already been reserved using growVTrans().755*/756static void addToVTrans(sqlite3 *db, VTable *pVTab){757 /* Add pVtab to the end of sqlite3.aVTrans */758 db->aVTrans[db->nVTrans++] = pVTab;759 sqlite3VtabLock(pVTab);760}761 762/*763** This function is invoked by the vdbe to call the xCreate method764** of the virtual table named zTab in database iDb.765**766** If an error occurs, *pzErr is set to point to an English language767** description of the error and an SQLITE_XXX error code is returned.768** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.769*/770int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){771 int rc = SQLITE_OK;772 Table *pTab;773 Module *pMod;774 const char *zMod;775 776 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);777 assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p );778 779 /* Locate the required virtual table module */780 zMod = pTab->u.vtab.azArg[0];781 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);782 783 /* If the module has been registered and includes a Create method,784 ** invoke it now. If the module has not been registered, return an785 ** error. Otherwise, do nothing.786 */787 if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){788 *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);789 rc = SQLITE_ERROR;790 }else{791 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);792 }793 794 /* Justification of ALWAYS(): The xConstructor method is required to795 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */796 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){797 rc = growVTrans(db);798 if( rc==SQLITE_OK ){799 addToVTrans(db, sqlite3GetVTable(db, pTab));800 }801 }802 803 return rc;804}805 806/*807** This function is used to set the schema of a virtual table. It is only808** valid to call this function from within the xCreate() or xConnect() of a809** virtual table module.810*/811int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){812 VtabCtx *pCtx;813 int rc = SQLITE_OK;814 Table *pTab;815 Parse sParse;816 int initBusy;817 int i;818 const unsigned char *z;819 static const u8 aKeyword[] = { TK_CREATE, TK_TABLE, 0 };820 821#ifdef SQLITE_ENABLE_API_ARMOR822 if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){823 return SQLITE_MISUSE_BKPT;824 }825#endif826 827 /* Verify that the first two keywords in the CREATE TABLE statement828 ** really are "CREATE" and "TABLE". If this is not the case, then829 ** sqlite3_declare_vtab() is being misused.830 */831 z = (const unsigned char*)zCreateTable;832 for(i=0; aKeyword[i]; i++){833 int tokenType = 0;834 do{835 z += sqlite3GetToken(z, &tokenType);836 }while( tokenType==TK_SPACE || tokenType==TK_COMMENT );837 if( tokenType!=aKeyword[i] ){838 sqlite3ErrorWithMsg(db, SQLITE_ERROR, "syntax error");839 return SQLITE_ERROR;840 }841 }842 843 sqlite3_mutex_enter(db->mutex);844 pCtx = db->pVtabCtx;845 if( !pCtx || pCtx->bDeclared ){846 sqlite3Error(db, SQLITE_MISUSE_BKPT);847 sqlite3_mutex_leave(db->mutex);848 return SQLITE_MISUSE_BKPT;849 }850 851 pTab = pCtx->pTab;852 assert( IsVirtual(pTab) );853 854 sqlite3ParseObjectInit(&sParse, db);855 sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;856 sParse.disableTriggers = 1;857 /* We should never be able to reach this point while loading the858 ** schema. Nevertheless, defend against that (turn off db->init.busy)859 ** in case a bug arises. */860 assert( db->init.busy==0 );861 initBusy = db->init.busy;862 db->init.busy = 0;863 sParse.nQueryLoop = 1;864 if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) ){865 assert( sParse.pNewTable!=0 );866 assert( !db->mallocFailed );867 assert( IsOrdinaryTable(sParse.pNewTable) );868 assert( sParse.zErrMsg==0 );869 if( !pTab->aCol ){870 Table *pNew = sParse.pNewTable;871 Index *pIdx;872 pTab->aCol = pNew->aCol;873 assert( IsOrdinaryTable(pNew) );874 sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);875 pTab->nNVCol = pTab->nCol = pNew->nCol;876 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);877 pNew->nCol = 0;878 pNew->aCol = 0;879 assert( pTab->pIndex==0 );880 assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );881 if( !HasRowid(pNew)882 && pCtx->pVTable->pMod->pModule->xUpdate!=0883 && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1884 ){885 /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)886 ** or else must have a single-column PRIMARY KEY */887 rc = SQLITE_ERROR;888 }889 pIdx = pNew->pIndex;890 if( pIdx ){891 assert( pIdx->pNext==0 );892 pTab->pIndex = pIdx;893 pNew->pIndex = 0;894 pIdx->pTable = pTab;895 }896 }897 pCtx->bDeclared = 1;898 }else{899 sqlite3ErrorWithMsg(db, SQLITE_ERROR,900 (sParse.zErrMsg ? "%s" : 0), sParse.zErrMsg);901 sqlite3DbFree(db, sParse.zErrMsg);902 rc = SQLITE_ERROR;903 }904 sParse.eParseMode = PARSE_MODE_NORMAL;905 906 if( sParse.pVdbe ){907 sqlite3VdbeFinalize(sParse.pVdbe);908 }909 sqlite3DeleteTable(db, sParse.pNewTable);910 sqlite3ParseObjectReset(&sParse);911 db->init.busy = initBusy;912 913 assert( (rc&0xff)==rc );914 rc = sqlite3ApiExit(db, rc);915 sqlite3_mutex_leave(db->mutex);916 return rc;917}918 919/*920** This function is invoked by the vdbe to call the xDestroy method921** of the virtual table named zTab in database iDb. This occurs922** when a DROP TABLE is mentioned.923**924** This call is a no-op if zTab is not a virtual table.925*/926int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){927 int rc = SQLITE_OK;928 Table *pTab;929 930 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);931 if( ALWAYS(pTab!=0)932 && ALWAYS(IsVirtual(pTab))933 && ALWAYS(pTab->u.vtab.p!=0)934 ){935 VTable *p;936 int (*xDestroy)(sqlite3_vtab *);937 for(p=pTab->u.vtab.p; p; p=p->pNext){938 assert( p->pVtab );939 if( p->pVtab->nRef>0 ){940 return SQLITE_LOCKED;941 }942 }943 p = vtabDisconnectAll(db, pTab);944 xDestroy = p->pMod->pModule->xDestroy;945 if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;946 assert( xDestroy!=0 );947 pTab->nTabRef++;948 rc = xDestroy(p->pVtab);949 /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */950 if( rc==SQLITE_OK ){951 assert( pTab->u.vtab.p==p && p->pNext==0 );952 p->pVtab = 0;953 pTab->u.vtab.p = 0;954 sqlite3VtabUnlock(p);955 }956 sqlite3DeleteTable(db, pTab);957 }958 959 return rc;960}961 962/*963** This function invokes either the xRollback or xCommit method964** of each of the virtual tables in the sqlite3.aVTrans array. The method965** called is identified by the second argument, "offset", which is966** the offset of the method to call in the sqlite3_module structure.967**968** The array is cleared after invoking the callbacks.969*/970static void callFinaliser(sqlite3 *db, int offset){971 int i;972 if( db->aVTrans ){973 VTable **aVTrans = db->aVTrans;974 db->aVTrans = 0;975 for(i=0; i<db->nVTrans; i++){976 VTable *pVTab = aVTrans[i];977 sqlite3_vtab *p = pVTab->pVtab;978 if( p ){979 int (*x)(sqlite3_vtab *);980 x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);981 if( x ) x(p);982 }983 pVTab->iSavepoint = 0;984 sqlite3VtabUnlock(pVTab);985 }986 sqlite3DbFree(db, aVTrans);987 db->nVTrans = 0;988 }989}990 991/*992** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans993** array. Return the error code for the first error that occurs, or994** SQLITE_OK if all xSync operations are successful.995**996** If an error message is available, leave it in p->zErrMsg.997*/998int sqlite3VtabSync(sqlite3 *db, Vdbe *p){999 int i;1000 int rc = SQLITE_OK;1001 VTable **aVTrans = db->aVTrans;1002 1003 db->aVTrans = 0;1004 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){1005 int (*x)(sqlite3_vtab *);1006 sqlite3_vtab *pVtab = aVTrans[i]->pVtab;1007 if( pVtab && (x = pVtab->pModule->xSync)!=0 ){1008 rc = x(pVtab);1009 sqlite3VtabImportErrmsg(p, pVtab);1010 }1011 }1012 db->aVTrans = aVTrans;1013 return rc;1014}1015 1016/*1017** Invoke the xRollback method of all virtual tables in the1018** sqlite3.aVTrans array. Then clear the array itself.1019*/1020int sqlite3VtabRollback(sqlite3 *db){1021 callFinaliser(db, offsetof(sqlite3_module,xRollback));1022 return SQLITE_OK;1023}1024 1025/*1026** Invoke the xCommit method of all virtual tables in the1027** sqlite3.aVTrans array. Then clear the array itself.1028*/1029int sqlite3VtabCommit(sqlite3 *db){1030 callFinaliser(db, offsetof(sqlite3_module,xCommit));1031 return SQLITE_OK;1032}1033 1034/*1035** If the virtual table pVtab supports the transaction interface1036** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is1037** not currently open, invoke the xBegin method now.1038**1039** If the xBegin call is successful, place the sqlite3_vtab pointer1040** in the sqlite3.aVTrans array.1041*/1042int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){1043 int rc = SQLITE_OK;1044 const sqlite3_module *pModule;1045 1046 /* Special case: If db->aVTrans is NULL and db->nVTrans is greater1047 ** than zero, then this function is being called from within a1048 ** virtual module xSync() callback. It is illegal to write to1049 ** virtual module tables in this case, so return SQLITE_LOCKED.1050 */1051 if( sqlite3VtabInSync(db) ){1052 return SQLITE_LOCKED;1053 }1054 if( !pVTab ){1055 return SQLITE_OK;1056 }1057 pModule = pVTab->pVtab->pModule;1058 1059 if( pModule->xBegin ){1060 int i;1061 1062 /* If pVtab is already in the aVTrans array, return early */1063 for(i=0; i<db->nVTrans; i++){1064 if( db->aVTrans[i]==pVTab ){1065 return SQLITE_OK;1066 }1067 }1068 1069 /* Invoke the xBegin method. If successful, add the vtab to the1070 ** sqlite3.aVTrans[] array. */1071 rc = growVTrans(db);1072 if( rc==SQLITE_OK ){1073 rc = pModule->xBegin(pVTab->pVtab);1074 if( rc==SQLITE_OK ){1075 int iSvpt = db->nStatement + db->nSavepoint;1076 addToVTrans(db, pVTab);1077 if( iSvpt && pModule->xSavepoint ){1078 pVTab->iSavepoint = iSvpt;1079 rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1);1080 }1081 }1082 }1083 }1084 return rc;1085}1086 1087/*1088** Invoke either the xSavepoint, xRollbackTo or xRelease method of all1089** virtual tables that currently have an open transaction. Pass iSavepoint1090** as the second argument to the virtual table method invoked.1091**1092** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is1093** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is1094** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with1095** an open transaction is invoked.1096**1097** If any virtual table method returns an error code other than SQLITE_OK,1098** processing is abandoned and the error returned to the caller of this1099** function immediately. If all calls to virtual table methods are successful,1100** SQLITE_OK is returned.1101*/1102int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){1103 int rc = SQLITE_OK;1104 1105 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );1106 assert( iSavepoint>=-1 );1107 if( db->aVTrans ){1108 int i;1109 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){1110 VTable *pVTab = db->aVTrans[i];1111 const sqlite3_module *pMod = pVTab->pMod->pModule;1112 if( pVTab->pVtab && pMod->iVersion>=2 ){1113 int (*xMethod)(sqlite3_vtab *, int);1114 sqlite3VtabLock(pVTab);1115 switch( op ){1116 case SAVEPOINT_BEGIN:1117 xMethod = pMod->xSavepoint;1118 pVTab->iSavepoint = iSavepoint+1;1119 break;1120 case SAVEPOINT_ROLLBACK:1121 xMethod = pMod->xRollbackTo;1122 break;1123 default:1124 xMethod = pMod->xRelease;1125 break;1126 }1127 if( xMethod && pVTab->iSavepoint>iSavepoint ){1128 u64 savedFlags = (db->flags & SQLITE_Defensive);1129 db->flags &= ~(u64)SQLITE_Defensive;1130 rc = xMethod(pVTab->pVtab, iSavepoint);1131 db->flags |= savedFlags;1132 }1133 sqlite3VtabUnlock(pVTab);1134 }1135 }1136 }1137 return rc;1138}1139 1140/*1141** The first parameter (pDef) is a function implementation. The1142** second parameter (pExpr) is the first argument to this function.1143** If pExpr is a column in a virtual table, then let the virtual1144** table implementation have an opportunity to overload the function.1145**1146** This routine is used to allow virtual table implementations to1147** overload MATCH, LIKE, GLOB, and REGEXP operators.1148**1149** Return either the pDef argument (indicating no change) or a1150** new FuncDef structure that is marked as ephemeral using the1151** SQLITE_FUNC_EPHEM flag.1152*/1153FuncDef *sqlite3VtabOverloadFunction(1154 sqlite3 *db, /* Database connection for reporting malloc problems */1155 FuncDef *pDef, /* Function to possibly overload */1156 int nArg, /* Number of arguments to the function */1157 Expr *pExpr /* First argument to the function */1158){1159 Table *pTab;1160 sqlite3_vtab *pVtab;1161 sqlite3_module *pMod;1162 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0;1163 void *pArg = 0;1164 FuncDef *pNew;1165 int rc = 0;1166 1167 /* Check to see the left operand is a column in a virtual table */1168 if( NEVER(pExpr==0) ) return pDef;1169 if( pExpr->op!=TK_COLUMN ) return pDef;1170 assert( ExprUseYTab(pExpr) );1171 pTab = pExpr->y.pTab;1172 if( NEVER(pTab==0) ) return pDef;1173 if( !IsVirtual(pTab) ) return pDef;1174 pVtab = sqlite3GetVTable(db, pTab)->pVtab;1175 assert( pVtab!=0 );1176 assert( pVtab->pModule!=0 );1177 pMod = (sqlite3_module *)pVtab->pModule;1178 if( pMod->xFindFunction==0 ) return pDef;1179 1180 /* Call the xFindFunction method on the virtual table implementation1181 ** to see if the implementation wants to overload this function.1182 **1183 ** Though undocumented, we have historically always invoked xFindFunction1184 ** with an all lower-case function name. Continue in this tradition to1185 ** avoid any chance of an incompatibility.1186 */1187#ifdef SQLITE_DEBUG1188 {1189 int i;1190 for(i=0; pDef->zName[i]; i++){1191 unsigned char x = (unsigned char)pDef->zName[i];1192 assert( x==sqlite3UpperToLower[x] );1193 }1194 }1195#endif1196 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);1197 if( rc==0 ){1198 return pDef;1199 }1200