blob: 357a6dba2a2b2044822273b3c29c1d9c66cb6e3e [file] [log] [blame]
drhb9bb7c12006-06-11 23:41:55 +00001/*
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.
drhb9bb7c12006-06-11 23:41:55 +000013*/
14#ifndef SQLITE_OMIT_VIRTUALTABLE
15#include "sqliteInt.h"
16
drh63842412009-04-11 16:27:19 +000017/*
danb061d052011-04-25 18:49:57 +000018** 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 {
drh81028a42012-05-15 18:28:27 +000025 VTable *pVTable; /* The virtual table being constructed */
26 Table *pTab; /* The Table object to which the virtual table belongs */
danb061d052011-04-25 18:49:57 +000027};
28
29/*
drh63842412009-04-11 16:27:19 +000030** 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*/
danielk1977832a58a2007-06-22 15:21:15 +000034static 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 */
danielk1977595a5232009-07-24 17:58:53 +000040){
danca8b9ba2012-05-16 14:29:11 +000041 int rc = SQLITE_OK;
42 int nName;
drh27641702007-08-22 02:56:42 +000043
44 sqlite3_mutex_enter(db->mutex);
drhea678832008-12-10 19:26:22 +000045 nName = sqlite3Strlen30(zName);
danca8b9ba2012-05-16 14:29:11 +000046 if( sqlite3HashFind(&db->aModule, zName, nName) ){
47 rc = SQLITE_MISUSE_BKPT;
48 }else{
49 Module *pMod;
50 pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
51 if( pMod ){
52 Module *pDel;
53 char *zCopy = (char *)(&pMod[1]);
54 memcpy(zCopy, zName, nName+1);
55 pMod->zName = zCopy;
56 pMod->pModule = pModule;
57 pMod->pAux = pAux;
58 pMod->xDestroy = xDestroy;
59 pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,nName,(void*)pMod);
60 assert( pDel==0 || pDel==pMod );
61 if( pDel ){
62 db->mallocFailed = 1;
63 sqlite3DbFree(db, pDel);
64 }
danielk1977832a58a2007-06-22 15:21:15 +000065 }
danielk1977832a58a2007-06-22 15:21:15 +000066 }
danca8b9ba2012-05-16 14:29:11 +000067 rc = sqlite3ApiExit(db, rc);
68 if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
69
drh27641702007-08-22 02:56:42 +000070 sqlite3_mutex_leave(db->mutex);
71 return rc;
danielk1977832a58a2007-06-22 15:21:15 +000072}
73
74
drhb9bb7c12006-06-11 23:41:55 +000075/*
76** External API function used to create a new virtual-table module.
77*/
78int sqlite3_create_module(
79 sqlite3 *db, /* Database in which module is registered */
80 const char *zName, /* Name assigned to this module */
danielk1977d1ab1ba2006-06-15 04:28:13 +000081 const sqlite3_module *pModule, /* The definition of the module */
82 void *pAux /* Context pointer for xCreate/xConnect */
drhb9bb7c12006-06-11 23:41:55 +000083){
danielk1977832a58a2007-06-22 15:21:15 +000084 return createModule(db, zName, pModule, pAux, 0);
85}
86
87/*
88** External API function used to create a new virtual-table module.
89*/
90int sqlite3_create_module_v2(
91 sqlite3 *db, /* Database in which module is registered */
92 const char *zName, /* Name assigned to this module */
93 const sqlite3_module *pModule, /* The definition of the module */
94 void *pAux, /* Context pointer for xCreate/xConnect */
95 void (*xDestroy)(void *) /* Module destructor function */
96){
97 return createModule(db, zName, pModule, pAux, xDestroy);
drhb9bb7c12006-06-11 23:41:55 +000098}
99
drhb9bb7c12006-06-11 23:41:55 +0000100/*
drh189d4af2006-09-02 20:57:52 +0000101** Lock the virtual table so that it cannot be disconnected.
102** Locks nest. Every lock should have a corresponding unlock.
103** If an unlock is omitted, resources leaks will occur.
104**
105** If a disconnect is attempted while a virtual table is locked,
106** the disconnect is deferred until all locks have been removed.
107*/
danielk1977595a5232009-07-24 17:58:53 +0000108void sqlite3VtabLock(VTable *pVTab){
109 pVTab->nRef++;
110}
111
112
113/*
114** pTab is a pointer to a Table structure representing a virtual-table.
115** Return a pointer to the VTable object used by connection db to access
116** this virtual-table, if one has been created, or NULL otherwise.
117*/
118VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
119 VTable *pVtab;
120 assert( IsVirtual(pTab) );
121 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
122 return pVtab;
drh189d4af2006-09-02 20:57:52 +0000123}
124
125/*
danielk1977595a5232009-07-24 17:58:53 +0000126** Decrement the ref-count on a virtual table object. When the ref-count
127** reaches zero, call the xDisconnect() method to delete the object.
drh189d4af2006-09-02 20:57:52 +0000128*/
danielk1977595a5232009-07-24 17:58:53 +0000129void sqlite3VtabUnlock(VTable *pVTab){
130 sqlite3 *db = pVTab->db;
131
132 assert( db );
133 assert( pVTab->nRef>0 );
drh04f2e342012-08-27 14:39:47 +0000134 assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
danielk1977595a5232009-07-24 17:58:53 +0000135
136 pVTab->nRef--;
137 if( pVTab->nRef==0 ){
138 sqlite3_vtab *p = pVTab->pVtab;
139 if( p ){
drh9978c972010-02-23 17:36:32 +0000140 p->pModule->xDisconnect(p);
danielk1977a04a34f2007-04-16 15:06:25 +0000141 }
danielk1977595a5232009-07-24 17:58:53 +0000142 sqlite3DbFree(db, pVTab);
143 }
144}
145
146/*
147** Table p is a virtual table. This function moves all elements in the
148** p->pVTable list to the sqlite3.pDisconnect lists of their associated
149** database connections to be disconnected at the next opportunity.
150** Except, if argument db is not NULL, then the entry associated with
151** connection db is left in the p->pVTable list.
152*/
153static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
154 VTable *pRet = 0;
155 VTable *pVTable = p->pVTable;
156 p->pVTable = 0;
157
158 /* Assert that the mutex (if any) associated with the BtShared database
159 ** that contains table p is held by the caller. See header comments
160 ** above function sqlite3VtabUnlockList() for an explanation of why
161 ** this makes it safe to access the sqlite3.pDisconnect list of any
drh9bbc2e22011-04-04 20:40:22 +0000162 ** database connection that may have an entry in the p->pVTable list.
163 */
164 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
danielk1977595a5232009-07-24 17:58:53 +0000165
166 while( pVTable ){
167 sqlite3 *db2 = pVTable->db;
168 VTable *pNext = pVTable->pNext;
169 assert( db2 );
170 if( db2==db ){
171 pRet = pVTable;
172 p->pVTable = pRet;
173 pRet->pNext = 0;
174 }else{
175 pVTable->pNext = db2->pDisconnect;
176 db2->pDisconnect = pVTable;
177 }
178 pVTable = pNext;
179 }
180
181 assert( !db || pRet );
182 return pRet;
183}
184
danbba02a92012-05-15 17:15:34 +0000185/*
186** Table *p is a virtual table. This function removes the VTable object
187** for table *p associated with database connection db from the linked
188** list in p->pVTab. It also decrements the VTable ref count. This is
189** used when closing database connection db to free all of its VTable
190** objects without disturbing the rest of the Schema object (which may
191** be being used by other shared-cache connections).
192*/
193void sqlite3VtabDisconnect(sqlite3 *db, Table *p){
194 VTable **ppVTab;
195
196 assert( IsVirtual(p) );
197 assert( sqlite3BtreeHoldsAllMutexes(db) );
198 assert( sqlite3_mutex_held(db->mutex) );
199
200 for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){
201 if( (*ppVTab)->db==db ){
202 VTable *pVTab = *ppVTab;
203 *ppVTab = pVTab->pNext;
204 sqlite3VtabUnlock(pVTab);
205 break;
206 }
207 }
208}
209
danielk1977595a5232009-07-24 17:58:53 +0000210
211/*
212** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
213**
214** This function may only be called when the mutexes associated with all
215** shared b-tree databases opened using connection db are held by the
216** caller. This is done to protect the sqlite3.pDisconnect list. The
217** sqlite3.pDisconnect list is accessed only as follows:
218**
219** 1) By this function. In this case, all BtShared mutexes and the mutex
220** associated with the database handle itself must be held.
221**
222** 2) By function vtabDisconnectAll(), when it adds a VTable entry to
223** the sqlite3.pDisconnect list. In this case either the BtShared mutex
224** associated with the database the virtual table is stored in is held
225** or, if the virtual table is stored in a non-sharable database, then
226** the database handle mutex is held.
227**
228** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously
229** by multiple threads. It is thread-safe.
230*/
231void sqlite3VtabUnlockList(sqlite3 *db){
232 VTable *p = db->pDisconnect;
233 db->pDisconnect = 0;
234
235 assert( sqlite3BtreeHoldsAllMutexes(db) );
236 assert( sqlite3_mutex_held(db->mutex) );
237
238 if( p ){
239 sqlite3ExpirePreparedStatements(db);
240 do {
241 VTable *pNext = p->pNext;
242 sqlite3VtabUnlock(p);
243 p = pNext;
244 }while( p );
drh189d4af2006-09-02 20:57:52 +0000245 }
246}
247
248/*
drhb9bb7c12006-06-11 23:41:55 +0000249** Clear any and all virtual-table information from the Table record.
250** This routine is called, for example, just before deleting the Table
251** record.
danielk1977595a5232009-07-24 17:58:53 +0000252**
253** Since it is a virtual-table, the Table structure contains a pointer
254** to the head of a linked list of VTable structures. Each VTable
255** structure is associated with a single sqlite3* user of the schema.
256** The reference count of the VTable structure associated with database
257** connection db is decremented immediately (which may lead to the
258** structure being xDisconnected and free). Any other VTable structures
259** in the list are moved to the sqlite3.pDisconnect list of the associated
260** database connection.
drhb9bb7c12006-06-11 23:41:55 +0000261*/
dan1feeaed2010-07-23 15:41:47 +0000262void sqlite3VtabClear(sqlite3 *db, Table *p){
dand46def72010-07-24 11:28:28 +0000263 if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
drhb9bb7c12006-06-11 23:41:55 +0000264 if( p->azModuleArg ){
265 int i;
266 for(i=0; i<p->nModuleArg; i++){
drh5a558262012-10-09 14:36:47 +0000267 if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]);
drhb9bb7c12006-06-11 23:41:55 +0000268 }
dan1feeaed2010-07-23 15:41:47 +0000269 sqlite3DbFree(db, p->azModuleArg);
drhb9bb7c12006-06-11 23:41:55 +0000270 }
271}
272
273/*
274** Add a new module argument to pTable->azModuleArg[].
275** The string is not copied - the pointer is stored. The
276** string will be freed automatically when the table is
277** deleted.
278*/
drh17435752007-08-16 04:30:38 +0000279static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
drhb9bb7c12006-06-11 23:41:55 +0000280 int i = pTable->nModuleArg++;
danielk1977b7a2f2e2006-06-23 11:34:54 +0000281 int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
282 char **azModuleArg;
danielk197726783a52007-08-29 14:06:22 +0000283 azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
danielk1977b7a2f2e2006-06-23 11:34:54 +0000284 if( azModuleArg==0 ){
285 int j;
286 for(j=0; j<i; j++){
drh633e6d52008-07-28 19:34:53 +0000287 sqlite3DbFree(db, pTable->azModuleArg[j]);
danielk1977b7a2f2e2006-06-23 11:34:54 +0000288 }
drh633e6d52008-07-28 19:34:53 +0000289 sqlite3DbFree(db, zArg);
290 sqlite3DbFree(db, pTable->azModuleArg);
danielk1977b7a2f2e2006-06-23 11:34:54 +0000291 pTable->nModuleArg = 0;
drhb9bb7c12006-06-11 23:41:55 +0000292 }else{
danielk1977b7a2f2e2006-06-23 11:34:54 +0000293 azModuleArg[i] = zArg;
294 azModuleArg[i+1] = 0;
drhb9bb7c12006-06-11 23:41:55 +0000295 }
danielk1977b7a2f2e2006-06-23 11:34:54 +0000296 pTable->azModuleArg = azModuleArg;
drhb9bb7c12006-06-11 23:41:55 +0000297}
298
299/*
300** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
301** statement. The module name has been parsed, but the optional list
302** of parameters that follow the module name are still pending.
303*/
304void sqlite3VtabBeginParse(
305 Parse *pParse, /* Parsing context */
306 Token *pName1, /* Name of new table, or database name */
307 Token *pName2, /* Name of new table or NULL */
drhb421b892012-01-28 19:41:53 +0000308 Token *pModuleName, /* Name of the module for the virtual table */
309 int ifNotExists /* No error if the table already exists */
drhb9bb7c12006-06-11 23:41:55 +0000310){
danielk1977f1a381e2006-06-16 08:01:02 +0000311 int iDb; /* The database the table is being created in */
drhb9bb7c12006-06-11 23:41:55 +0000312 Table *pTable; /* The new virtual table */
drh17435752007-08-16 04:30:38 +0000313 sqlite3 *db; /* Database connection */
drhb9bb7c12006-06-11 23:41:55 +0000314
drhb421b892012-01-28 19:41:53 +0000315 sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);
drhb9bb7c12006-06-11 23:41:55 +0000316 pTable = pParse->pNewTable;
drh748ce212009-05-20 20:10:47 +0000317 if( pTable==0 ) return;
danielk1977f1a381e2006-06-16 08:01:02 +0000318 assert( 0==pTable->pIndex );
319
drh17435752007-08-16 04:30:38 +0000320 db = pParse->db;
321 iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
danielk197770ba1642006-06-21 16:02:42 +0000322 assert( iDb>=0 );
323
drh7d10d5a2008-08-20 16:35:10 +0000324 pTable->tabFlags |= TF_Virtual;
drhb9bb7c12006-06-11 23:41:55 +0000325 pTable->nModuleArg = 0;
drh17435752007-08-16 04:30:38 +0000326 addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
dan41fb5cd2012-10-04 19:33:00 +0000327 addModuleArgument(db, pTable, 0);
drh17435752007-08-16 04:30:38 +0000328 addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
drhb27b7f52008-12-10 18:03:45 +0000329 pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z);
danielk1977f1a381e2006-06-16 08:01:02 +0000330
331#ifndef SQLITE_OMIT_AUTHORIZATION
332 /* Creating a virtual table invokes the authorization callback twice.
333 ** The first invocation, to obtain permission to INSERT a row into the
334 ** sqlite_master table, has already been made by sqlite3StartTable().
335 ** The second call, to obtain permission to create the table, is made now.
336 */
danielk1977be718892006-06-23 08:05:19 +0000337 if( pTable->azModuleArg ){
338 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
339 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
danielk1977f1a381e2006-06-16 08:01:02 +0000340 }
341#endif
drhb9bb7c12006-06-11 23:41:55 +0000342}
343
344/*
345** This routine takes the module argument that has been accumulating
346** in pParse->zArg[] and appends it to the list of arguments on the
347** virtual table currently under construction in pParse->pTable.
348*/
349static void addArgumentToVtab(Parse *pParse){
drhb421b892012-01-28 19:41:53 +0000350 if( pParse->sArg.z && pParse->pNewTable ){
drh7c2d87c2006-09-02 14:16:59 +0000351 const char *z = (const char*)pParse->sArg.z;
danielk197733b39332006-06-24 08:51:05 +0000352 int n = pParse->sArg.n;
drh17435752007-08-16 04:30:38 +0000353 sqlite3 *db = pParse->db;
354 addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
drhb9bb7c12006-06-11 23:41:55 +0000355 }
drhb9bb7c12006-06-11 23:41:55 +0000356}
357
358/*
359** The parser calls this routine after the CREATE VIRTUAL TABLE statement
360** has been completely parsed.
361*/
362void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
danielk1977595a5232009-07-24 17:58:53 +0000363 Table *pTab = pParse->pNewTable; /* The table being constructed */
364 sqlite3 *db = pParse->db; /* The database connection */
drhb9bb7c12006-06-11 23:41:55 +0000365
danielk1977595a5232009-07-24 17:58:53 +0000366 if( pTab==0 ) return;
drhb9bb7c12006-06-11 23:41:55 +0000367 addArgumentToVtab(pParse);
danielk197733b39332006-06-24 08:51:05 +0000368 pParse->sArg.z = 0;
drhb9bb7c12006-06-11 23:41:55 +0000369 if( pTab->nModuleArg<1 ) return;
drhb9bb7c12006-06-11 23:41:55 +0000370
371 /* If the CREATE VIRTUAL TABLE statement is being entered for the
372 ** first time (in other words if the virtual table is actually being
373 ** created now instead of just being read out of sqlite_master) then
374 ** do additional initialization work and store the statement text
375 ** in the sqlite_master table.
376 */
377 if( !db->init.busy ){
378 char *zStmt;
danielk197778efaba2006-06-12 06:09:17 +0000379 char *zWhere;
drhb9bb7c12006-06-11 23:41:55 +0000380 int iDb;
381 Vdbe *v;
drhb9bb7c12006-06-11 23:41:55 +0000382
383 /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
384 if( pEnd ){
drhb27b7f52008-12-10 18:03:45 +0000385 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
drhb9bb7c12006-06-11 23:41:55 +0000386 }
danielk19771e536952007-08-16 10:09:01 +0000387 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
drhb9bb7c12006-06-11 23:41:55 +0000388
389 /* A slot for the record has already been allocated in the
390 ** SQLITE_MASTER table. We just need to update that slot with all
danielk197778efaba2006-06-12 06:09:17 +0000391 ** the information we've collected.
392 **
drhb7654112008-01-12 12:48:07 +0000393 ** The VM register number pParse->regRowid holds the rowid of an
394 ** entry in the sqlite_master table tht was created for this vtab
395 ** by sqlite3StartTable().
drhb9bb7c12006-06-11 23:41:55 +0000396 */
397 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
398 sqlite3NestedParse(pParse,
399 "UPDATE %Q.%s "
danielk197778efaba2006-06-12 06:09:17 +0000400 "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
drhb7654112008-01-12 12:48:07 +0000401 "WHERE rowid=#%d",
drhb9bb7c12006-06-11 23:41:55 +0000402 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
403 pTab->zName,
404 pTab->zName,
drhb7654112008-01-12 12:48:07 +0000405 zStmt,
406 pParse->regRowid
drhb9bb7c12006-06-11 23:41:55 +0000407 );
drh633e6d52008-07-28 19:34:53 +0000408 sqlite3DbFree(db, zStmt);
drhb9bb7c12006-06-11 23:41:55 +0000409 v = sqlite3GetVdbe(pParse);
drh9cbf3422008-01-17 16:22:13 +0000410 sqlite3ChangeCookie(pParse, iDb);
danielk197778efaba2006-06-12 06:09:17 +0000411
drh66a51672008-01-03 00:01:23 +0000412 sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
dan39f1bcb2010-09-29 07:16:46 +0000413 zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
drh5d9c9da2011-06-03 20:11:17 +0000414 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
drh66a51672008-01-03 00:01:23 +0000415 sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0,
drhea678832008-12-10 19:26:22 +0000416 pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
drhb9bb7c12006-06-11 23:41:55 +0000417 }
418
danielk197778efaba2006-06-12 06:09:17 +0000419 /* If we are rereading the sqlite_master table create the in-memory
danielk1977595a5232009-07-24 17:58:53 +0000420 ** record of the table. The xConnect() method is not called until
421 ** the first time the virtual table is used in an SQL statement. This
422 ** allows a schema that contains virtual tables to be loaded before
423 ** the required virtual table implementations are registered. */
danielk197778efaba2006-06-12 06:09:17 +0000424 else {
danielk197778efaba2006-06-12 06:09:17 +0000425 Table *pOld;
426 Schema *pSchema = pTab->pSchema;
427 const char *zName = pTab->zName;
drha83ccca2009-04-28 13:01:09 +0000428 int nName = sqlite3Strlen30(zName);
drh21206082011-04-04 18:22:02 +0000429 assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
danielk197778efaba2006-06-12 06:09:17 +0000430 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
431 if( pOld ){
danielk1977a1644fd2007-08-29 12:31:25 +0000432 db->mallocFailed = 1;
danielk197778efaba2006-06-12 06:09:17 +0000433 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
434 return;
435 }
danielk19777e6ebfb2006-06-12 11:24:37 +0000436 pParse->pNewTable = 0;
drhb9bb7c12006-06-11 23:41:55 +0000437 }
438}
439
440/*
441** The parser calls this routine when it sees the first token
442** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
443*/
444void sqlite3VtabArgInit(Parse *pParse){
445 addArgumentToVtab(pParse);
danielk197733b39332006-06-24 08:51:05 +0000446 pParse->sArg.z = 0;
447 pParse->sArg.n = 0;
drhb9bb7c12006-06-11 23:41:55 +0000448}
449
450/*
451** The parser calls this routine for each token after the first token
452** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
453*/
454void sqlite3VtabArgExtend(Parse *pParse, Token *p){
danielk197733b39332006-06-24 08:51:05 +0000455 Token *pArg = &pParse->sArg;
456 if( pArg->z==0 ){
457 pArg->z = p->z;
458 pArg->n = p->n;
459 }else{
460 assert(pArg->z < p->z);
drhb27b7f52008-12-10 18:03:45 +0000461 pArg->n = (int)(&p->z[p->n] - pArg->z);
drhb9bb7c12006-06-11 23:41:55 +0000462 }
drhb9bb7c12006-06-11 23:41:55 +0000463}
464
danielk197778efaba2006-06-12 06:09:17 +0000465/*
danielk19779da9d472006-06-14 06:58:15 +0000466** Invoke a virtual table constructor (either xCreate or xConnect). The
467** pointer to the function to invoke is passed as the fourth parameter
468** to this procedure.
469*/
470static int vtabCallConstructor(
471 sqlite3 *db,
472 Table *pTab,
danielk1977d1ab1ba2006-06-15 04:28:13 +0000473 Module *pMod,
drhe4102962006-09-11 00:34:22 +0000474 int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
danielk19779da9d472006-06-14 06:58:15 +0000475 char **pzErr
476){
drh92505812012-04-26 22:47:20 +0000477 VtabCtx sCtx, *pPriorCtx;
danielk1977595a5232009-07-24 17:58:53 +0000478 VTable *pVTable;
danielk19779da9d472006-06-14 06:58:15 +0000479 int rc;
drhe4102962006-09-11 00:34:22 +0000480 const char *const*azArg = (const char *const*)pTab->azModuleArg;
danielk19779da9d472006-06-14 06:58:15 +0000481 int nArg = pTab->nModuleArg;
drh4ca8aac2006-09-10 17:31:58 +0000482 char *zErr = 0;
danielk19771e536952007-08-16 10:09:01 +0000483 char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
dan41fb5cd2012-10-04 19:33:00 +0000484 int iDb;
danielk19779da9d472006-06-14 06:58:15 +0000485
danielk197701256832007-04-18 14:24:32 +0000486 if( !zModuleName ){
487 return SQLITE_NOMEM;
488 }
489
danielk1977595a5232009-07-24 17:58:53 +0000490 pVTable = sqlite3DbMallocZero(db, sizeof(VTable));
491 if( !pVTable ){
492 sqlite3DbFree(db, zModuleName);
493 return SQLITE_NOMEM;
494 }
495 pVTable->db = db;
496 pVTable->pMod = pMod;
497
dan41fb5cd2012-10-04 19:33:00 +0000498 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
499 pTab->azModuleArg[1] = db->aDb[iDb].zName;
500
danielk1977595a5232009-07-24 17:58:53 +0000501 /* Invoke the virtual table constructor */
danb061d052011-04-25 18:49:57 +0000502 assert( &db->pVtabCtx );
503 assert( xConstruct );
504 sCtx.pTab = pTab;
505 sCtx.pVTable = pVTable;
drh92505812012-04-26 22:47:20 +0000506 pPriorCtx = db->pVtabCtx;
danb061d052011-04-25 18:49:57 +0000507 db->pVtabCtx = &sCtx;
danielk1977595a5232009-07-24 17:58:53 +0000508 rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
drh92505812012-04-26 22:47:20 +0000509 db->pVtabCtx = pPriorCtx;
drh55f04f22009-05-11 23:37:59 +0000510 if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
danielk19779da9d472006-06-14 06:58:15 +0000511
512 if( SQLITE_OK!=rc ){
drh4ca8aac2006-09-10 17:31:58 +0000513 if( zErr==0 ){
danielk19771e536952007-08-16 10:09:01 +0000514 *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
drh4ca8aac2006-09-10 17:31:58 +0000515 }else {
danielk19771e536952007-08-16 10:09:01 +0000516 *pzErr = sqlite3MPrintf(db, "%s", zErr);
drhb9755982010-07-24 16:34:37 +0000517 sqlite3_free(zErr);
drhfe1368e2006-09-10 17:08:29 +0000518 }
danielk1977595a5232009-07-24 17:58:53 +0000519 sqlite3DbFree(db, pVTable);
520 }else if( ALWAYS(pVTable->pVtab) ){
521 /* Justification of ALWAYS(): A correct vtab constructor must allocate
522 ** the sqlite3_vtab object if successful. */
523 pVTable->pVtab->pModule = pMod->pModule;
524 pVTable->nRef = 1;
danb061d052011-04-25 18:49:57 +0000525 if( sCtx.pTab ){
danielk1977595a5232009-07-24 17:58:53 +0000526 const char *zFormat = "vtable constructor did not declare schema: %s";
527 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
528 sqlite3VtabUnlock(pVTable);
529 rc = SQLITE_ERROR;
530 }else{
531 int iCol;
532 /* If everything went according to plan, link the new VTable structure
533 ** into the linked list headed by pTab->pVTable. Then loop through the
534 ** columns of the table to see if any of them contain the token "hidden".
drha371ace2012-09-13 14:22:47 +0000535 ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from
danielk1977595a5232009-07-24 17:58:53 +0000536 ** the type string. */
537 pVTable->pNext = pTab->pVTable;
538 pTab->pVTable = pVTable;
danielk1977034ca142007-06-26 10:38:54 +0000539
danielk1977595a5232009-07-24 17:58:53 +0000540 for(iCol=0; iCol<pTab->nCol; iCol++){
541 char *zType = pTab->aCol[iCol].zType;
542 int nType;
543 int i = 0;
544 if( !zType ) continue;
545 nType = sqlite3Strlen30(zType);
546 if( sqlite3StrNICmp("hidden", zType, 6)||(zType[6] && zType[6]!=' ') ){
547 for(i=0; i<nType; i++){
548 if( (0==sqlite3StrNICmp(" hidden", &zType[i], 7))
549 && (zType[i+7]=='\0' || zType[i+7]==' ')
550 ){
551 i++;
552 break;
553 }
danielk1977034ca142007-06-26 10:38:54 +0000554 }
555 }
danielk1977595a5232009-07-24 17:58:53 +0000556 if( i<nType ){
557 int j;
558 int nDel = 6 + (zType[i+6] ? 1 : 0);
559 for(j=i; (j+nDel)<=nType; j++){
560 zType[j] = zType[j+nDel];
561 }
562 if( zType[i]=='\0' && i>0 ){
563 assert(zType[i-1]==' ');
564 zType[i-1] = '\0';
565 }
drha371ace2012-09-13 14:22:47 +0000566 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
danielk1977034ca142007-06-26 10:38:54 +0000567 }
danielk1977034ca142007-06-26 10:38:54 +0000568 }
569 }
570 }
danielk1977595a5232009-07-24 17:58:53 +0000571
572 sqlite3DbFree(db, zModuleName);
danielk19779da9d472006-06-14 06:58:15 +0000573 return rc;
574}
575
576/*
danielk19777e6ebfb2006-06-12 11:24:37 +0000577** This function is invoked by the parser to call the xConnect() method
danielk1977fe3fcbe22006-06-12 12:08:45 +0000578** of the virtual table pTab. If an error occurs, an error code is returned
579** and an error left in pParse.
580**
581** This call is a no-op if table pTab is not a virtual table.
danielk19777e6ebfb2006-06-12 11:24:37 +0000582*/
583int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
danielk1977595a5232009-07-24 17:58:53 +0000584 sqlite3 *db = pParse->db;
585 const char *zMod;
danielk1977d1ab1ba2006-06-15 04:28:13 +0000586 Module *pMod;
danielk1977595a5232009-07-24 17:58:53 +0000587 int rc;
danielk19777e6ebfb2006-06-12 11:24:37 +0000588
drh748ce212009-05-20 20:10:47 +0000589 assert( pTab );
danielk1977595a5232009-07-24 17:58:53 +0000590 if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){
danielk19777e6ebfb2006-06-12 11:24:37 +0000591 return SQLITE_OK;
592 }
593
danielk1977595a5232009-07-24 17:58:53 +0000594 /* Locate the required virtual table module */
595 zMod = pTab->azModuleArg[0];
596 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod));
597
danielk1977d1ab1ba2006-06-15 04:28:13 +0000598 if( !pMod ){
danielk19777e6ebfb2006-06-12 11:24:37 +0000599 const char *zModule = pTab->azModuleArg[0];
danielk1977a4e76362006-06-14 06:31:28 +0000600 sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
danielk19777e6ebfb2006-06-12 11:24:37 +0000601 rc = SQLITE_ERROR;
danielk1977595a5232009-07-24 17:58:53 +0000602 }else{
danielk19779da9d472006-06-14 06:58:15 +0000603 char *zErr = 0;
danielk1977d1ab1ba2006-06-15 04:28:13 +0000604 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
danielk19779da9d472006-06-14 06:58:15 +0000605 if( rc!=SQLITE_OK ){
606 sqlite3ErrorMsg(pParse, "%s", zErr);
danielk19777e6ebfb2006-06-12 11:24:37 +0000607 }
drh633e6d52008-07-28 19:34:53 +0000608 sqlite3DbFree(db, zErr);
danielk19777e6ebfb2006-06-12 11:24:37 +0000609 }
610
611 return rc;
612}
danielk19779da9d472006-06-14 06:58:15 +0000613/*
dan2cac2072011-05-25 18:46:22 +0000614** Grow the db->aVTrans[] array so that there is room for at least one
615** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
danielk1977e7ff4032006-06-17 11:30:32 +0000616*/
dan2cac2072011-05-25 18:46:22 +0000617static int growVTrans(sqlite3 *db){
danielk1977e7ff4032006-06-17 11:30:32 +0000618 const int ARRAY_INCR = 5;
619
620 /* Grow the sqlite3.aVTrans array if required */
621 if( (db->nVTrans%ARRAY_INCR)==0 ){
danielk1977595a5232009-07-24 17:58:53 +0000622 VTable **aVTrans;
danielk1977e7ff4032006-06-17 11:30:32 +0000623 int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
danielk197726783a52007-08-29 14:06:22 +0000624 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
danielk1977e7ff4032006-06-17 11:30:32 +0000625 if( !aVTrans ){
626 return SQLITE_NOMEM;
627 }
628 memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
629 db->aVTrans = aVTrans;
630 }
631
dan2cac2072011-05-25 18:46:22 +0000632 return SQLITE_OK;
633}
634
635/*
636** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should
637** have already been reserved using growVTrans().
638*/
639static void addToVTrans(sqlite3 *db, VTable *pVTab){
danielk1977e7ff4032006-06-17 11:30:32 +0000640 /* Add pVtab to the end of sqlite3.aVTrans */
danielk1977595a5232009-07-24 17:58:53 +0000641 db->aVTrans[db->nVTrans++] = pVTab;
642 sqlite3VtabLock(pVTab);
danielk1977e7ff4032006-06-17 11:30:32 +0000643}
644
645/*
danielk19779da9d472006-06-14 06:58:15 +0000646** This function is invoked by the vdbe to call the xCreate method
647** of the virtual table named zTab in database iDb.
648**
649** If an error occurs, *pzErr is set to point an an English language
650** description of the error and an SQLITE_XXX error code is returned.
drh633e6d52008-07-28 19:34:53 +0000651** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
danielk19779da9d472006-06-14 06:58:15 +0000652*/
653int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
654 int rc = SQLITE_OK;
655 Table *pTab;
danielk1977d1ab1ba2006-06-15 04:28:13 +0000656 Module *pMod;
danielk1977595a5232009-07-24 17:58:53 +0000657 const char *zMod;
danielk19779da9d472006-06-14 06:58:15 +0000658
659 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
danielk1977595a5232009-07-24 17:58:53 +0000660 assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
661
662 /* Locate the required virtual table module */
663 zMod = pTab->azModuleArg[0];
664 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod));
danielk19779da9d472006-06-14 06:58:15 +0000665
666 /* If the module has been registered and includes a Create method,
667 ** invoke it now. If the module has not been registered, return an
668 ** error. Otherwise, do nothing.
669 */
danielk1977d1ab1ba2006-06-15 04:28:13 +0000670 if( !pMod ){
danielk1977595a5232009-07-24 17:58:53 +0000671 *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);
danielk19779da9d472006-06-14 06:58:15 +0000672 rc = SQLITE_ERROR;
673 }else{
danielk1977d1ab1ba2006-06-15 04:28:13 +0000674 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
danielk19779da9d472006-06-14 06:58:15 +0000675 }
676
drh748ce212009-05-20 20:10:47 +0000677 /* Justification of ALWAYS(): The xConstructor method is required to
678 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
danielk1977595a5232009-07-24 17:58:53 +0000679 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
dan2cac2072011-05-25 18:46:22 +0000680 rc = growVTrans(db);
681 if( rc==SQLITE_OK ){
682 addToVTrans(db, sqlite3GetVTable(db, pTab));
683 }
danielk1977e7ff4032006-06-17 11:30:32 +0000684 }
685
danielk19779da9d472006-06-14 06:58:15 +0000686 return rc;
687}
danielk1977be8a7832006-06-13 15:00:54 +0000688
689/*
danielk1977fe3fcbe22006-06-12 12:08:45 +0000690** This function is used to set the schema of a virtual table. It is only
691** valid to call this function from within the xCreate() or xConnect() of a
692** virtual table module.
693*/
danielk19777e6ebfb2006-06-12 11:24:37 +0000694int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
drhe98c9042009-06-02 21:31:38 +0000695 Parse *pParse;
danielk19777e6ebfb2006-06-12 11:24:37 +0000696
697 int rc = SQLITE_OK;
drh27641702007-08-22 02:56:42 +0000698 Table *pTab;
danielk19777e6ebfb2006-06-12 11:24:37 +0000699 char *zErr = 0;
700
drh27641702007-08-22 02:56:42 +0000701 sqlite3_mutex_enter(db->mutex);
dand9495cd2011-04-27 12:08:04 +0000702 if( !db->pVtabCtx || !(pTab = db->pVtabCtx->pTab) ){
danielk19777e6ebfb2006-06-12 11:24:37 +0000703 sqlite3Error(db, SQLITE_MISUSE, 0);
drh27641702007-08-22 02:56:42 +0000704 sqlite3_mutex_leave(db->mutex);
drh413c3d32010-02-23 20:11:56 +0000705 return SQLITE_MISUSE_BKPT;
danielk19777e6ebfb2006-06-12 11:24:37 +0000706 }
danielk1977595a5232009-07-24 17:58:53 +0000707 assert( (pTab->tabFlags & TF_Virtual)!=0 );
danielk19777e6ebfb2006-06-12 11:24:37 +0000708
drhe98c9042009-06-02 21:31:38 +0000709 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
710 if( pParse==0 ){
711 rc = SQLITE_NOMEM;
712 }else{
713 pParse->declareVtab = 1;
714 pParse->db = db;
drh8b307fb2010-04-06 15:57:05 +0000715 pParse->nQueryLoop = 1;
drhe98c9042009-06-02 21:31:38 +0000716
dan84db21e2009-12-08 19:05:53 +0000717 if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
dan84db21e2009-12-08 19:05:53 +0000718 && pParse->pNewTable
drh0e3c5122009-12-08 22:16:15 +0000719 && !db->mallocFailed
dan84db21e2009-12-08 19:05:53 +0000720 && !pParse->pNewTable->pSelect
721 && (pParse->pNewTable->tabFlags & TF_Virtual)==0
drhe98c9042009-06-02 21:31:38 +0000722 ){
danielk1977595a5232009-07-24 17:58:53 +0000723 if( !pTab->aCol ){
724 pTab->aCol = pParse->pNewTable->aCol;
725 pTab->nCol = pParse->pNewTable->nCol;
726 pParse->pNewTable->nCol = 0;
727 pParse->pNewTable->aCol = 0;
728 }
danb061d052011-04-25 18:49:57 +0000729 db->pVtabCtx->pTab = 0;
dan84db21e2009-12-08 19:05:53 +0000730 }else{
dan06b5db02010-10-21 15:12:44 +0000731 sqlite3Error(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);
dan78f9b732010-08-11 11:59:37 +0000732 sqlite3DbFree(db, zErr);
drhe98c9042009-06-02 21:31:38 +0000733 rc = SQLITE_ERROR;
734 }
735 pParse->declareVtab = 0;
736
737 if( pParse->pVdbe ){
738 sqlite3VdbeFinalize(pParse->pVdbe);
739 }
dan1feeaed2010-07-23 15:41:47 +0000740 sqlite3DeleteTable(db, pParse->pNewTable);
drhe98c9042009-06-02 21:31:38 +0000741 sqlite3StackFree(db, pParse);
danielk19777e6ebfb2006-06-12 11:24:37 +0000742 }
danielk19777e6ebfb2006-06-12 11:24:37 +0000743
drh4ac285a2006-09-15 07:28:50 +0000744 assert( (rc&0xff)==rc );
drh27641702007-08-22 02:56:42 +0000745 rc = sqlite3ApiExit(db, rc);
746 sqlite3_mutex_leave(db->mutex);
747 return rc;
danielk19777e6ebfb2006-06-12 11:24:37 +0000748}
749
750/*
danielk19779e39ce82006-06-12 16:01:21 +0000751** This function is invoked by the vdbe to call the xDestroy method
752** of the virtual table named zTab in database iDb. This occurs
753** when a DROP TABLE is mentioned.
754**
755** This call is a no-op if zTab is not a virtual table.
756*/
drh748ce212009-05-20 20:10:47 +0000757int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
danielk19779e39ce82006-06-12 16:01:21 +0000758 int rc = SQLITE_OK;
759 Table *pTab;
danielk19779e39ce82006-06-12 16:01:21 +0000760
761 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
danielk1977595a5232009-07-24 17:58:53 +0000762 if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
763 VTable *p = vtabDisconnectAll(db, pTab);
764
danielk19779e39ce82006-06-12 16:01:21 +0000765 assert( rc==SQLITE_OK );
danielk1977595a5232009-07-24 17:58:53 +0000766 rc = p->pMod->pModule->xDestroy(p->pVtab);
danielk1977595a5232009-07-24 17:58:53 +0000767
768 /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
danielk19779e39ce82006-06-12 16:01:21 +0000769 if( rc==SQLITE_OK ){
danielk1977595a5232009-07-24 17:58:53 +0000770 assert( pTab->pVTable==p && p->pNext==0 );
771 p->pVtab = 0;
772 pTab->pVTable = 0;
773 sqlite3VtabUnlock(p);
danielk19779e39ce82006-06-12 16:01:21 +0000774 }
775 }
776
777 return rc;
778}
779
danielk1977f9e7dda2006-06-16 16:08:53 +0000780/*
danielk1977e7ff4032006-06-17 11:30:32 +0000781** This function invokes either the xRollback or xCommit method
782** of each of the virtual tables in the sqlite3.aVTrans array. The method
783** called is identified by the second argument, "offset", which is
784** the offset of the method to call in the sqlite3_module structure.
785**
786** The array is cleared after invoking the callbacks.
787*/
drh7209c692008-04-27 18:40:11 +0000788static void callFinaliser(sqlite3 *db, int offset){
danielk1977e7ff4032006-06-17 11:30:32 +0000789 int i;
danielk19770b83fa82007-04-19 14:48:37 +0000790 if( db->aVTrans ){
drh748ce212009-05-20 20:10:47 +0000791 for(i=0; i<db->nVTrans; i++){
danielk1977595a5232009-07-24 17:58:53 +0000792 VTable *pVTab = db->aVTrans[i];
793 sqlite3_vtab *p = pVTab->pVtab;
794 if( p ){
795 int (*x)(sqlite3_vtab *);
796 x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
797 if( x ) x(p);
798 }
drh346506f2011-05-25 01:16:42 +0000799 pVTab->iSavepoint = 0;
danielk1977595a5232009-07-24 17:58:53 +0000800 sqlite3VtabUnlock(pVTab);
danielk19770b83fa82007-04-19 14:48:37 +0000801 }
drh633e6d52008-07-28 19:34:53 +0000802 sqlite3DbFree(db, db->aVTrans);
danielk19770b83fa82007-04-19 14:48:37 +0000803 db->nVTrans = 0;
804 db->aVTrans = 0;
danielk1977e7ff4032006-06-17 11:30:32 +0000805 }
danielk1977e7ff4032006-06-17 11:30:32 +0000806}
807
808/*
danielk19773e3a84d2008-08-01 17:37:40 +0000809** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
810** array. Return the error code for the first error that occurs, or
811** SQLITE_OK if all xSync operations are successful.
812**
dan016f7812013-08-21 17:35:48 +0000813** If an error message is available, leave it in p->zErrMsg.
danielk1977f9e7dda2006-06-16 16:08:53 +0000814*/
dan016f7812013-08-21 17:35:48 +0000815int sqlite3VtabSync(sqlite3 *db, Vdbe *p){
danielk1977e7ff4032006-06-17 11:30:32 +0000816 int i;
817 int rc = SQLITE_OK;
danielk1977595a5232009-07-24 17:58:53 +0000818 VTable **aVTrans = db->aVTrans;
danielk197720b1eaf2006-07-26 16:22:14 +0000819
danielk197720b1eaf2006-07-26 16:22:14 +0000820 db->aVTrans = 0;
drh748ce212009-05-20 20:10:47 +0000821 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
danielk1977e7ff4032006-06-17 11:30:32 +0000822 int (*x)(sqlite3_vtab *);
danielk1977595a5232009-07-24 17:58:53 +0000823 sqlite3_vtab *pVtab = aVTrans[i]->pVtab;
824 if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
danielk1977e7ff4032006-06-17 11:30:32 +0000825 rc = x(pVtab);
dan016f7812013-08-21 17:35:48 +0000826 sqlite3VtabImportErrmsg(p, pVtab);
danielk1977e7ff4032006-06-17 11:30:32 +0000827 }
828 }
danielk197720b1eaf2006-07-26 16:22:14 +0000829 db->aVTrans = aVTrans;
danielk1977e7ff4032006-06-17 11:30:32 +0000830 return rc;
danielk1977f9e7dda2006-06-16 16:08:53 +0000831}
832
833/*
834** Invoke the xRollback method of all virtual tables in the
835** sqlite3.aVTrans array. Then clear the array itself.
836*/
837int sqlite3VtabRollback(sqlite3 *db){
drh7209c692008-04-27 18:40:11 +0000838 callFinaliser(db, offsetof(sqlite3_module,xRollback));
danielk1977e7ff4032006-06-17 11:30:32 +0000839 return SQLITE_OK;
danielk1977f9e7dda2006-06-16 16:08:53 +0000840}
841
842/*
843** Invoke the xCommit method of all virtual tables in the
844** sqlite3.aVTrans array. Then clear the array itself.
845*/
846int sqlite3VtabCommit(sqlite3 *db){
drh7209c692008-04-27 18:40:11 +0000847 callFinaliser(db, offsetof(sqlite3_module,xCommit));
danielk1977e7ff4032006-06-17 11:30:32 +0000848 return SQLITE_OK;
danielk1977f9e7dda2006-06-16 16:08:53 +0000849}
850
851/*
852** If the virtual table pVtab supports the transaction interface
853** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
854** not currently open, invoke the xBegin method now.
855**
856** If the xBegin call is successful, place the sqlite3_vtab pointer
857** in the sqlite3.aVTrans array.
858*/
danielk1977595a5232009-07-24 17:58:53 +0000859int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){
danielk1977f9e7dda2006-06-16 16:08:53 +0000860 int rc = SQLITE_OK;
danielk197720b1eaf2006-07-26 16:22:14 +0000861 const sqlite3_module *pModule;
862
863 /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
864 ** than zero, then this function is being called from within a
865 ** virtual module xSync() callback. It is illegal to write to
drh748ce212009-05-20 20:10:47 +0000866 ** virtual module tables in this case, so return SQLITE_LOCKED.
danielk197720b1eaf2006-07-26 16:22:14 +0000867 */
danielk1977093e0f62008-11-13 18:00:14 +0000868 if( sqlite3VtabInSync(db) ){
danielk197720b1eaf2006-07-26 16:22:14 +0000869 return SQLITE_LOCKED;
870 }
danielk1977595a5232009-07-24 17:58:53 +0000871 if( !pVTab ){
danielk197720b1eaf2006-07-26 16:22:14 +0000872 return SQLITE_OK;
873 }
danielk1977595a5232009-07-24 17:58:53 +0000874 pModule = pVTab->pVtab->pModule;
danielk197720b1eaf2006-07-26 16:22:14 +0000875
danielk1977f9e7dda2006-06-16 16:08:53 +0000876 if( pModule->xBegin ){
877 int i;
878
879 /* If pVtab is already in the aVTrans array, return early */
drh748ce212009-05-20 20:10:47 +0000880 for(i=0; i<db->nVTrans; i++){
danielk1977595a5232009-07-24 17:58:53 +0000881 if( db->aVTrans[i]==pVTab ){
danielk1977f9e7dda2006-06-16 16:08:53 +0000882 return SQLITE_OK;
883 }
884 }
885
dan2cac2072011-05-25 18:46:22 +0000886 /* Invoke the xBegin method. If successful, add the vtab to the
887 ** sqlite3.aVTrans[] array. */
888 rc = growVTrans(db);
danielk19773e3a84d2008-08-01 17:37:40 +0000889 if( rc==SQLITE_OK ){
dan2cac2072011-05-25 18:46:22 +0000890 rc = pModule->xBegin(pVTab->pVtab);
891 if( rc==SQLITE_OK ){
892 addToVTrans(db, pVTab);
893 }
danielk1977f9e7dda2006-06-16 16:08:53 +0000894 }
danielk1977f9e7dda2006-06-16 16:08:53 +0000895 }
896 return rc;
897}
898
dand9495cd2011-04-27 12:08:04 +0000899/*
900** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
901** virtual tables that currently have an open transaction. Pass iSavepoint
902** as the second argument to the virtual table method invoked.
903**
904** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is
905** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is
906** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
907** an open transaction is invoked.
908**
909** If any virtual table method returns an error code other than SQLITE_OK,
910** processing is abandoned and the error returned to the caller of this
911** function immediately. If all calls to virtual table methods are successful,
912** SQLITE_OK is returned.
913*/
dana311b802011-04-26 19:21:34 +0000914int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
dana311b802011-04-26 19:21:34 +0000915 int rc = SQLITE_OK;
916
917 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
drh346506f2011-05-25 01:16:42 +0000918 assert( iSavepoint>=0 );
dand9495cd2011-04-27 12:08:04 +0000919 if( db->aVTrans ){
920 int i;
921 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
drhe4855222011-05-24 15:36:01 +0000922 VTable *pVTab = db->aVTrans[i];
923 const sqlite3_module *pMod = pVTab->pMod->pModule;
dan341cade2011-10-29 11:43:04 +0000924 if( pVTab->pVtab && pMod->iVersion>=2 ){
dand9495cd2011-04-27 12:08:04 +0000925 int (*xMethod)(sqlite3_vtab *, int);
926 switch( op ){
927 case SAVEPOINT_BEGIN:
928 xMethod = pMod->xSavepoint;
drh346506f2011-05-25 01:16:42 +0000929 pVTab->iSavepoint = iSavepoint+1;
dand9495cd2011-04-27 12:08:04 +0000930 break;
931 case SAVEPOINT_ROLLBACK:
932 xMethod = pMod->xRollbackTo;
933 break;
934 default:
935 xMethod = pMod->xRelease;
936 break;
937 }
drh346506f2011-05-25 01:16:42 +0000938 if( xMethod && pVTab->iSavepoint>iSavepoint ){
dan341cade2011-10-29 11:43:04 +0000939 rc = xMethod(pVTab->pVtab, iSavepoint);
drh346506f2011-05-25 01:16:42 +0000940 }
dana311b802011-04-26 19:21:34 +0000941 }
942 }
943 }
944 return rc;
945}
946
drhb7f6f682006-07-08 17:06:43 +0000947/*
948** The first parameter (pDef) is a function implementation. The
949** second parameter (pExpr) is the first argument to this function.
950** If pExpr is a column in a virtual table, then let the virtual
951** table implementation have an opportunity to overload the function.
952**
953** This routine is used to allow virtual table implementations to
954** overload MATCH, LIKE, GLOB, and REGEXP operators.
955**
956** Return either the pDef argument (indicating no change) or a
957** new FuncDef structure that is marked as ephemeral using the
958** SQLITE_FUNC_EPHEM flag.
959*/
960FuncDef *sqlite3VtabOverloadFunction(
drh17435752007-08-16 04:30:38 +0000961 sqlite3 *db, /* Database connection for reporting malloc problems */
drhb7f6f682006-07-08 17:06:43 +0000962 FuncDef *pDef, /* Function to possibly overload */
963 int nArg, /* Number of arguments to the function */
964 Expr *pExpr /* First argument to the function */
965){
966 Table *pTab;
967 sqlite3_vtab *pVtab;
968 sqlite3_module *pMod;
drhdc5ea5c2008-12-10 17:19:59 +0000969 void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
970 void *pArg = 0;
drhb7f6f682006-07-08 17:06:43 +0000971 FuncDef *pNew;
drh777b17a2007-09-20 10:02:54 +0000972 int rc = 0;
drha70034d2006-09-18 20:24:02 +0000973 char *zLowerName;
974 unsigned char *z;
975
drhb7f6f682006-07-08 17:06:43 +0000976
977 /* Check to see the left operand is a column in a virtual table */
drh748ce212009-05-20 20:10:47 +0000978 if( NEVER(pExpr==0) ) return pDef;
drhb7f6f682006-07-08 17:06:43 +0000979 if( pExpr->op!=TK_COLUMN ) return pDef;
980 pTab = pExpr->pTab;
drh748ce212009-05-20 20:10:47 +0000981 if( NEVER(pTab==0) ) return pDef;
drh7d10d5a2008-08-20 16:35:10 +0000982 if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
danielk1977595a5232009-07-24 17:58:53 +0000983 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
drhb7f6f682006-07-08 17:06:43 +0000984 assert( pVtab!=0 );
985 assert( pVtab->pModule!=0 );
danielk19775bd270b2006-07-25 15:14:52 +0000986 pMod = (sqlite3_module *)pVtab->pModule;
drhb7f6f682006-07-08 17:06:43 +0000987 if( pMod->xFindFunction==0 ) return pDef;
988
rseb72e88d2007-09-20 11:32:18 +0000989 /* Call the xFindFunction method on the virtual table implementation
drha70034d2006-09-18 20:24:02 +0000990 ** to see if the implementation wants to overload this function
991 */
drh17435752007-08-16 04:30:38 +0000992 zLowerName = sqlite3DbStrDup(db, pDef->zName);
993 if( zLowerName ){
994 for(z=(unsigned char*)zLowerName; *z; z++){
995 *z = sqlite3UpperToLower[*z];
996 }
997 rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
drh633e6d52008-07-28 19:34:53 +0000998 sqlite3DbFree(db, zLowerName);
drha70034d2006-09-18 20:24:02 +0000999 }
drha70034d2006-09-18 20:24:02 +00001000 if( rc==0 ){
drhb7f6f682006-07-08 17:06:43 +00001001 return pDef;
1002 }
1003
1004 /* Create a new ephemeral function definition for the overloaded
1005 ** function */
drhea678832008-12-10 19:26:22 +00001006 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
danielk1977e25a50b2009-07-01 18:04:20 +00001007 + sqlite3Strlen30(pDef->zName) + 1);
drhb7f6f682006-07-08 17:06:43 +00001008 if( pNew==0 ){
1009 return pDef;
1010 }
1011 *pNew = *pDef;
danielk19778c0a7912008-08-20 14:49:23 +00001012 pNew->zName = (char *)&pNew[1];
drhea678832008-12-10 19:26:22 +00001013 memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
drhb7f6f682006-07-08 17:06:43 +00001014 pNew->xFunc = xFunc;
1015 pNew->pUserData = pArg;
drhb7f6f682006-07-08 17:06:43 +00001016 pNew->flags |= SQLITE_FUNC_EPHEM;
1017 return pNew;
1018}
1019
drh4f3dd152008-04-28 18:46:43 +00001020/*
1021** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
1022** array so that an OP_VBegin will get generated for it. Add pTab to the
1023** array if it is missing. If pTab is already in the array, this routine
1024** is a no-op.
1025*/
1026void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
dan65a7cd12009-09-01 12:16:01 +00001027 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh4f3dd152008-04-28 18:46:43 +00001028 int i, n;
drh748ce212009-05-20 20:10:47 +00001029 Table **apVtabLock;
1030
drh4f3dd152008-04-28 18:46:43 +00001031 assert( IsVirtual(pTab) );
dan65a7cd12009-09-01 12:16:01 +00001032 for(i=0; i<pToplevel->nVtabLock; i++){
1033 if( pTab==pToplevel->apVtabLock[i] ) return;
drh4f3dd152008-04-28 18:46:43 +00001034 }
dan65a7cd12009-09-01 12:16:01 +00001035 n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
1036 apVtabLock = sqlite3_realloc(pToplevel->apVtabLock, n);
drh748ce212009-05-20 20:10:47 +00001037 if( apVtabLock ){
dan65a7cd12009-09-01 12:16:01 +00001038 pToplevel->apVtabLock = apVtabLock;
1039 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
drh344c38e2008-05-05 13:23:04 +00001040 }else{
dan65a7cd12009-09-01 12:16:01 +00001041 pToplevel->db->mallocFailed = 1;
drh4f3dd152008-04-28 18:46:43 +00001042 }
1043}
1044
drhef45bb72011-05-05 15:39:50 +00001045/*
1046** Return the ON CONFLICT resolution mode in effect for the virtual
1047** table update operation currently in progress.
1048**
1049** The results of this routine are undefined unless it is called from
1050** within an xUpdate method.
1051*/
danb061d052011-04-25 18:49:57 +00001052int sqlite3_vtab_on_conflict(sqlite3 *db){
drhef45bb72011-05-05 15:39:50 +00001053 static const unsigned char aMap[] = {
drh87f67bf2011-05-05 17:41:58 +00001054 SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
danb061d052011-04-25 18:49:57 +00001055 };
1056 assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
1057 assert( OE_Ignore==4 && OE_Replace==5 );
1058 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
drhef45bb72011-05-05 15:39:50 +00001059 return (int)aMap[db->vtabOnConflict-1];
danb061d052011-04-25 18:49:57 +00001060}
1061
drhef45bb72011-05-05 15:39:50 +00001062/*
1063** Call from within the xCreate() or xConnect() methods to provide
1064** the SQLite core with additional information about the behavior
1065** of the virtual table being implemented.
1066*/
danb061d052011-04-25 18:49:57 +00001067int sqlite3_vtab_config(sqlite3 *db, int op, ...){
1068 va_list ap;
1069 int rc = SQLITE_OK;
1070
1071 sqlite3_mutex_enter(db->mutex);
1072
1073 va_start(ap, op);
1074 switch( op ){
1075 case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
1076 VtabCtx *p = db->pVtabCtx;
1077 if( !p ){
1078 rc = SQLITE_MISUSE_BKPT;
1079 }else{
drh367e84d2011-05-05 23:07:43 +00001080 assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
danb061d052011-04-25 18:49:57 +00001081 p->pVTable->bConstraint = (u8)va_arg(ap, int);
1082 }
1083 break;
1084 }
1085 default:
1086 rc = SQLITE_MISUSE_BKPT;
1087 break;
1088 }
1089 va_end(ap);
1090
1091 if( rc!=SQLITE_OK ) sqlite3Error(db, rc, 0);
1092 sqlite3_mutex_leave(db->mutex);
1093 return rc;
1094}
1095
drhb9bb7c12006-06-11 23:41:55 +00001096#endif /* SQLITE_OMIT_VIRTUALTABLE */