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