drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 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. |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 13 | */ |
| 14 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 15 | #include "sqliteInt.h" |
| 16 | |
drh | 6384241 | 2009-04-11 16:27:19 +0000 | [diff] [blame] | 17 | /* |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 18 | ** Before a virtual table xCreate() or xConnect() method is invoked, the |
| 19 | ** sqlite3.pVtabCtx member variable is set to point to an instance of |
| 20 | ** this struct allocated on the stack. It is used by the implementation of |
| 21 | ** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which |
| 22 | ** are invoked only from within xCreate and xConnect methods. |
| 23 | */ |
| 24 | struct VtabCtx { |
drh | 81028a4 | 2012-05-15 18:28:27 +0000 | [diff] [blame] | 25 | VTable *pVTable; /* The virtual table being constructed */ |
| 26 | Table *pTab; /* The Table object to which the virtual table belongs */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 27 | }; |
| 28 | |
| 29 | /* |
drh | 6384241 | 2009-04-11 16:27:19 +0000 | [diff] [blame] | 30 | ** The actual function that does the work of creating a new module. |
| 31 | ** This function implements the sqlite3_create_module() and |
| 32 | ** sqlite3_create_module_v2() interfaces. |
| 33 | */ |
danielk1977 | 832a58a | 2007-06-22 15:21:15 +0000 | [diff] [blame] | 34 | static int createModule( |
| 35 | sqlite3 *db, /* Database in which module is registered */ |
| 36 | const char *zName, /* Name assigned to this module */ |
| 37 | const sqlite3_module *pModule, /* The definition of the module */ |
| 38 | void *pAux, /* Context pointer for xCreate/xConnect */ |
| 39 | void (*xDestroy)(void *) /* Module destructor function */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 40 | ){ |
dan | ca8b9ba | 2012-05-16 14:29:11 +0000 | [diff] [blame] | 41 | int rc = SQLITE_OK; |
| 42 | int nName; |
drh | 2764170 | 2007-08-22 02:56:42 +0000 | [diff] [blame] | 43 | |
| 44 | sqlite3_mutex_enter(db->mutex); |
drh | ea67883 | 2008-12-10 19:26:22 +0000 | [diff] [blame] | 45 | nName = sqlite3Strlen30(zName); |
dan | ca8b9ba | 2012-05-16 14:29:11 +0000 | [diff] [blame] | 46 | 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 | } |
danielk1977 | 832a58a | 2007-06-22 15:21:15 +0000 | [diff] [blame] | 65 | } |
danielk1977 | 832a58a | 2007-06-22 15:21:15 +0000 | [diff] [blame] | 66 | } |
dan | ca8b9ba | 2012-05-16 14:29:11 +0000 | [diff] [blame] | 67 | rc = sqlite3ApiExit(db, rc); |
| 68 | if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux); |
| 69 | |
drh | 2764170 | 2007-08-22 02:56:42 +0000 | [diff] [blame] | 70 | sqlite3_mutex_leave(db->mutex); |
| 71 | return rc; |
danielk1977 | 832a58a | 2007-06-22 15:21:15 +0000 | [diff] [blame] | 72 | } |
| 73 | |
| 74 | |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 75 | /* |
| 76 | ** External API function used to create a new virtual-table module. |
| 77 | */ |
| 78 | int sqlite3_create_module( |
| 79 | sqlite3 *db, /* Database in which module is registered */ |
| 80 | const char *zName, /* Name assigned to this module */ |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 81 | const sqlite3_module *pModule, /* The definition of the module */ |
| 82 | void *pAux /* Context pointer for xCreate/xConnect */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 83 | ){ |
danielk1977 | 832a58a | 2007-06-22 15:21:15 +0000 | [diff] [blame] | 84 | return createModule(db, zName, pModule, pAux, 0); |
| 85 | } |
| 86 | |
| 87 | /* |
| 88 | ** External API function used to create a new virtual-table module. |
| 89 | */ |
| 90 | int 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); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 98 | } |
| 99 | |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 100 | /* |
drh | 189d4af | 2006-09-02 20:57:52 +0000 | [diff] [blame] | 101 | ** 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 | */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 108 | void 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 | */ |
| 118 | VTable *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; |
drh | 189d4af | 2006-09-02 20:57:52 +0000 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | /* |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 126 | ** Decrement the ref-count on a virtual table object. When the ref-count |
| 127 | ** reaches zero, call the xDisconnect() method to delete the object. |
drh | 189d4af | 2006-09-02 20:57:52 +0000 | [diff] [blame] | 128 | */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 129 | void sqlite3VtabUnlock(VTable *pVTab){ |
| 130 | sqlite3 *db = pVTab->db; |
| 131 | |
| 132 | assert( db ); |
| 133 | assert( pVTab->nRef>0 ); |
drh | 04f2e34 | 2012-08-27 14:39:47 +0000 | [diff] [blame] | 134 | assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE ); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 135 | |
| 136 | pVTab->nRef--; |
| 137 | if( pVTab->nRef==0 ){ |
| 138 | sqlite3_vtab *p = pVTab->pVtab; |
| 139 | if( p ){ |
drh | 9978c97 | 2010-02-23 17:36:32 +0000 | [diff] [blame] | 140 | p->pModule->xDisconnect(p); |
danielk1977 | a04a34f | 2007-04-16 15:06:25 +0000 | [diff] [blame] | 141 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 142 | 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 | */ |
| 153 | static 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 |
drh | 9bbc2e2 | 2011-04-04 20:40:22 +0000 | [diff] [blame] | 162 | ** database connection that may have an entry in the p->pVTable list. |
| 163 | */ |
| 164 | assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 165 | |
| 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 | |
dan | bba02a9 | 2012-05-15 17:15:34 +0000 | [diff] [blame] | 185 | /* |
| 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 | */ |
| 193 | void 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 | |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 210 | |
| 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 | */ |
| 231 | void 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 ); |
drh | 189d4af | 2006-09-02 20:57:52 +0000 | [diff] [blame] | 245 | } |
| 246 | } |
| 247 | |
| 248 | /* |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 249 | ** 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. |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 252 | ** |
| 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. |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 261 | */ |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 262 | void sqlite3VtabClear(sqlite3 *db, Table *p){ |
dan | d46def7 | 2010-07-24 11:28:28 +0000 | [diff] [blame] | 263 | if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 264 | if( p->azModuleArg ){ |
| 265 | int i; |
| 266 | for(i=0; i<p->nModuleArg; i++){ |
drh | 5a55826 | 2012-10-09 14:36:47 +0000 | [diff] [blame] | 267 | if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 268 | } |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 269 | sqlite3DbFree(db, p->azModuleArg); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 270 | } |
| 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 | */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 279 | static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 280 | int i = pTable->nModuleArg++; |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 281 | int nBytes = sizeof(char *)*(1+pTable->nModuleArg); |
| 282 | char **azModuleArg; |
danielk1977 | 26783a5 | 2007-08-29 14:06:22 +0000 | [diff] [blame] | 283 | azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes); |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 284 | if( azModuleArg==0 ){ |
| 285 | int j; |
| 286 | for(j=0; j<i; j++){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 287 | sqlite3DbFree(db, pTable->azModuleArg[j]); |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 288 | } |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 289 | sqlite3DbFree(db, zArg); |
| 290 | sqlite3DbFree(db, pTable->azModuleArg); |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 291 | pTable->nModuleArg = 0; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 292 | }else{ |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 293 | azModuleArg[i] = zArg; |
| 294 | azModuleArg[i+1] = 0; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 295 | } |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 296 | pTable->azModuleArg = azModuleArg; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 297 | } |
| 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 | */ |
| 304 | void 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 */ |
drh | b421b89 | 2012-01-28 19:41:53 +0000 | [diff] [blame] | 308 | Token *pModuleName, /* Name of the module for the virtual table */ |
| 309 | int ifNotExists /* No error if the table already exists */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 310 | ){ |
danielk1977 | f1a381e | 2006-06-16 08:01:02 +0000 | [diff] [blame] | 311 | int iDb; /* The database the table is being created in */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 312 | Table *pTable; /* The new virtual table */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 313 | sqlite3 *db; /* Database connection */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 314 | |
drh | b421b89 | 2012-01-28 19:41:53 +0000 | [diff] [blame] | 315 | sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 316 | pTable = pParse->pNewTable; |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 317 | if( pTable==0 ) return; |
danielk1977 | f1a381e | 2006-06-16 08:01:02 +0000 | [diff] [blame] | 318 | assert( 0==pTable->pIndex ); |
| 319 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 320 | db = pParse->db; |
| 321 | iDb = sqlite3SchemaToIndex(db, pTable->pSchema); |
danielk1977 | 70ba164 | 2006-06-21 16:02:42 +0000 | [diff] [blame] | 322 | assert( iDb>=0 ); |
| 323 | |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 324 | pTable->tabFlags |= TF_Virtual; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 325 | pTable->nModuleArg = 0; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 326 | addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName)); |
dan | 41fb5cd | 2012-10-04 19:33:00 +0000 | [diff] [blame] | 327 | addModuleArgument(db, pTable, 0); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 328 | addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName)); |
drh | b27b7f5 | 2008-12-10 18:03:45 +0000 | [diff] [blame] | 329 | pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z); |
danielk1977 | f1a381e | 2006-06-16 08:01:02 +0000 | [diff] [blame] | 330 | |
| 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 | */ |
danielk1977 | be71889 | 2006-06-23 08:05:19 +0000 | [diff] [blame] | 337 | if( pTable->azModuleArg ){ |
| 338 | sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, |
| 339 | pTable->azModuleArg[0], pParse->db->aDb[iDb].zName); |
danielk1977 | f1a381e | 2006-06-16 08:01:02 +0000 | [diff] [blame] | 340 | } |
| 341 | #endif |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 342 | } |
| 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 | */ |
| 349 | static void addArgumentToVtab(Parse *pParse){ |
drh | b421b89 | 2012-01-28 19:41:53 +0000 | [diff] [blame] | 350 | if( pParse->sArg.z && pParse->pNewTable ){ |
drh | 7c2d87c | 2006-09-02 14:16:59 +0000 | [diff] [blame] | 351 | const char *z = (const char*)pParse->sArg.z; |
danielk1977 | 33b3933 | 2006-06-24 08:51:05 +0000 | [diff] [blame] | 352 | int n = pParse->sArg.n; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 353 | sqlite3 *db = pParse->db; |
| 354 | addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n)); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 355 | } |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 356 | } |
| 357 | |
| 358 | /* |
| 359 | ** The parser calls this routine after the CREATE VIRTUAL TABLE statement |
| 360 | ** has been completely parsed. |
| 361 | */ |
| 362 | void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 363 | Table *pTab = pParse->pNewTable; /* The table being constructed */ |
| 364 | sqlite3 *db = pParse->db; /* The database connection */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 365 | |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 366 | if( pTab==0 ) return; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 367 | addArgumentToVtab(pParse); |
danielk1977 | 33b3933 | 2006-06-24 08:51:05 +0000 | [diff] [blame] | 368 | pParse->sArg.z = 0; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 369 | if( pTab->nModuleArg<1 ) return; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 370 | |
| 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; |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 379 | char *zWhere; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 380 | int iDb; |
| 381 | Vdbe *v; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 382 | |
| 383 | /* Compute the complete text of the CREATE VIRTUAL TABLE statement */ |
| 384 | if( pEnd ){ |
drh | b27b7f5 | 2008-12-10 18:03:45 +0000 | [diff] [blame] | 385 | pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 386 | } |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 387 | zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 388 | |
| 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 |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 391 | ** the information we've collected. |
| 392 | ** |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 393 | ** 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(). |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 396 | */ |
| 397 | iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
| 398 | sqlite3NestedParse(pParse, |
| 399 | "UPDATE %Q.%s " |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 400 | "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q " |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 401 | "WHERE rowid=#%d", |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 402 | db->aDb[iDb].zName, SCHEMA_TABLE(iDb), |
| 403 | pTab->zName, |
| 404 | pTab->zName, |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 405 | zStmt, |
| 406 | pParse->regRowid |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 407 | ); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 408 | sqlite3DbFree(db, zStmt); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 409 | v = sqlite3GetVdbe(pParse); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 410 | sqlite3ChangeCookie(pParse, iDb); |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 411 | |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 412 | sqlite3VdbeAddOp2(v, OP_Expire, 0, 0); |
dan | 39f1bcb | 2010-09-29 07:16:46 +0000 | [diff] [blame] | 413 | zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName); |
drh | 5d9c9da | 2011-06-03 20:11:17 +0000 | [diff] [blame] | 414 | sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 415 | sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0, |
drh | ea67883 | 2008-12-10 19:26:22 +0000 | [diff] [blame] | 416 | pTab->zName, sqlite3Strlen30(pTab->zName) + 1); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 417 | } |
| 418 | |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 419 | /* If we are rereading the sqlite_master table create the in-memory |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 420 | ** 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. */ |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 424 | else { |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 425 | Table *pOld; |
| 426 | Schema *pSchema = pTab->pSchema; |
| 427 | const char *zName = pTab->zName; |
drh | a83ccca | 2009-04-28 13:01:09 +0000 | [diff] [blame] | 428 | int nName = sqlite3Strlen30(zName); |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 429 | assert( sqlite3SchemaMutexHeld(db, 0, pSchema) ); |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 430 | pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab); |
| 431 | if( pOld ){ |
danielk1977 | a1644fd | 2007-08-29 12:31:25 +0000 | [diff] [blame] | 432 | db->mallocFailed = 1; |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 433 | assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */ |
| 434 | return; |
| 435 | } |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 436 | pParse->pNewTable = 0; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 437 | } |
| 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 | */ |
| 444 | void sqlite3VtabArgInit(Parse *pParse){ |
| 445 | addArgumentToVtab(pParse); |
danielk1977 | 33b3933 | 2006-06-24 08:51:05 +0000 | [diff] [blame] | 446 | pParse->sArg.z = 0; |
| 447 | pParse->sArg.n = 0; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 448 | } |
| 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 | */ |
| 454 | void sqlite3VtabArgExtend(Parse *pParse, Token *p){ |
danielk1977 | 33b3933 | 2006-06-24 08:51:05 +0000 | [diff] [blame] | 455 | 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); |
drh | b27b7f5 | 2008-12-10 18:03:45 +0000 | [diff] [blame] | 461 | pArg->n = (int)(&p->z[p->n] - pArg->z); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 462 | } |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 463 | } |
| 464 | |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 465 | /* |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 466 | ** 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 | */ |
| 470 | static int vtabCallConstructor( |
| 471 | sqlite3 *db, |
| 472 | Table *pTab, |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 473 | Module *pMod, |
drh | e410296 | 2006-09-11 00:34:22 +0000 | [diff] [blame] | 474 | int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**), |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 475 | char **pzErr |
| 476 | ){ |
drh | 9250581 | 2012-04-26 22:47:20 +0000 | [diff] [blame] | 477 | VtabCtx sCtx, *pPriorCtx; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 478 | VTable *pVTable; |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 479 | int rc; |
drh | e410296 | 2006-09-11 00:34:22 +0000 | [diff] [blame] | 480 | const char *const*azArg = (const char *const*)pTab->azModuleArg; |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 481 | int nArg = pTab->nModuleArg; |
drh | 4ca8aac | 2006-09-10 17:31:58 +0000 | [diff] [blame] | 482 | char *zErr = 0; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 483 | char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName); |
dan | 41fb5cd | 2012-10-04 19:33:00 +0000 | [diff] [blame] | 484 | int iDb; |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 485 | |
danielk1977 | 0125683 | 2007-04-18 14:24:32 +0000 | [diff] [blame] | 486 | if( !zModuleName ){ |
| 487 | return SQLITE_NOMEM; |
| 488 | } |
| 489 | |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 490 | 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 | |
dan | 41fb5cd | 2012-10-04 19:33:00 +0000 | [diff] [blame] | 498 | iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
| 499 | pTab->azModuleArg[1] = db->aDb[iDb].zName; |
| 500 | |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 501 | /* Invoke the virtual table constructor */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 502 | assert( &db->pVtabCtx ); |
| 503 | assert( xConstruct ); |
| 504 | sCtx.pTab = pTab; |
| 505 | sCtx.pVTable = pVTable; |
drh | 9250581 | 2012-04-26 22:47:20 +0000 | [diff] [blame] | 506 | pPriorCtx = db->pVtabCtx; |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 507 | db->pVtabCtx = &sCtx; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 508 | rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr); |
drh | 9250581 | 2012-04-26 22:47:20 +0000 | [diff] [blame] | 509 | db->pVtabCtx = pPriorCtx; |
drh | 55f04f2 | 2009-05-11 23:37:59 +0000 | [diff] [blame] | 510 | if( rc==SQLITE_NOMEM ) db->mallocFailed = 1; |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 511 | |
| 512 | if( SQLITE_OK!=rc ){ |
drh | 4ca8aac | 2006-09-10 17:31:58 +0000 | [diff] [blame] | 513 | if( zErr==0 ){ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 514 | *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName); |
drh | 4ca8aac | 2006-09-10 17:31:58 +0000 | [diff] [blame] | 515 | }else { |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 516 | *pzErr = sqlite3MPrintf(db, "%s", zErr); |
drh | b975598 | 2010-07-24 16:34:37 +0000 | [diff] [blame] | 517 | sqlite3_free(zErr); |
drh | fe1368e | 2006-09-10 17:08:29 +0000 | [diff] [blame] | 518 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 519 | 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; |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 525 | if( sCtx.pTab ){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 526 | 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". |
drh | a371ace | 2012-09-13 14:22:47 +0000 | [diff] [blame] | 535 | ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 536 | ** the type string. */ |
| 537 | pVTable->pNext = pTab->pVTable; |
| 538 | pTab->pVTable = pVTable; |
danielk1977 | 034ca14 | 2007-06-26 10:38:54 +0000 | [diff] [blame] | 539 | |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 540 | 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 | } |
danielk1977 | 034ca14 | 2007-06-26 10:38:54 +0000 | [diff] [blame] | 554 | } |
| 555 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 556 | 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 | } |
drh | a371ace | 2012-09-13 14:22:47 +0000 | [diff] [blame] | 566 | pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN; |
danielk1977 | 034ca14 | 2007-06-26 10:38:54 +0000 | [diff] [blame] | 567 | } |
danielk1977 | 034ca14 | 2007-06-26 10:38:54 +0000 | [diff] [blame] | 568 | } |
| 569 | } |
| 570 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 571 | |
| 572 | sqlite3DbFree(db, zModuleName); |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 573 | return rc; |
| 574 | } |
| 575 | |
| 576 | /* |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 577 | ** This function is invoked by the parser to call the xConnect() method |
danielk1977 | fe3fcbe2 | 2006-06-12 12:08:45 +0000 | [diff] [blame] | 578 | ** 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. |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 582 | */ |
| 583 | int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 584 | sqlite3 *db = pParse->db; |
| 585 | const char *zMod; |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 586 | Module *pMod; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 587 | int rc; |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 588 | |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 589 | assert( pTab ); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 590 | if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){ |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 591 | return SQLITE_OK; |
| 592 | } |
| 593 | |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 594 | /* Locate the required virtual table module */ |
| 595 | zMod = pTab->azModuleArg[0]; |
| 596 | pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod)); |
| 597 | |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 598 | if( !pMod ){ |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 599 | const char *zModule = pTab->azModuleArg[0]; |
danielk1977 | a4e7636 | 2006-06-14 06:31:28 +0000 | [diff] [blame] | 600 | sqlite3ErrorMsg(pParse, "no such module: %s", zModule); |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 601 | rc = SQLITE_ERROR; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 602 | }else{ |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 603 | char *zErr = 0; |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 604 | rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr); |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 605 | if( rc!=SQLITE_OK ){ |
| 606 | sqlite3ErrorMsg(pParse, "%s", zErr); |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 607 | } |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 608 | sqlite3DbFree(db, zErr); |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 609 | } |
| 610 | |
| 611 | return rc; |
| 612 | } |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 613 | /* |
dan | 2cac207 | 2011-05-25 18:46:22 +0000 | [diff] [blame] | 614 | ** 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. |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 616 | */ |
dan | 2cac207 | 2011-05-25 18:46:22 +0000 | [diff] [blame] | 617 | static int growVTrans(sqlite3 *db){ |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 618 | const int ARRAY_INCR = 5; |
| 619 | |
| 620 | /* Grow the sqlite3.aVTrans array if required */ |
| 621 | if( (db->nVTrans%ARRAY_INCR)==0 ){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 622 | VTable **aVTrans; |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 623 | int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR); |
danielk1977 | 26783a5 | 2007-08-29 14:06:22 +0000 | [diff] [blame] | 624 | aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes); |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 625 | if( !aVTrans ){ |
| 626 | return SQLITE_NOMEM; |
| 627 | } |
| 628 | memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR); |
| 629 | db->aVTrans = aVTrans; |
| 630 | } |
| 631 | |
dan | 2cac207 | 2011-05-25 18:46:22 +0000 | [diff] [blame] | 632 | 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 | */ |
| 639 | static void addToVTrans(sqlite3 *db, VTable *pVTab){ |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 640 | /* Add pVtab to the end of sqlite3.aVTrans */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 641 | db->aVTrans[db->nVTrans++] = pVTab; |
| 642 | sqlite3VtabLock(pVTab); |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 643 | } |
| 644 | |
| 645 | /* |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 646 | ** 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. |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 651 | ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr. |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 652 | */ |
| 653 | int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){ |
| 654 | int rc = SQLITE_OK; |
| 655 | Table *pTab; |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 656 | Module *pMod; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 657 | const char *zMod; |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 658 | |
| 659 | pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 660 | 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)); |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 665 | |
| 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 | */ |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 670 | if( !pMod ){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 671 | *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod); |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 672 | rc = SQLITE_ERROR; |
| 673 | }else{ |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 674 | rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr); |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 675 | } |
| 676 | |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 677 | /* Justification of ALWAYS(): The xConstructor method is required to |
| 678 | ** create a valid sqlite3_vtab if it returns SQLITE_OK. */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 679 | if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){ |
dan | 2cac207 | 2011-05-25 18:46:22 +0000 | [diff] [blame] | 680 | rc = growVTrans(db); |
| 681 | if( rc==SQLITE_OK ){ |
| 682 | addToVTrans(db, sqlite3GetVTable(db, pTab)); |
| 683 | } |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 684 | } |
| 685 | |
danielk1977 | 9da9d47 | 2006-06-14 06:58:15 +0000 | [diff] [blame] | 686 | return rc; |
| 687 | } |
danielk1977 | be8a783 | 2006-06-13 15:00:54 +0000 | [diff] [blame] | 688 | |
| 689 | /* |
danielk1977 | fe3fcbe2 | 2006-06-12 12:08:45 +0000 | [diff] [blame] | 690 | ** 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 | */ |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 694 | int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 695 | Parse *pParse; |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 696 | |
| 697 | int rc = SQLITE_OK; |
drh | 2764170 | 2007-08-22 02:56:42 +0000 | [diff] [blame] | 698 | Table *pTab; |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 699 | char *zErr = 0; |
| 700 | |
drh | 2764170 | 2007-08-22 02:56:42 +0000 | [diff] [blame] | 701 | sqlite3_mutex_enter(db->mutex); |
dan | d9495cd | 2011-04-27 12:08:04 +0000 | [diff] [blame] | 702 | if( !db->pVtabCtx || !(pTab = db->pVtabCtx->pTab) ){ |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 703 | sqlite3Error(db, SQLITE_MISUSE, 0); |
drh | 2764170 | 2007-08-22 02:56:42 +0000 | [diff] [blame] | 704 | sqlite3_mutex_leave(db->mutex); |
drh | 413c3d3 | 2010-02-23 20:11:56 +0000 | [diff] [blame] | 705 | return SQLITE_MISUSE_BKPT; |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 706 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 707 | assert( (pTab->tabFlags & TF_Virtual)!=0 ); |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 708 | |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 709 | pParse = sqlite3StackAllocZero(db, sizeof(*pParse)); |
| 710 | if( pParse==0 ){ |
| 711 | rc = SQLITE_NOMEM; |
| 712 | }else{ |
| 713 | pParse->declareVtab = 1; |
| 714 | pParse->db = db; |
drh | 8b307fb | 2010-04-06 15:57:05 +0000 | [diff] [blame] | 715 | pParse->nQueryLoop = 1; |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 716 | |
dan | 84db21e | 2009-12-08 19:05:53 +0000 | [diff] [blame] | 717 | if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr) |
dan | 84db21e | 2009-12-08 19:05:53 +0000 | [diff] [blame] | 718 | && pParse->pNewTable |
drh | 0e3c512 | 2009-12-08 22:16:15 +0000 | [diff] [blame] | 719 | && !db->mallocFailed |
dan | 84db21e | 2009-12-08 19:05:53 +0000 | [diff] [blame] | 720 | && !pParse->pNewTable->pSelect |
| 721 | && (pParse->pNewTable->tabFlags & TF_Virtual)==0 |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 722 | ){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 723 | 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 | } |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 729 | db->pVtabCtx->pTab = 0; |
dan | 84db21e | 2009-12-08 19:05:53 +0000 | [diff] [blame] | 730 | }else{ |
dan | 06b5db0 | 2010-10-21 15:12:44 +0000 | [diff] [blame] | 731 | sqlite3Error(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr); |
dan | 78f9b73 | 2010-08-11 11:59:37 +0000 | [diff] [blame] | 732 | sqlite3DbFree(db, zErr); |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 733 | rc = SQLITE_ERROR; |
| 734 | } |
| 735 | pParse->declareVtab = 0; |
| 736 | |
| 737 | if( pParse->pVdbe ){ |
| 738 | sqlite3VdbeFinalize(pParse->pVdbe); |
| 739 | } |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 740 | sqlite3DeleteTable(db, pParse->pNewTable); |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 741 | sqlite3StackFree(db, pParse); |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 742 | } |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 743 | |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 744 | assert( (rc&0xff)==rc ); |
drh | 2764170 | 2007-08-22 02:56:42 +0000 | [diff] [blame] | 745 | rc = sqlite3ApiExit(db, rc); |
| 746 | sqlite3_mutex_leave(db->mutex); |
| 747 | return rc; |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 748 | } |
| 749 | |
| 750 | /* |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 751 | ** 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 | */ |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 757 | int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){ |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 758 | int rc = SQLITE_OK; |
| 759 | Table *pTab; |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 760 | |
| 761 | pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 762 | if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){ |
| 763 | VTable *p = vtabDisconnectAll(db, pTab); |
| 764 | |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 765 | assert( rc==SQLITE_OK ); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 766 | rc = p->pMod->pModule->xDestroy(p->pVtab); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 767 | |
| 768 | /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */ |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 769 | if( rc==SQLITE_OK ){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 770 | assert( pTab->pVTable==p && p->pNext==0 ); |
| 771 | p->pVtab = 0; |
| 772 | pTab->pVTable = 0; |
| 773 | sqlite3VtabUnlock(p); |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 774 | } |
| 775 | } |
| 776 | |
| 777 | return rc; |
| 778 | } |
| 779 | |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 780 | /* |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 781 | ** 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 | */ |
drh | 7209c69 | 2008-04-27 18:40:11 +0000 | [diff] [blame] | 788 | static void callFinaliser(sqlite3 *db, int offset){ |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 789 | int i; |
danielk1977 | 0b83fa8 | 2007-04-19 14:48:37 +0000 | [diff] [blame] | 790 | if( db->aVTrans ){ |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 791 | for(i=0; i<db->nVTrans; i++){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 792 | 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 | } |
drh | 346506f | 2011-05-25 01:16:42 +0000 | [diff] [blame] | 799 | pVTab->iSavepoint = 0; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 800 | sqlite3VtabUnlock(pVTab); |
danielk1977 | 0b83fa8 | 2007-04-19 14:48:37 +0000 | [diff] [blame] | 801 | } |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 802 | sqlite3DbFree(db, db->aVTrans); |
danielk1977 | 0b83fa8 | 2007-04-19 14:48:37 +0000 | [diff] [blame] | 803 | db->nVTrans = 0; |
| 804 | db->aVTrans = 0; |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 805 | } |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 806 | } |
| 807 | |
| 808 | /* |
danielk1977 | 3e3a84d | 2008-08-01 17:37:40 +0000 | [diff] [blame] | 809 | ** 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 | ** |
dan | 016f781 | 2013-08-21 17:35:48 +0000 | [diff] [blame^] | 813 | ** If an error message is available, leave it in p->zErrMsg. |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 814 | */ |
dan | 016f781 | 2013-08-21 17:35:48 +0000 | [diff] [blame^] | 815 | int sqlite3VtabSync(sqlite3 *db, Vdbe *p){ |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 816 | int i; |
| 817 | int rc = SQLITE_OK; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 818 | VTable **aVTrans = db->aVTrans; |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 819 | |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 820 | db->aVTrans = 0; |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 821 | for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){ |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 822 | int (*x)(sqlite3_vtab *); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 823 | sqlite3_vtab *pVtab = aVTrans[i]->pVtab; |
| 824 | if( pVtab && (x = pVtab->pModule->xSync)!=0 ){ |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 825 | rc = x(pVtab); |
dan | 016f781 | 2013-08-21 17:35:48 +0000 | [diff] [blame^] | 826 | sqlite3VtabImportErrmsg(p, pVtab); |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 827 | } |
| 828 | } |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 829 | db->aVTrans = aVTrans; |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 830 | return rc; |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 831 | } |
| 832 | |
| 833 | /* |
| 834 | ** Invoke the xRollback method of all virtual tables in the |
| 835 | ** sqlite3.aVTrans array. Then clear the array itself. |
| 836 | */ |
| 837 | int sqlite3VtabRollback(sqlite3 *db){ |
drh | 7209c69 | 2008-04-27 18:40:11 +0000 | [diff] [blame] | 838 | callFinaliser(db, offsetof(sqlite3_module,xRollback)); |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 839 | return SQLITE_OK; |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 840 | } |
| 841 | |
| 842 | /* |
| 843 | ** Invoke the xCommit method of all virtual tables in the |
| 844 | ** sqlite3.aVTrans array. Then clear the array itself. |
| 845 | */ |
| 846 | int sqlite3VtabCommit(sqlite3 *db){ |
drh | 7209c69 | 2008-04-27 18:40:11 +0000 | [diff] [blame] | 847 | callFinaliser(db, offsetof(sqlite3_module,xCommit)); |
danielk1977 | e7ff403 | 2006-06-17 11:30:32 +0000 | [diff] [blame] | 848 | return SQLITE_OK; |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 849 | } |
| 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 | */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 859 | int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){ |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 860 | int rc = SQLITE_OK; |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 861 | 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 |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 866 | ** virtual module tables in this case, so return SQLITE_LOCKED. |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 867 | */ |
danielk1977 | 093e0f6 | 2008-11-13 18:00:14 +0000 | [diff] [blame] | 868 | if( sqlite3VtabInSync(db) ){ |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 869 | return SQLITE_LOCKED; |
| 870 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 871 | if( !pVTab ){ |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 872 | return SQLITE_OK; |
| 873 | } |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 874 | pModule = pVTab->pVtab->pModule; |
danielk1977 | 20b1eaf | 2006-07-26 16:22:14 +0000 | [diff] [blame] | 875 | |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 876 | if( pModule->xBegin ){ |
| 877 | int i; |
| 878 | |
| 879 | /* If pVtab is already in the aVTrans array, return early */ |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 880 | for(i=0; i<db->nVTrans; i++){ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 881 | if( db->aVTrans[i]==pVTab ){ |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 882 | return SQLITE_OK; |
| 883 | } |
| 884 | } |
| 885 | |
dan | 2cac207 | 2011-05-25 18:46:22 +0000 | [diff] [blame] | 886 | /* Invoke the xBegin method. If successful, add the vtab to the |
| 887 | ** sqlite3.aVTrans[] array. */ |
| 888 | rc = growVTrans(db); |
danielk1977 | 3e3a84d | 2008-08-01 17:37:40 +0000 | [diff] [blame] | 889 | if( rc==SQLITE_OK ){ |
dan | 2cac207 | 2011-05-25 18:46:22 +0000 | [diff] [blame] | 890 | rc = pModule->xBegin(pVTab->pVtab); |
| 891 | if( rc==SQLITE_OK ){ |
| 892 | addToVTrans(db, pVTab); |
| 893 | } |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 894 | } |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 895 | } |
| 896 | return rc; |
| 897 | } |
| 898 | |
dan | d9495cd | 2011-04-27 12:08:04 +0000 | [diff] [blame] | 899 | /* |
| 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 | */ |
dan | a311b80 | 2011-04-26 19:21:34 +0000 | [diff] [blame] | 914 | int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){ |
dan | a311b80 | 2011-04-26 19:21:34 +0000 | [diff] [blame] | 915 | int rc = SQLITE_OK; |
| 916 | |
| 917 | assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN ); |
drh | 346506f | 2011-05-25 01:16:42 +0000 | [diff] [blame] | 918 | assert( iSavepoint>=0 ); |
dan | d9495cd | 2011-04-27 12:08:04 +0000 | [diff] [blame] | 919 | if( db->aVTrans ){ |
| 920 | int i; |
| 921 | for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){ |
drh | e485522 | 2011-05-24 15:36:01 +0000 | [diff] [blame] | 922 | VTable *pVTab = db->aVTrans[i]; |
| 923 | const sqlite3_module *pMod = pVTab->pMod->pModule; |
dan | 341cade | 2011-10-29 11:43:04 +0000 | [diff] [blame] | 924 | if( pVTab->pVtab && pMod->iVersion>=2 ){ |
dan | d9495cd | 2011-04-27 12:08:04 +0000 | [diff] [blame] | 925 | int (*xMethod)(sqlite3_vtab *, int); |
| 926 | switch( op ){ |
| 927 | case SAVEPOINT_BEGIN: |
| 928 | xMethod = pMod->xSavepoint; |
drh | 346506f | 2011-05-25 01:16:42 +0000 | [diff] [blame] | 929 | pVTab->iSavepoint = iSavepoint+1; |
dan | d9495cd | 2011-04-27 12:08:04 +0000 | [diff] [blame] | 930 | break; |
| 931 | case SAVEPOINT_ROLLBACK: |
| 932 | xMethod = pMod->xRollbackTo; |
| 933 | break; |
| 934 | default: |
| 935 | xMethod = pMod->xRelease; |
| 936 | break; |
| 937 | } |
drh | 346506f | 2011-05-25 01:16:42 +0000 | [diff] [blame] | 938 | if( xMethod && pVTab->iSavepoint>iSavepoint ){ |
dan | 341cade | 2011-10-29 11:43:04 +0000 | [diff] [blame] | 939 | rc = xMethod(pVTab->pVtab, iSavepoint); |
drh | 346506f | 2011-05-25 01:16:42 +0000 | [diff] [blame] | 940 | } |
dan | a311b80 | 2011-04-26 19:21:34 +0000 | [diff] [blame] | 941 | } |
| 942 | } |
| 943 | } |
| 944 | return rc; |
| 945 | } |
| 946 | |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 947 | /* |
| 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 | */ |
| 960 | FuncDef *sqlite3VtabOverloadFunction( |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 961 | sqlite3 *db, /* Database connection for reporting malloc problems */ |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 962 | 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; |
drh | dc5ea5c | 2008-12-10 17:19:59 +0000 | [diff] [blame] | 969 | void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0; |
| 970 | void *pArg = 0; |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 971 | FuncDef *pNew; |
drh | 777b17a | 2007-09-20 10:02:54 +0000 | [diff] [blame] | 972 | int rc = 0; |
drh | a70034d | 2006-09-18 20:24:02 +0000 | [diff] [blame] | 973 | char *zLowerName; |
| 974 | unsigned char *z; |
| 975 | |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 976 | |
| 977 | /* Check to see the left operand is a column in a virtual table */ |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 978 | if( NEVER(pExpr==0) ) return pDef; |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 979 | if( pExpr->op!=TK_COLUMN ) return pDef; |
| 980 | pTab = pExpr->pTab; |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 981 | if( NEVER(pTab==0) ) return pDef; |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 982 | if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 983 | pVtab = sqlite3GetVTable(db, pTab)->pVtab; |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 984 | assert( pVtab!=0 ); |
| 985 | assert( pVtab->pModule!=0 ); |
danielk1977 | 5bd270b | 2006-07-25 15:14:52 +0000 | [diff] [blame] | 986 | pMod = (sqlite3_module *)pVtab->pModule; |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 987 | if( pMod->xFindFunction==0 ) return pDef; |
| 988 | |
rse | b72e88d | 2007-09-20 11:32:18 +0000 | [diff] [blame] | 989 | /* Call the xFindFunction method on the virtual table implementation |
drh | a70034d | 2006-09-18 20:24:02 +0000 | [diff] [blame] | 990 | ** to see if the implementation wants to overload this function |
| 991 | */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 992 | 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); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 998 | sqlite3DbFree(db, zLowerName); |
drh | a70034d | 2006-09-18 20:24:02 +0000 | [diff] [blame] | 999 | } |
drh | a70034d | 2006-09-18 20:24:02 +0000 | [diff] [blame] | 1000 | if( rc==0 ){ |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 1001 | return pDef; |
| 1002 | } |
| 1003 | |
| 1004 | /* Create a new ephemeral function definition for the overloaded |
| 1005 | ** function */ |
drh | ea67883 | 2008-12-10 19:26:22 +0000 | [diff] [blame] | 1006 | pNew = sqlite3DbMallocZero(db, sizeof(*pNew) |
danielk1977 | e25a50b | 2009-07-01 18:04:20 +0000 | [diff] [blame] | 1007 | + sqlite3Strlen30(pDef->zName) + 1); |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 1008 | if( pNew==0 ){ |
| 1009 | return pDef; |
| 1010 | } |
| 1011 | *pNew = *pDef; |
danielk1977 | 8c0a791 | 2008-08-20 14:49:23 +0000 | [diff] [blame] | 1012 | pNew->zName = (char *)&pNew[1]; |
drh | ea67883 | 2008-12-10 19:26:22 +0000 | [diff] [blame] | 1013 | memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1); |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 1014 | pNew->xFunc = xFunc; |
| 1015 | pNew->pUserData = pArg; |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 1016 | pNew->flags |= SQLITE_FUNC_EPHEM; |
| 1017 | return pNew; |
| 1018 | } |
| 1019 | |
drh | 4f3dd15 | 2008-04-28 18:46:43 +0000 | [diff] [blame] | 1020 | /* |
| 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 | */ |
| 1026 | void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 1027 | Parse *pToplevel = sqlite3ParseToplevel(pParse); |
drh | 4f3dd15 | 2008-04-28 18:46:43 +0000 | [diff] [blame] | 1028 | int i, n; |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 1029 | Table **apVtabLock; |
| 1030 | |
drh | 4f3dd15 | 2008-04-28 18:46:43 +0000 | [diff] [blame] | 1031 | assert( IsVirtual(pTab) ); |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 1032 | for(i=0; i<pToplevel->nVtabLock; i++){ |
| 1033 | if( pTab==pToplevel->apVtabLock[i] ) return; |
drh | 4f3dd15 | 2008-04-28 18:46:43 +0000 | [diff] [blame] | 1034 | } |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 1035 | n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]); |
| 1036 | apVtabLock = sqlite3_realloc(pToplevel->apVtabLock, n); |
drh | 748ce21 | 2009-05-20 20:10:47 +0000 | [diff] [blame] | 1037 | if( apVtabLock ){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 1038 | pToplevel->apVtabLock = apVtabLock; |
| 1039 | pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab; |
drh | 344c38e | 2008-05-05 13:23:04 +0000 | [diff] [blame] | 1040 | }else{ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 1041 | pToplevel->db->mallocFailed = 1; |
drh | 4f3dd15 | 2008-04-28 18:46:43 +0000 | [diff] [blame] | 1042 | } |
| 1043 | } |
| 1044 | |
drh | ef45bb7 | 2011-05-05 15:39:50 +0000 | [diff] [blame] | 1045 | /* |
| 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 | */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 1052 | int sqlite3_vtab_on_conflict(sqlite3 *db){ |
drh | ef45bb7 | 2011-05-05 15:39:50 +0000 | [diff] [blame] | 1053 | static const unsigned char aMap[] = { |
drh | 87f67bf | 2011-05-05 17:41:58 +0000 | [diff] [blame] | 1054 | SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 1055 | }; |
| 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 ); |
drh | ef45bb7 | 2011-05-05 15:39:50 +0000 | [diff] [blame] | 1059 | return (int)aMap[db->vtabOnConflict-1]; |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 1060 | } |
| 1061 | |
drh | ef45bb7 | 2011-05-05 15:39:50 +0000 | [diff] [blame] | 1062 | /* |
| 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 | */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 1067 | int 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{ |
drh | 367e84d | 2011-05-05 23:07:43 +0000 | [diff] [blame] | 1080 | assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 ); |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 1081 | 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 | |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 1096 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |