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