1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite/vtab.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,838 @@
1.4 +/*
1.5 +** 2006 June 10
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file contains code used to help implement virtual tables.
1.16 +**
1.17 +** $Id: vtab.c,v 1.74 2008/08/02 03:50:39 drh Exp $
1.18 +*/
1.19 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.20 +#include "sqliteInt.h"
1.21 +
1.22 +static int createModule(
1.23 + sqlite3 *db, /* Database in which module is registered */
1.24 + const char *zName, /* Name assigned to this module */
1.25 + const sqlite3_module *pModule, /* The definition of the module */
1.26 + void *pAux, /* Context pointer for xCreate/xConnect */
1.27 + void (*xDestroy)(void *) /* Module destructor function */
1.28 +) {
1.29 + int rc, nName;
1.30 + Module *pMod;
1.31 +
1.32 + sqlite3_mutex_enter(db->mutex);
1.33 + nName = strlen(zName);
1.34 + pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
1.35 + if( pMod ){
1.36 + Module *pDel;
1.37 + char *zCopy = (char *)(&pMod[1]);
1.38 + memcpy(zCopy, zName, nName+1);
1.39 + pMod->zName = zCopy;
1.40 + pMod->pModule = pModule;
1.41 + pMod->pAux = pAux;
1.42 + pMod->xDestroy = xDestroy;
1.43 + pDel = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);
1.44 + if( pDel && pDel->xDestroy ){
1.45 + pDel->xDestroy(pDel->pAux);
1.46 + }
1.47 + sqlite3DbFree(db, pDel);
1.48 + if( pDel==pMod ){
1.49 + db->mallocFailed = 1;
1.50 + }
1.51 + sqlite3ResetInternalSchema(db, 0);
1.52 + }
1.53 + rc = sqlite3ApiExit(db, SQLITE_OK);
1.54 + sqlite3_mutex_leave(db->mutex);
1.55 + return rc;
1.56 +}
1.57 +
1.58 +
1.59 +/*
1.60 +** External API function used to create a new virtual-table module.
1.61 +*/
1.62 +int sqlite3_create_module(
1.63 + sqlite3 *db, /* Database in which module is registered */
1.64 + const char *zName, /* Name assigned to this module */
1.65 + const sqlite3_module *pModule, /* The definition of the module */
1.66 + void *pAux /* Context pointer for xCreate/xConnect */
1.67 +){
1.68 + return createModule(db, zName, pModule, pAux, 0);
1.69 +}
1.70 +
1.71 +/*
1.72 +** External API function used to create a new virtual-table module.
1.73 +*/
1.74 +int sqlite3_create_module_v2(
1.75 + sqlite3 *db, /* Database in which module is registered */
1.76 + const char *zName, /* Name assigned to this module */
1.77 + const sqlite3_module *pModule, /* The definition of the module */
1.78 + void *pAux, /* Context pointer for xCreate/xConnect */
1.79 + void (*xDestroy)(void *) /* Module destructor function */
1.80 +){
1.81 + return createModule(db, zName, pModule, pAux, xDestroy);
1.82 +}
1.83 +
1.84 +/*
1.85 +** Lock the virtual table so that it cannot be disconnected.
1.86 +** Locks nest. Every lock should have a corresponding unlock.
1.87 +** If an unlock is omitted, resources leaks will occur.
1.88 +**
1.89 +** If a disconnect is attempted while a virtual table is locked,
1.90 +** the disconnect is deferred until all locks have been removed.
1.91 +*/
1.92 +void sqlite3VtabLock(sqlite3_vtab *pVtab){
1.93 + pVtab->nRef++;
1.94 +}
1.95 +
1.96 +/*
1.97 +** Unlock a virtual table. When the last lock is removed,
1.98 +** disconnect the virtual table.
1.99 +*/
1.100 +void sqlite3VtabUnlock(sqlite3 *db, sqlite3_vtab *pVtab){
1.101 + pVtab->nRef--;
1.102 + assert(db);
1.103 + assert( sqlite3SafetyCheckOk(db) );
1.104 + if( pVtab->nRef==0 ){
1.105 + if( db->magic==SQLITE_MAGIC_BUSY ){
1.106 + (void)sqlite3SafetyOff(db);
1.107 + pVtab->pModule->xDisconnect(pVtab);
1.108 + (void)sqlite3SafetyOn(db);
1.109 + } else {
1.110 + pVtab->pModule->xDisconnect(pVtab);
1.111 + }
1.112 + }
1.113 +}
1.114 +
1.115 +/*
1.116 +** Clear any and all virtual-table information from the Table record.
1.117 +** This routine is called, for example, just before deleting the Table
1.118 +** record.
1.119 +*/
1.120 +void sqlite3VtabClear(Table *p){
1.121 + sqlite3_vtab *pVtab = p->pVtab;
1.122 + sqlite3 *db = p->db;
1.123 + if( pVtab ){
1.124 + assert( p->pMod && p->pMod->pModule );
1.125 + sqlite3VtabUnlock(db, pVtab);
1.126 + p->pVtab = 0;
1.127 + }
1.128 + if( p->azModuleArg ){
1.129 + int i;
1.130 + for(i=0; i<p->nModuleArg; i++){
1.131 + sqlite3DbFree(db, p->azModuleArg[i]);
1.132 + }
1.133 + sqlite3DbFree(db, p->azModuleArg);
1.134 + }
1.135 +}
1.136 +
1.137 +/*
1.138 +** Add a new module argument to pTable->azModuleArg[].
1.139 +** The string is not copied - the pointer is stored. The
1.140 +** string will be freed automatically when the table is
1.141 +** deleted.
1.142 +*/
1.143 +static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
1.144 + int i = pTable->nModuleArg++;
1.145 + int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
1.146 + char **azModuleArg;
1.147 + azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
1.148 + if( azModuleArg==0 ){
1.149 + int j;
1.150 + for(j=0; j<i; j++){
1.151 + sqlite3DbFree(db, pTable->azModuleArg[j]);
1.152 + }
1.153 + sqlite3DbFree(db, zArg);
1.154 + sqlite3DbFree(db, pTable->azModuleArg);
1.155 + pTable->nModuleArg = 0;
1.156 + }else{
1.157 + azModuleArg[i] = zArg;
1.158 + azModuleArg[i+1] = 0;
1.159 + }
1.160 + pTable->azModuleArg = azModuleArg;
1.161 +}
1.162 +
1.163 +/*
1.164 +** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
1.165 +** statement. The module name has been parsed, but the optional list
1.166 +** of parameters that follow the module name are still pending.
1.167 +*/
1.168 +void sqlite3VtabBeginParse(
1.169 + Parse *pParse, /* Parsing context */
1.170 + Token *pName1, /* Name of new table, or database name */
1.171 + Token *pName2, /* Name of new table or NULL */
1.172 + Token *pModuleName /* Name of the module for the virtual table */
1.173 +){
1.174 + int iDb; /* The database the table is being created in */
1.175 + Table *pTable; /* The new virtual table */
1.176 + sqlite3 *db; /* Database connection */
1.177 +
1.178 + if( pParse->db->flags & SQLITE_SharedCache ){
1.179 + sqlite3ErrorMsg(pParse, "Cannot use virtual tables in shared-cache mode");
1.180 + return;
1.181 + }
1.182 +
1.183 + sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, 0);
1.184 + pTable = pParse->pNewTable;
1.185 + if( pTable==0 || pParse->nErr ) return;
1.186 + assert( 0==pTable->pIndex );
1.187 +
1.188 + db = pParse->db;
1.189 + iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
1.190 + assert( iDb>=0 );
1.191 +
1.192 + pTable->isVirtual = 1;
1.193 + pTable->nModuleArg = 0;
1.194 + addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
1.195 + addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
1.196 + addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
1.197 + pParse->sNameToken.n = pModuleName->z + pModuleName->n - pName1->z;
1.198 +
1.199 +#ifndef SQLITE_OMIT_AUTHORIZATION
1.200 + /* Creating a virtual table invokes the authorization callback twice.
1.201 + ** The first invocation, to obtain permission to INSERT a row into the
1.202 + ** sqlite_master table, has already been made by sqlite3StartTable().
1.203 + ** The second call, to obtain permission to create the table, is made now.
1.204 + */
1.205 + if( pTable->azModuleArg ){
1.206 + sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
1.207 + pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
1.208 + }
1.209 +#endif
1.210 +}
1.211 +
1.212 +/*
1.213 +** This routine takes the module argument that has been accumulating
1.214 +** in pParse->zArg[] and appends it to the list of arguments on the
1.215 +** virtual table currently under construction in pParse->pTable.
1.216 +*/
1.217 +static void addArgumentToVtab(Parse *pParse){
1.218 + if( pParse->sArg.z && pParse->pNewTable ){
1.219 + const char *z = (const char*)pParse->sArg.z;
1.220 + int n = pParse->sArg.n;
1.221 + sqlite3 *db = pParse->db;
1.222 + addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
1.223 + }
1.224 +}
1.225 +
1.226 +/*
1.227 +** The parser calls this routine after the CREATE VIRTUAL TABLE statement
1.228 +** has been completely parsed.
1.229 +*/
1.230 +void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
1.231 + Table *pTab; /* The table being constructed */
1.232 + sqlite3 *db; /* The database connection */
1.233 + char *zModule; /* The module name of the table: USING modulename */
1.234 + Module *pMod = 0;
1.235 +
1.236 + addArgumentToVtab(pParse);
1.237 + pParse->sArg.z = 0;
1.238 +
1.239 + /* Lookup the module name. */
1.240 + pTab = pParse->pNewTable;
1.241 + if( pTab==0 ) return;
1.242 + db = pParse->db;
1.243 + if( pTab->nModuleArg<1 ) return;
1.244 + zModule = pTab->azModuleArg[0];
1.245 + pMod = (Module *)sqlite3HashFind(&db->aModule, zModule, strlen(zModule));
1.246 + pTab->pMod = pMod;
1.247 +
1.248 + /* If the CREATE VIRTUAL TABLE statement is being entered for the
1.249 + ** first time (in other words if the virtual table is actually being
1.250 + ** created now instead of just being read out of sqlite_master) then
1.251 + ** do additional initialization work and store the statement text
1.252 + ** in the sqlite_master table.
1.253 + */
1.254 + if( !db->init.busy ){
1.255 + char *zStmt;
1.256 + char *zWhere;
1.257 + int iDb;
1.258 + Vdbe *v;
1.259 +
1.260 + /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
1.261 + if( pEnd ){
1.262 + pParse->sNameToken.n = pEnd->z - pParse->sNameToken.z + pEnd->n;
1.263 + }
1.264 + zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
1.265 +
1.266 + /* A slot for the record has already been allocated in the
1.267 + ** SQLITE_MASTER table. We just need to update that slot with all
1.268 + ** the information we've collected.
1.269 + **
1.270 + ** The VM register number pParse->regRowid holds the rowid of an
1.271 + ** entry in the sqlite_master table tht was created for this vtab
1.272 + ** by sqlite3StartTable().
1.273 + */
1.274 + iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1.275 + sqlite3NestedParse(pParse,
1.276 + "UPDATE %Q.%s "
1.277 + "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
1.278 + "WHERE rowid=#%d",
1.279 + db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
1.280 + pTab->zName,
1.281 + pTab->zName,
1.282 + zStmt,
1.283 + pParse->regRowid
1.284 + );
1.285 + sqlite3DbFree(db, zStmt);
1.286 + v = sqlite3GetVdbe(pParse);
1.287 + sqlite3ChangeCookie(pParse, iDb);
1.288 +
1.289 + sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
1.290 + zWhere = sqlite3MPrintf(db, "name='%q'", pTab->zName);
1.291 + sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 1, 0, zWhere, P4_DYNAMIC);
1.292 + sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0,
1.293 + pTab->zName, strlen(pTab->zName) + 1);
1.294 + }
1.295 +
1.296 + /* If we are rereading the sqlite_master table create the in-memory
1.297 + ** record of the table. If the module has already been registered,
1.298 + ** also call the xConnect method here.
1.299 + */
1.300 + else {
1.301 + Table *pOld;
1.302 + Schema *pSchema = pTab->pSchema;
1.303 + const char *zName = pTab->zName;
1.304 + int nName = strlen(zName) + 1;
1.305 + pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
1.306 + if( pOld ){
1.307 + db->mallocFailed = 1;
1.308 + assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
1.309 + return;
1.310 + }
1.311 + pSchema->db = pParse->db;
1.312 + pParse->pNewTable = 0;
1.313 + }
1.314 +}
1.315 +
1.316 +/*
1.317 +** The parser calls this routine when it sees the first token
1.318 +** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
1.319 +*/
1.320 +void sqlite3VtabArgInit(Parse *pParse){
1.321 + addArgumentToVtab(pParse);
1.322 + pParse->sArg.z = 0;
1.323 + pParse->sArg.n = 0;
1.324 +}
1.325 +
1.326 +/*
1.327 +** The parser calls this routine for each token after the first token
1.328 +** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
1.329 +*/
1.330 +void sqlite3VtabArgExtend(Parse *pParse, Token *p){
1.331 + Token *pArg = &pParse->sArg;
1.332 + if( pArg->z==0 ){
1.333 + pArg->z = p->z;
1.334 + pArg->n = p->n;
1.335 + }else{
1.336 + assert(pArg->z < p->z);
1.337 + pArg->n = (p->z + p->n - pArg->z);
1.338 + }
1.339 +}
1.340 +
1.341 +/*
1.342 +** Invoke a virtual table constructor (either xCreate or xConnect). The
1.343 +** pointer to the function to invoke is passed as the fourth parameter
1.344 +** to this procedure.
1.345 +*/
1.346 +static int vtabCallConstructor(
1.347 + sqlite3 *db,
1.348 + Table *pTab,
1.349 + Module *pMod,
1.350 + int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
1.351 + char **pzErr
1.352 +){
1.353 + int rc;
1.354 + int rc2;
1.355 + sqlite3_vtab *pVtab = 0;
1.356 + const char *const*azArg = (const char *const*)pTab->azModuleArg;
1.357 + int nArg = pTab->nModuleArg;
1.358 + char *zErr = 0;
1.359 + char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
1.360 +
1.361 + if( !zModuleName ){
1.362 + return SQLITE_NOMEM;
1.363 + }
1.364 +
1.365 + assert( !db->pVTab );
1.366 + assert( xConstruct );
1.367 +
1.368 + db->pVTab = pTab;
1.369 + rc = sqlite3SafetyOff(db);
1.370 + assert( rc==SQLITE_OK );
1.371 + rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVtab, &zErr);
1.372 + rc2 = sqlite3SafetyOn(db);
1.373 + if( rc==SQLITE_OK && pVtab ){
1.374 + pVtab->pModule = pMod->pModule;
1.375 + pVtab->nRef = 1;
1.376 + pTab->pVtab = pVtab;
1.377 + }
1.378 +
1.379 + if( SQLITE_OK!=rc ){
1.380 + if( zErr==0 ){
1.381 + *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
1.382 + }else {
1.383 + *pzErr = sqlite3MPrintf(db, "%s", zErr);
1.384 + sqlite3DbFree(db, zErr);
1.385 + }
1.386 + }else if( db->pVTab ){
1.387 + const char *zFormat = "vtable constructor did not declare schema: %s";
1.388 + *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
1.389 + rc = SQLITE_ERROR;
1.390 + }
1.391 + if( rc==SQLITE_OK ){
1.392 + rc = rc2;
1.393 + }
1.394 + db->pVTab = 0;
1.395 + sqlite3DbFree(db, zModuleName);
1.396 +
1.397 + /* If everything went according to plan, loop through the columns
1.398 + ** of the table to see if any of them contain the token "hidden".
1.399 + ** If so, set the Column.isHidden flag and remove the token from
1.400 + ** the type string.
1.401 + */
1.402 + if( rc==SQLITE_OK ){
1.403 + int iCol;
1.404 + for(iCol=0; iCol<pTab->nCol; iCol++){
1.405 + char *zType = pTab->aCol[iCol].zType;
1.406 + int nType;
1.407 + int i = 0;
1.408 + if( !zType ) continue;
1.409 + nType = strlen(zType);
1.410 + if( sqlite3StrNICmp("hidden", zType, 6) || (zType[6] && zType[6]!=' ') ){
1.411 + for(i=0; i<nType; i++){
1.412 + if( (0==sqlite3StrNICmp(" hidden", &zType[i], 7))
1.413 + && (zType[i+7]=='\0' || zType[i+7]==' ')
1.414 + ){
1.415 + i++;
1.416 + break;
1.417 + }
1.418 + }
1.419 + }
1.420 + if( i<nType ){
1.421 + int j;
1.422 + int nDel = 6 + (zType[i+6] ? 1 : 0);
1.423 + for(j=i; (j+nDel)<=nType; j++){
1.424 + zType[j] = zType[j+nDel];
1.425 + }
1.426 + if( zType[i]=='\0' && i>0 ){
1.427 + assert(zType[i-1]==' ');
1.428 + zType[i-1] = '\0';
1.429 + }
1.430 + pTab->aCol[iCol].isHidden = 1;
1.431 + }
1.432 + }
1.433 + }
1.434 + return rc;
1.435 +}
1.436 +
1.437 +/*
1.438 +** This function is invoked by the parser to call the xConnect() method
1.439 +** of the virtual table pTab. If an error occurs, an error code is returned
1.440 +** and an error left in pParse.
1.441 +**
1.442 +** This call is a no-op if table pTab is not a virtual table.
1.443 +*/
1.444 +int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
1.445 + Module *pMod;
1.446 + int rc = SQLITE_OK;
1.447 +
1.448 + if( !pTab || !pTab->isVirtual || pTab->pVtab ){
1.449 + return SQLITE_OK;
1.450 + }
1.451 +
1.452 + pMod = pTab->pMod;
1.453 + if( !pMod ){
1.454 + const char *zModule = pTab->azModuleArg[0];
1.455 + sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
1.456 + rc = SQLITE_ERROR;
1.457 + } else {
1.458 + char *zErr = 0;
1.459 + sqlite3 *db = pParse->db;
1.460 + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
1.461 + if( rc!=SQLITE_OK ){
1.462 + sqlite3ErrorMsg(pParse, "%s", zErr);
1.463 + }
1.464 + sqlite3DbFree(db, zErr);
1.465 + }
1.466 +
1.467 + return rc;
1.468 +}
1.469 +
1.470 +/*
1.471 +** Add the virtual table pVtab to the array sqlite3.aVTrans[].
1.472 +*/
1.473 +static int addToVTrans(sqlite3 *db, sqlite3_vtab *pVtab){
1.474 + const int ARRAY_INCR = 5;
1.475 +
1.476 + /* Grow the sqlite3.aVTrans array if required */
1.477 + if( (db->nVTrans%ARRAY_INCR)==0 ){
1.478 + sqlite3_vtab **aVTrans;
1.479 + int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
1.480 + aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
1.481 + if( !aVTrans ){
1.482 + return SQLITE_NOMEM;
1.483 + }
1.484 + memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
1.485 + db->aVTrans = aVTrans;
1.486 + }
1.487 +
1.488 + /* Add pVtab to the end of sqlite3.aVTrans */
1.489 + db->aVTrans[db->nVTrans++] = pVtab;
1.490 + sqlite3VtabLock(pVtab);
1.491 + return SQLITE_OK;
1.492 +}
1.493 +
1.494 +/*
1.495 +** This function is invoked by the vdbe to call the xCreate method
1.496 +** of the virtual table named zTab in database iDb.
1.497 +**
1.498 +** If an error occurs, *pzErr is set to point an an English language
1.499 +** description of the error and an SQLITE_XXX error code is returned.
1.500 +** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
1.501 +*/
1.502 +int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
1.503 + int rc = SQLITE_OK;
1.504 + Table *pTab;
1.505 + Module *pMod;
1.506 + const char *zModule;
1.507 +
1.508 + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
1.509 + assert(pTab && pTab->isVirtual && !pTab->pVtab);
1.510 + pMod = pTab->pMod;
1.511 + zModule = pTab->azModuleArg[0];
1.512 +
1.513 + /* If the module has been registered and includes a Create method,
1.514 + ** invoke it now. If the module has not been registered, return an
1.515 + ** error. Otherwise, do nothing.
1.516 + */
1.517 + if( !pMod ){
1.518 + *pzErr = sqlite3MPrintf(db, "no such module: %s", zModule);
1.519 + rc = SQLITE_ERROR;
1.520 + }else{
1.521 + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
1.522 + }
1.523 +
1.524 + if( rc==SQLITE_OK && pTab->pVtab ){
1.525 + rc = addToVTrans(db, pTab->pVtab);
1.526 + }
1.527 +
1.528 + return rc;
1.529 +}
1.530 +
1.531 +/*
1.532 +** This function is used to set the schema of a virtual table. It is only
1.533 +** valid to call this function from within the xCreate() or xConnect() of a
1.534 +** virtual table module.
1.535 +*/
1.536 +int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
1.537 + Parse sParse;
1.538 +
1.539 + int rc = SQLITE_OK;
1.540 + Table *pTab;
1.541 + char *zErr = 0;
1.542 +
1.543 + sqlite3_mutex_enter(db->mutex);
1.544 + pTab = db->pVTab;
1.545 + if( !pTab ){
1.546 + sqlite3Error(db, SQLITE_MISUSE, 0);
1.547 + sqlite3_mutex_leave(db->mutex);
1.548 + return SQLITE_MISUSE;
1.549 + }
1.550 + assert(pTab->isVirtual && pTab->nCol==0 && pTab->aCol==0);
1.551 +
1.552 + memset(&sParse, 0, sizeof(Parse));
1.553 + sParse.declareVtab = 1;
1.554 + sParse.db = db;
1.555 +
1.556 + if(
1.557 + SQLITE_OK == sqlite3RunParser(&sParse, zCreateTable, &zErr) &&
1.558 + sParse.pNewTable &&
1.559 + !sParse.pNewTable->pSelect &&
1.560 + !sParse.pNewTable->isVirtual
1.561 + ){
1.562 + pTab->aCol = sParse.pNewTable->aCol;
1.563 + pTab->nCol = sParse.pNewTable->nCol;
1.564 + sParse.pNewTable->nCol = 0;
1.565 + sParse.pNewTable->aCol = 0;
1.566 + db->pVTab = 0;
1.567 + } else {
1.568 + sqlite3Error(db, SQLITE_ERROR, zErr);
1.569 + sqlite3DbFree(db, zErr);
1.570 + rc = SQLITE_ERROR;
1.571 + }
1.572 + sParse.declareVtab = 0;
1.573 +
1.574 + sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
1.575 + sqlite3DeleteTable(sParse.pNewTable);
1.576 + sParse.pNewTable = 0;
1.577 +
1.578 + assert( (rc&0xff)==rc );
1.579 + rc = sqlite3ApiExit(db, rc);
1.580 + sqlite3_mutex_leave(db->mutex);
1.581 + return rc;
1.582 +}
1.583 +
1.584 +/*
1.585 +** This function is invoked by the vdbe to call the xDestroy method
1.586 +** of the virtual table named zTab in database iDb. This occurs
1.587 +** when a DROP TABLE is mentioned.
1.588 +**
1.589 +** This call is a no-op if zTab is not a virtual table.
1.590 +*/
1.591 +int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab)
1.592 +{
1.593 + int rc = SQLITE_OK;
1.594 + Table *pTab;
1.595 +
1.596 + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
1.597 + assert(pTab);
1.598 + if( pTab->pVtab ){
1.599 + int (*xDestroy)(sqlite3_vtab *pVTab) = pTab->pMod->pModule->xDestroy;
1.600 + rc = sqlite3SafetyOff(db);
1.601 + assert( rc==SQLITE_OK );
1.602 + if( xDestroy ){
1.603 + rc = xDestroy(pTab->pVtab);
1.604 + }
1.605 + (void)sqlite3SafetyOn(db);
1.606 + if( rc==SQLITE_OK ){
1.607 + int i;
1.608 + for(i=0; i<db->nVTrans; i++){
1.609 + if( db->aVTrans[i]==pTab->pVtab ){
1.610 + db->aVTrans[i] = db->aVTrans[--db->nVTrans];
1.611 + break;
1.612 + }
1.613 + }
1.614 + pTab->pVtab = 0;
1.615 + }
1.616 + }
1.617 +
1.618 + return rc;
1.619 +}
1.620 +
1.621 +/*
1.622 +** This function invokes either the xRollback or xCommit method
1.623 +** of each of the virtual tables in the sqlite3.aVTrans array. The method
1.624 +** called is identified by the second argument, "offset", which is
1.625 +** the offset of the method to call in the sqlite3_module structure.
1.626 +**
1.627 +** The array is cleared after invoking the callbacks.
1.628 +*/
1.629 +static void callFinaliser(sqlite3 *db, int offset){
1.630 + int i;
1.631 + if( db->aVTrans ){
1.632 + for(i=0; i<db->nVTrans && db->aVTrans[i]; i++){
1.633 + sqlite3_vtab *pVtab = db->aVTrans[i];
1.634 + int (*x)(sqlite3_vtab *);
1.635 + x = *(int (**)(sqlite3_vtab *))((char *)pVtab->pModule + offset);
1.636 + if( x ) x(pVtab);
1.637 + sqlite3VtabUnlock(db, pVtab);
1.638 + }
1.639 + sqlite3DbFree(db, db->aVTrans);
1.640 + db->nVTrans = 0;
1.641 + db->aVTrans = 0;
1.642 + }
1.643 +}
1.644 +
1.645 +/*
1.646 +** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
1.647 +** array. Return the error code for the first error that occurs, or
1.648 +** SQLITE_OK if all xSync operations are successful.
1.649 +**
1.650 +** Set *pzErrmsg to point to a buffer that should be released using
1.651 +** sqlite3DbFree() containing an error message, if one is available.
1.652 +*/
1.653 +int sqlite3VtabSync(sqlite3 *db, char **pzErrmsg){
1.654 + int i;
1.655 + int rc = SQLITE_OK;
1.656 + int rcsafety;
1.657 + sqlite3_vtab **aVTrans = db->aVTrans;
1.658 +
1.659 + rc = sqlite3SafetyOff(db);
1.660 + db->aVTrans = 0;
1.661 + for(i=0; rc==SQLITE_OK && i<db->nVTrans && aVTrans[i]; i++){
1.662 + sqlite3_vtab *pVtab = aVTrans[i];
1.663 + int (*x)(sqlite3_vtab *);
1.664 + x = pVtab->pModule->xSync;
1.665 + if( x ){
1.666 + rc = x(pVtab);
1.667 + sqlite3DbFree(db, *pzErrmsg);
1.668 + *pzErrmsg = pVtab->zErrMsg;
1.669 + pVtab->zErrMsg = 0;
1.670 + }
1.671 + }
1.672 + db->aVTrans = aVTrans;
1.673 + rcsafety = sqlite3SafetyOn(db);
1.674 +
1.675 + if( rc==SQLITE_OK ){
1.676 + rc = rcsafety;
1.677 + }
1.678 + return rc;
1.679 +}
1.680 +
1.681 +/*
1.682 +** Invoke the xRollback method of all virtual tables in the
1.683 +** sqlite3.aVTrans array. Then clear the array itself.
1.684 +*/
1.685 +int sqlite3VtabRollback(sqlite3 *db){
1.686 + callFinaliser(db, offsetof(sqlite3_module,xRollback));
1.687 + return SQLITE_OK;
1.688 +}
1.689 +
1.690 +/*
1.691 +** Invoke the xCommit method of all virtual tables in the
1.692 +** sqlite3.aVTrans array. Then clear the array itself.
1.693 +*/
1.694 +int sqlite3VtabCommit(sqlite3 *db){
1.695 + callFinaliser(db, offsetof(sqlite3_module,xCommit));
1.696 + return SQLITE_OK;
1.697 +}
1.698 +
1.699 +/*
1.700 +** If the virtual table pVtab supports the transaction interface
1.701 +** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
1.702 +** not currently open, invoke the xBegin method now.
1.703 +**
1.704 +** If the xBegin call is successful, place the sqlite3_vtab pointer
1.705 +** in the sqlite3.aVTrans array.
1.706 +*/
1.707 +int sqlite3VtabBegin(sqlite3 *db, sqlite3_vtab *pVtab){
1.708 + int rc = SQLITE_OK;
1.709 + const sqlite3_module *pModule;
1.710 +
1.711 + /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
1.712 + ** than zero, then this function is being called from within a
1.713 + ** virtual module xSync() callback. It is illegal to write to
1.714 + ** virtual module tables in this case, so return SQLITE_LOCKED.
1.715 + */
1.716 + if( 0==db->aVTrans && db->nVTrans>0 ){
1.717 + return SQLITE_LOCKED;
1.718 + }
1.719 + if( !pVtab ){
1.720 + return SQLITE_OK;
1.721 + }
1.722 + pModule = pVtab->pModule;
1.723 +
1.724 + if( pModule->xBegin ){
1.725 + int i;
1.726 +
1.727 +
1.728 + /* If pVtab is already in the aVTrans array, return early */
1.729 + for(i=0; (i<db->nVTrans) && 0!=db->aVTrans[i]; i++){
1.730 + if( db->aVTrans[i]==pVtab ){
1.731 + return SQLITE_OK;
1.732 + }
1.733 + }
1.734 +
1.735 + /* Invoke the xBegin method */
1.736 + rc = pModule->xBegin(pVtab);
1.737 + if( rc==SQLITE_OK ){
1.738 + rc = addToVTrans(db, pVtab);
1.739 + }
1.740 + }
1.741 + return rc;
1.742 +}
1.743 +
1.744 +/*
1.745 +** The first parameter (pDef) is a function implementation. The
1.746 +** second parameter (pExpr) is the first argument to this function.
1.747 +** If pExpr is a column in a virtual table, then let the virtual
1.748 +** table implementation have an opportunity to overload the function.
1.749 +**
1.750 +** This routine is used to allow virtual table implementations to
1.751 +** overload MATCH, LIKE, GLOB, and REGEXP operators.
1.752 +**
1.753 +** Return either the pDef argument (indicating no change) or a
1.754 +** new FuncDef structure that is marked as ephemeral using the
1.755 +** SQLITE_FUNC_EPHEM flag.
1.756 +*/
1.757 +FuncDef *sqlite3VtabOverloadFunction(
1.758 + sqlite3 *db, /* Database connection for reporting malloc problems */
1.759 + FuncDef *pDef, /* Function to possibly overload */
1.760 + int nArg, /* Number of arguments to the function */
1.761 + Expr *pExpr /* First argument to the function */
1.762 +){
1.763 + Table *pTab;
1.764 + sqlite3_vtab *pVtab;
1.765 + sqlite3_module *pMod;
1.766 + void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
1.767 + void *pArg;
1.768 + FuncDef *pNew;
1.769 + int rc = 0;
1.770 + char *zLowerName;
1.771 + unsigned char *z;
1.772 +
1.773 +
1.774 + /* Check to see the left operand is a column in a virtual table */
1.775 + if( pExpr==0 ) return pDef;
1.776 + if( pExpr->op!=TK_COLUMN ) return pDef;
1.777 + pTab = pExpr->pTab;
1.778 + if( pTab==0 ) return pDef;
1.779 + if( !pTab->isVirtual ) return pDef;
1.780 + pVtab = pTab->pVtab;
1.781 + assert( pVtab!=0 );
1.782 + assert( pVtab->pModule!=0 );
1.783 + pMod = (sqlite3_module *)pVtab->pModule;
1.784 + if( pMod->xFindFunction==0 ) return pDef;
1.785 +
1.786 + /* Call the xFindFunction method on the virtual table implementation
1.787 + ** to see if the implementation wants to overload this function
1.788 + */
1.789 + zLowerName = sqlite3DbStrDup(db, pDef->zName);
1.790 + if( zLowerName ){
1.791 + for(z=(unsigned char*)zLowerName; *z; z++){
1.792 + *z = sqlite3UpperToLower[*z];
1.793 + }
1.794 + rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
1.795 + sqlite3DbFree(db, zLowerName);
1.796 + if( pVtab->zErrMsg ){
1.797 + sqlite3Error(db, rc, "%s", pVtab->zErrMsg);
1.798 + sqlite3DbFree(db, pVtab->zErrMsg);
1.799 + pVtab->zErrMsg = 0;
1.800 + }
1.801 + }
1.802 + if( rc==0 ){
1.803 + return pDef;
1.804 + }
1.805 +
1.806 + /* Create a new ephemeral function definition for the overloaded
1.807 + ** function */
1.808 + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) + strlen(pDef->zName) );
1.809 + if( pNew==0 ){
1.810 + return pDef;
1.811 + }
1.812 + *pNew = *pDef;
1.813 + memcpy(pNew->zName, pDef->zName, strlen(pDef->zName)+1);
1.814 + pNew->xFunc = xFunc;
1.815 + pNew->pUserData = pArg;
1.816 + pNew->flags |= SQLITE_FUNC_EPHEM;
1.817 + return pNew;
1.818 +}
1.819 +
1.820 +/*
1.821 +** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
1.822 +** array so that an OP_VBegin will get generated for it. Add pTab to the
1.823 +** array if it is missing. If pTab is already in the array, this routine
1.824 +** is a no-op.
1.825 +*/
1.826 +void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
1.827 + int i, n;
1.828 + assert( IsVirtual(pTab) );
1.829 + for(i=0; i<pParse->nVtabLock; i++){
1.830 + if( pTab==pParse->apVtabLock[i] ) return;
1.831 + }
1.832 + n = (pParse->nVtabLock+1)*sizeof(pParse->apVtabLock[0]);
1.833 + pParse->apVtabLock = sqlite3_realloc(pParse->apVtabLock, n);
1.834 + if( pParse->apVtabLock ){
1.835 + pParse->apVtabLock[pParse->nVtabLock++] = pTab;
1.836 + }else{
1.837 + pParse->db->mallocFailed = 1;
1.838 + }
1.839 +}
1.840 +
1.841 +#endif /* SQLITE_OMIT_VIRTUALTABLE */