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 */
sqlite3VtabCreateModule(sqlite3 * db,const char * zName,const sqlite3_module * pModule,void * pAux,void (* xDestroy)(void *))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 */
createModule(sqlite3 * db,const char * zName,const sqlite3_module * pModule,void * pAux,void (* xDestroy)(void *))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 */
sqlite3_create_module(sqlite3 * db,const char * zName,const sqlite3_module * pModule,void * pAux)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 */
sqlite3_create_module_v2(sqlite3 * db,const char * zName,const sqlite3_module * pModule,void * pAux,void (* xDestroy)(void *))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 */
sqlite3_drop_modules(sqlite3 * db,const char ** azNames)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 */
sqlite3VtabModuleUnref(sqlite3 * db,Module * pMod)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 */
sqlite3VtabLock(VTable * pVTab)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 */
sqlite3GetVTable(sqlite3 * db,Table * pTab)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 */
sqlite3VtabUnlock(VTable * pVTab)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 */
vtabDisconnectAll(sqlite3 * db,Table * p)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 */
sqlite3VtabDisconnect(sqlite3 * db,Table * p)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 */
sqlite3VtabUnlockList(sqlite3 * db)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 */
sqlite3VtabClear(sqlite3 * db,Table * p)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 */
addModuleArgument(Parse * pParse,Table * pTable,char * zArg)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 */
sqlite3VtabBeginParse(Parse * pParse,Token * pName1,Token * pName2,Token * pModuleName,int ifNotExists)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 */
addArgumentToVtab(Parse * pParse)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 */
sqlite3VtabFinishParse(Parse * pParse,Token * pEnd)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, 0);
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 */
sqlite3VtabArgInit(Parse * pParse)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 */
sqlite3VtabArgExtend(Parse * pParse,Token * p)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 */
vtabCallConstructor(sqlite3 * db,Table * pTab,Module * pMod,int (* xConstruct)(sqlite3 *,void *,int,const char * const *,sqlite3_vtab **,char **),char ** pzErr)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 pTab->tabFlags |= TF_HasHidden;
664 oooHidden = TF_OOOHidden;
665 }else{
666 pTab->tabFlags |= oooHidden;
667 }
668 }
669 }
670 }
671
672 sqlite3DbFree(db, zModuleName);
673 return rc;
674 }
675
676 /*
677 ** This function is invoked by the parser to call the xConnect() method
678 ** of the virtual table pTab. If an error occurs, an error code is returned
679 ** and an error left in pParse.
680 **
681 ** This call is a no-op if table pTab is not a virtual table.
682 */
sqlite3VtabCallConnect(Parse * pParse,Table * pTab)683 int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
684 sqlite3 *db = pParse->db;
685 const char *zMod;
686 Module *pMod;
687 int rc;
688
689 assert( pTab );
690 if( !IsVirtual(pTab) || sqlite3GetVTable(db, pTab) ){
691 return SQLITE_OK;
692 }
693
694 /* Locate the required virtual table module */
695 zMod = pTab->azModuleArg[0];
696 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
697
698 if( !pMod ){
699 const char *zModule = pTab->azModuleArg[0];
700 sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
701 rc = SQLITE_ERROR;
702 }else{
703 char *zErr = 0;
704 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
705 if( rc!=SQLITE_OK ){
706 sqlite3ErrorMsg(pParse, "%s", zErr);
707 pParse->rc = rc;
708 }
709 sqlite3DbFree(db, zErr);
710 }
711
712 return rc;
713 }
714 /*
715 ** Grow the db->aVTrans[] array so that there is room for at least one
716 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
717 */
growVTrans(sqlite3 * db)718 static int growVTrans(sqlite3 *db){
719 const int ARRAY_INCR = 5;
720
721 /* Grow the sqlite3.aVTrans array if required */
722 if( (db->nVTrans%ARRAY_INCR)==0 ){
723 VTable **aVTrans;
724 sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)*
725 ((sqlite3_int64)db->nVTrans + ARRAY_INCR);
726 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
727 if( !aVTrans ){
728 return SQLITE_NOMEM_BKPT;
729 }
730 memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
731 db->aVTrans = aVTrans;
732 }
733
734 return SQLITE_OK;
735 }
736
737 /*
738 ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should
739 ** have already been reserved using growVTrans().
740 */
addToVTrans(sqlite3 * db,VTable * pVTab)741 static void addToVTrans(sqlite3 *db, VTable *pVTab){
742 /* Add pVtab to the end of sqlite3.aVTrans */
743 db->aVTrans[db->nVTrans++] = pVTab;
744 sqlite3VtabLock(pVTab);
745 }
746
747 /*
748 ** This function is invoked by the vdbe to call the xCreate method
749 ** of the virtual table named zTab in database iDb.
750 **
751 ** If an error occurs, *pzErr is set to point to an English language
752 ** description of the error and an SQLITE_XXX error code is returned.
753 ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
754 */
sqlite3VtabCallCreate(sqlite3 * db,int iDb,const char * zTab,char ** pzErr)755 int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
756 int rc = SQLITE_OK;
757 Table *pTab;
758 Module *pMod;
759 const char *zMod;
760
761 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
762 assert( pTab && IsVirtual(pTab) && !pTab->pVTable );
763
764 /* Locate the required virtual table module */
765 zMod = pTab->azModuleArg[0];
766 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
767
768 /* If the module has been registered and includes a Create method,
769 ** invoke it now. If the module has not been registered, return an
770 ** error. Otherwise, do nothing.
771 */
772 if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){
773 *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);
774 rc = SQLITE_ERROR;
775 }else{
776 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
777 }
778
779 /* Justification of ALWAYS(): The xConstructor method is required to
780 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
781 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
782 rc = growVTrans(db);
783 if( rc==SQLITE_OK ){
784 addToVTrans(db, sqlite3GetVTable(db, pTab));
785 }
786 }
787
788 return rc;
789 }
790
791 /*
792 ** This function is used to set the schema of a virtual table. It is only
793 ** valid to call this function from within the xCreate() or xConnect() of a
794 ** virtual table module.
795 */
sqlite3_declare_vtab(sqlite3 * db,const char * zCreateTable)796 int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
797 VtabCtx *pCtx;
798 int rc = SQLITE_OK;
799 Table *pTab;
800 char *zErr = 0;
801 Parse sParse;
802
803 #ifdef SQLITE_ENABLE_API_ARMOR
804 if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
805 return SQLITE_MISUSE_BKPT;
806 }
807 #endif
808 sqlite3_mutex_enter(db->mutex);
809 pCtx = db->pVtabCtx;
810 if( !pCtx || pCtx->bDeclared ){
811 sqlite3Error(db, SQLITE_MISUSE);
812 sqlite3_mutex_leave(db->mutex);
813 return SQLITE_MISUSE_BKPT;
814 }
815 pTab = pCtx->pTab;
816 assert( IsVirtual(pTab) );
817
818 memset(&sParse, 0, sizeof(sParse));
819 sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
820 sParse.db = db;
821 sParse.nQueryLoop = 1;
822 if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr)
823 && sParse.pNewTable
824 && !db->mallocFailed
825 && !sParse.pNewTable->pSelect
826 && !IsVirtual(sParse.pNewTable)
827 ){
828 if( !pTab->aCol ){
829 Table *pNew = sParse.pNewTable;
830 Index *pIdx;
831 pTab->aCol = pNew->aCol;
832 pTab->nNVCol = pTab->nCol = pNew->nCol;
833 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
834 pNew->nCol = 0;
835 pNew->aCol = 0;
836 assert( pTab->pIndex==0 );
837 assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
838 if( !HasRowid(pNew)
839 && pCtx->pVTable->pMod->pModule->xUpdate!=0
840 && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
841 ){
842 /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
843 ** or else must have a single-column PRIMARY KEY */
844 rc = SQLITE_ERROR;
845 }
846 pIdx = pNew->pIndex;
847 if( pIdx ){
848 assert( pIdx->pNext==0 );
849 pTab->pIndex = pIdx;
850 pNew->pIndex = 0;
851 pIdx->pTable = pTab;
852 }
853 }
854 pCtx->bDeclared = 1;
855 }else{
856 sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);
857 sqlite3DbFree(db, zErr);
858 rc = SQLITE_ERROR;
859 }
860 sParse.eParseMode = PARSE_MODE_NORMAL;
861
862 if( sParse.pVdbe ){
863 sqlite3VdbeFinalize(sParse.pVdbe);
864 }
865 sqlite3DeleteTable(db, sParse.pNewTable);
866 sqlite3ParserReset(&sParse);
867
868 assert( (rc&0xff)==rc );
869 rc = sqlite3ApiExit(db, rc);
870 sqlite3_mutex_leave(db->mutex);
871 return rc;
872 }
873
874 /*
875 ** This function is invoked by the vdbe to call the xDestroy method
876 ** of the virtual table named zTab in database iDb. This occurs
877 ** when a DROP TABLE is mentioned.
878 **
879 ** This call is a no-op if zTab is not a virtual table.
880 */
sqlite3VtabCallDestroy(sqlite3 * db,int iDb,const char * zTab)881 int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
882 int rc = SQLITE_OK;
883 Table *pTab;
884
885 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
886 if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){
887 VTable *p;
888 int (*xDestroy)(sqlite3_vtab *);
889 for(p=pTab->pVTable; p; p=p->pNext){
890 assert( p->pVtab );
891 if( p->pVtab->nRef>0 ){
892 return SQLITE_LOCKED;
893 }
894 }
895 p = vtabDisconnectAll(db, pTab);
896 xDestroy = p->pMod->pModule->xDestroy;
897 if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;
898 assert( xDestroy!=0 );
899 pTab->nTabRef++;
900 rc = xDestroy(p->pVtab);
901 /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
902 if( rc==SQLITE_OK ){
903 assert( pTab->pVTable==p && p->pNext==0 );
904 p->pVtab = 0;
905 pTab->pVTable = 0;
906 sqlite3VtabUnlock(p);
907 }
908 sqlite3DeleteTable(db, pTab);
909 }
910
911 return rc;
912 }
913
914 /*
915 ** This function invokes either the xRollback or xCommit method
916 ** of each of the virtual tables in the sqlite3.aVTrans array. The method
917 ** called is identified by the second argument, "offset", which is
918 ** the offset of the method to call in the sqlite3_module structure.
919 **
920 ** The array is cleared after invoking the callbacks.
921 */
callFinaliser(sqlite3 * db,int offset)922 static void callFinaliser(sqlite3 *db, int offset){
923 int i;
924 if( db->aVTrans ){
925 VTable **aVTrans = db->aVTrans;
926 db->aVTrans = 0;
927 for(i=0; i<db->nVTrans; i++){
928 VTable *pVTab = aVTrans[i];
929 sqlite3_vtab *p = pVTab->pVtab;
930 if( p ){
931 int (*x)(sqlite3_vtab *);
932 x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
933 if( x ) x(p);
934 }
935 pVTab->iSavepoint = 0;
936 sqlite3VtabUnlock(pVTab);
937 }
938 sqlite3DbFree(db, aVTrans);
939 db->nVTrans = 0;
940 }
941 }
942
943 /*
944 ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
945 ** array. Return the error code for the first error that occurs, or
946 ** SQLITE_OK if all xSync operations are successful.
947 **
948 ** If an error message is available, leave it in p->zErrMsg.
949 */
sqlite3VtabSync(sqlite3 * db,Vdbe * p)950 int sqlite3VtabSync(sqlite3 *db, Vdbe *p){
951 int i;
952 int rc = SQLITE_OK;
953 VTable **aVTrans = db->aVTrans;
954
955 db->aVTrans = 0;
956 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
957 int (*x)(sqlite3_vtab *);
958 sqlite3_vtab *pVtab = aVTrans[i]->pVtab;
959 if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
960 rc = x(pVtab);
961 sqlite3VtabImportErrmsg(p, pVtab);
962 }
963 }
964 db->aVTrans = aVTrans;
965 return rc;
966 }
967
968 /*
969 ** Invoke the xRollback method of all virtual tables in the
970 ** sqlite3.aVTrans array. Then clear the array itself.
971 */
sqlite3VtabRollback(sqlite3 * db)972 int sqlite3VtabRollback(sqlite3 *db){
973 callFinaliser(db, offsetof(sqlite3_module,xRollback));
974 return SQLITE_OK;
975 }
976
977 /*
978 ** Invoke the xCommit method of all virtual tables in the
979 ** sqlite3.aVTrans array. Then clear the array itself.
980 */
sqlite3VtabCommit(sqlite3 * db)981 int sqlite3VtabCommit(sqlite3 *db){
982 callFinaliser(db, offsetof(sqlite3_module,xCommit));
983 return SQLITE_OK;
984 }
985
986 /*
987 ** If the virtual table pVtab supports the transaction interface
988 ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
989 ** not currently open, invoke the xBegin method now.
990 **
991 ** If the xBegin call is successful, place the sqlite3_vtab pointer
992 ** in the sqlite3.aVTrans array.
993 */
sqlite3VtabBegin(sqlite3 * db,VTable * pVTab)994 int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){
995 int rc = SQLITE_OK;
996 const sqlite3_module *pModule;
997
998 /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
999 ** than zero, then this function is being called from within a
1000 ** virtual module xSync() callback. It is illegal to write to
1001 ** virtual module tables in this case, so return SQLITE_LOCKED.
1002 */
1003 if( sqlite3VtabInSync(db) ){
1004 return SQLITE_LOCKED;
1005 }
1006 if( !pVTab ){
1007 return SQLITE_OK;
1008 }
1009 pModule = pVTab->pVtab->pModule;
1010
1011 if( pModule->xBegin ){
1012 int i;
1013
1014 /* If pVtab is already in the aVTrans array, return early */
1015 for(i=0; i<db->nVTrans; i++){
1016 if( db->aVTrans[i]==pVTab ){
1017 return SQLITE_OK;
1018 }
1019 }
1020
1021 /* Invoke the xBegin method. If successful, add the vtab to the
1022 ** sqlite3.aVTrans[] array. */
1023 rc = growVTrans(db);
1024 if( rc==SQLITE_OK ){
1025 rc = pModule->xBegin(pVTab->pVtab);
1026 if( rc==SQLITE_OK ){
1027 int iSvpt = db->nStatement + db->nSavepoint;
1028 addToVTrans(db, pVTab);
1029 if( iSvpt && pModule->xSavepoint ){
1030 pVTab->iSavepoint = iSvpt;
1031 rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1);
1032 }
1033 }
1034 }
1035 }
1036 return rc;
1037 }
1038
1039 /*
1040 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
1041 ** virtual tables that currently have an open transaction. Pass iSavepoint
1042 ** as the second argument to the virtual table method invoked.
1043 **
1044 ** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is
1045 ** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is
1046 ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
1047 ** an open transaction is invoked.
1048 **
1049 ** If any virtual table method returns an error code other than SQLITE_OK,
1050 ** processing is abandoned and the error returned to the caller of this
1051 ** function immediately. If all calls to virtual table methods are successful,
1052 ** SQLITE_OK is returned.
1053 */
sqlite3VtabSavepoint(sqlite3 * db,int op,int iSavepoint)1054 int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
1055 int rc = SQLITE_OK;
1056
1057 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
1058 assert( iSavepoint>=-1 );
1059 if( db->aVTrans ){
1060 int i;
1061 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
1062 VTable *pVTab = db->aVTrans[i];
1063 const sqlite3_module *pMod = pVTab->pMod->pModule;
1064 if( pVTab->pVtab && pMod->iVersion>=2 ){
1065 int (*xMethod)(sqlite3_vtab *, int);
1066 sqlite3VtabLock(pVTab);
1067 switch( op ){
1068 case SAVEPOINT_BEGIN:
1069 xMethod = pMod->xSavepoint;
1070 pVTab->iSavepoint = iSavepoint+1;
1071 break;
1072 case SAVEPOINT_ROLLBACK:
1073 xMethod = pMod->xRollbackTo;
1074 break;
1075 default:
1076 xMethod = pMod->xRelease;
1077 break;
1078 }
1079 if( xMethod && pVTab->iSavepoint>iSavepoint ){
1080 rc = xMethod(pVTab->pVtab, iSavepoint);
1081 }
1082 sqlite3VtabUnlock(pVTab);
1083 }
1084 }
1085 }
1086 return rc;
1087 }
1088
1089 /*
1090 ** The first parameter (pDef) is a function implementation. The
1091 ** second parameter (pExpr) is the first argument to this function.
1092 ** If pExpr is a column in a virtual table, then let the virtual
1093 ** table implementation have an opportunity to overload the function.
1094 **
1095 ** This routine is used to allow virtual table implementations to
1096 ** overload MATCH, LIKE, GLOB, and REGEXP operators.
1097 **
1098 ** Return either the pDef argument (indicating no change) or a
1099 ** new FuncDef structure that is marked as ephemeral using the
1100 ** SQLITE_FUNC_EPHEM flag.
1101 */
sqlite3VtabOverloadFunction(sqlite3 * db,FuncDef * pDef,int nArg,Expr * pExpr)1102 FuncDef *sqlite3VtabOverloadFunction(
1103 sqlite3 *db, /* Database connection for reporting malloc problems */
1104 FuncDef *pDef, /* Function to possibly overload */
1105 int nArg, /* Number of arguments to the function */
1106 Expr *pExpr /* First argument to the function */
1107 ){
1108 Table *pTab;
1109 sqlite3_vtab *pVtab;
1110 sqlite3_module *pMod;
1111 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
1112 void *pArg = 0;
1113 FuncDef *pNew;
1114 int rc = 0;
1115
1116 /* Check to see the left operand is a column in a virtual table */
1117 if( NEVER(pExpr==0) ) return pDef;
1118 if( pExpr->op!=TK_COLUMN ) return pDef;
1119 pTab = pExpr->y.pTab;
1120 if( pTab==0 ) return pDef;
1121 if( !IsVirtual(pTab) ) return pDef;
1122 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
1123 assert( pVtab!=0 );
1124 assert( pVtab->pModule!=0 );
1125 pMod = (sqlite3_module *)pVtab->pModule;
1126 if( pMod->xFindFunction==0 ) return pDef;
1127
1128 /* Call the xFindFunction method on the virtual table implementation
1129 ** to see if the implementation wants to overload this function.
1130 **
1131 ** Though undocumented, we have historically always invoked xFindFunction
1132 ** with an all lower-case function name. Continue in this tradition to
1133 ** avoid any chance of an incompatibility.
1134 */
1135 #ifdef SQLITE_DEBUG
1136 {
1137 int i;
1138 for(i=0; pDef->zName[i]; i++){
1139 unsigned char x = (unsigned char)pDef->zName[i];
1140 assert( x==sqlite3UpperToLower[x] );
1141 }
1142 }
1143 #endif
1144 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
1145 if( rc==0 ){
1146 return pDef;
1147 }
1148
1149 /* Create a new ephemeral function definition for the overloaded
1150 ** function */
1151 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
1152 + sqlite3Strlen30(pDef->zName) + 1);
1153 if( pNew==0 ){
1154 return pDef;
1155 }
1156 *pNew = *pDef;
1157 pNew->zName = (const char*)&pNew[1];
1158 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
1159 pNew->xSFunc = xSFunc;
1160 pNew->pUserData = pArg;
1161 pNew->funcFlags |= SQLITE_FUNC_EPHEM;
1162 return pNew;
1163 }
1164
1165 /*
1166 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
1167 ** array so that an OP_VBegin will get generated for it. Add pTab to the
1168 ** array if it is missing. If pTab is already in the array, this routine
1169 ** is a no-op.
1170 */
sqlite3VtabMakeWritable(Parse * pParse,Table * pTab)1171 void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
1172 Parse *pToplevel = sqlite3ParseToplevel(pParse);
1173 int i, n;
1174 Table **apVtabLock;
1175
1176 assert( IsVirtual(pTab) );
1177 for(i=0; i<pToplevel->nVtabLock; i++){
1178 if( pTab==pToplevel->apVtabLock[i] ) return;
1179 }
1180 n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
1181 apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n);
1182 if( apVtabLock ){
1183 pToplevel->apVtabLock = apVtabLock;
1184 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
1185 }else{
1186 sqlite3OomFault(pToplevel->db);
1187 }
1188 }
1189
1190 /*
1191 ** Check to see if virtual table module pMod can be have an eponymous
1192 ** virtual table instance. If it can, create one if one does not already
1193 ** exist. Return non-zero if the eponymous virtual table instance exists
1194 ** when this routine returns, and return zero if it does not exist.
1195 **
1196 ** An eponymous virtual table instance is one that is named after its
1197 ** module, and more importantly, does not require a CREATE VIRTUAL TABLE
1198 ** statement in order to come into existance. Eponymous virtual table
1199 ** instances always exist. They cannot be DROP-ed.
1200 **
1201 ** Any virtual table module for which xConnect and xCreate are the same
1202 ** method can have an eponymous virtual table instance.
1203 */
sqlite3VtabEponymousTableInit(Parse * pParse,Module * pMod)1204 int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){
1205 const sqlite3_module *pModule = pMod->pModule;
1206 Table *pTab;
1207 char *zErr = 0;
1208 int rc;
1209 sqlite3 *db = pParse->db;
1210 if( pMod->pEpoTab ) return 1;
1211 if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0;
1212 pTab = sqlite3DbMallocZero(db, sizeof(Table));
1213 if( pTab==0 ) return 0;
1214 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
1215 if( pTab->zName==0 ){
1216 sqlite3DbFree(db, pTab);
1217 return 0;
1218 }
1219 pMod->pEpoTab = pTab;
1220 pTab->nTabRef = 1;
1221 pTab->pSchema = db->aDb[0].pSchema;
1222 assert( pTab->nModuleArg==0 );
1223 pTab->iPKey = -1;
1224 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
1225 addModuleArgument(pParse, pTab, 0);
1226 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
1227 rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
1228 if( rc ){
1229 sqlite3ErrorMsg(pParse, "%s", zErr);
1230 sqlite3DbFree(db, zErr);
1231 sqlite3VtabEponymousTableClear(db, pMod);
1232 return 0;
1233 }
1234 return 1;
1235 }
1236
1237 /*
1238 ** Erase the eponymous virtual table instance associated with
1239 ** virtual table module pMod, if it exists.
1240 */
sqlite3VtabEponymousTableClear(sqlite3 * db,Module * pMod)1241 void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){
1242 Table *pTab = pMod->pEpoTab;
1243 if( pTab!=0 ){
1244 /* Mark the table as Ephemeral prior to deleting it, so that the
1245 ** sqlite3DeleteTable() routine will know that it is not stored in
1246 ** the schema. */
1247 pTab->tabFlags |= TF_Ephemeral;
1248 sqlite3DeleteTable(db, pTab);
1249 pMod->pEpoTab = 0;
1250 }
1251 }
1252
1253 /*
1254 ** Return the ON CONFLICT resolution mode in effect for the virtual
1255 ** table update operation currently in progress.
1256 **
1257 ** The results of this routine are undefined unless it is called from
1258 ** within an xUpdate method.
1259 */
sqlite3_vtab_on_conflict(sqlite3 * db)1260 int sqlite3_vtab_on_conflict(sqlite3 *db){
1261 static const unsigned char aMap[] = {
1262 SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
1263 };
1264 #ifdef SQLITE_ENABLE_API_ARMOR
1265 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1266 #endif
1267 assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
1268 assert( OE_Ignore==4 && OE_Replace==5 );
1269 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
1270 return (int)aMap[db->vtabOnConflict-1];
1271 }
1272
1273 /*
1274 ** Call from within the xCreate() or xConnect() methods to provide
1275 ** the SQLite core with additional information about the behavior
1276 ** of the virtual table being implemented.
1277 */
sqlite3_vtab_config(sqlite3 * db,int op,...)1278 int sqlite3_vtab_config(sqlite3 *db, int op, ...){
1279 va_list ap;
1280 int rc = SQLITE_OK;
1281 VtabCtx *p;
1282
1283 #ifdef SQLITE_ENABLE_API_ARMOR
1284 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1285 #endif
1286 sqlite3_mutex_enter(db->mutex);
1287 p = db->pVtabCtx;
1288 if( !p ){
1289 rc = SQLITE_MISUSE_BKPT;
1290 }else{
1291 assert( p->pTab==0 || IsVirtual(p->pTab) );
1292 va_start(ap, op);
1293 switch( op ){
1294 case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
1295 p->pVTable->bConstraint = (u8)va_arg(ap, int);
1296 break;
1297 }
1298 case SQLITE_VTAB_INNOCUOUS: {
1299 p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low;
1300 break;
1301 }
1302 case SQLITE_VTAB_DIRECTONLY: {
1303 p->pVTable->eVtabRisk = SQLITE_VTABRISK_High;
1304 break;
1305 }
1306 default: {
1307 rc = SQLITE_MISUSE_BKPT;
1308 break;
1309 }
1310 }
1311 va_end(ap);
1312 }
1313
1314 if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
1315 sqlite3_mutex_leave(db->mutex);
1316 return rc;
1317 }
1318
1319 #endif /* SQLITE_OMIT_VIRTUALTABLE */
1320