| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2003 April 6 | |
| 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 implement the ATTACH and DETACH commands. | |
| 13 ** | |
| 14 ** $Id: attach.c,v 1.93 2009/05/31 21:21:41 drh Exp $ | |
| 15 */ | |
| 16 #include "sqliteInt.h" | |
| 17 | |
| 18 #ifndef SQLITE_OMIT_ATTACH | |
| 19 /* | |
| 20 ** Resolve an expression that was part of an ATTACH or DETACH statement. This | |
| 21 ** is slightly different from resolving a normal SQL expression, because simple | |
| 22 ** identifiers are treated as strings, not possible column names or aliases. | |
| 23 ** | |
| 24 ** i.e. if the parser sees: | |
| 25 ** | |
| 26 ** ATTACH DATABASE abc AS def | |
| 27 ** | |
| 28 ** it treats the two expressions as literal strings 'abc' and 'def' instead of | |
| 29 ** looking for columns of the same name. | |
| 30 ** | |
| 31 ** This only applies to the root node of pExpr, so the statement: | |
| 32 ** | |
| 33 ** ATTACH DATABASE abc||def AS 'db2' | |
| 34 ** | |
| 35 ** will fail because neither abc or def can be resolved. | |
| 36 */ | |
| 37 static int resolveAttachExpr(NameContext *pName, Expr *pExpr) | |
| 38 { | |
| 39 int rc = SQLITE_OK; | |
| 40 if( pExpr ){ | |
| 41 if( pExpr->op!=TK_ID ){ | |
| 42 rc = sqlite3ResolveExprNames(pName, pExpr); | |
| 43 if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){ | |
| 44 sqlite3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken); | |
| 45 return SQLITE_ERROR; | |
| 46 } | |
| 47 }else{ | |
| 48 pExpr->op = TK_STRING; | |
| 49 } | |
| 50 } | |
| 51 return rc; | |
| 52 } | |
| 53 | |
| 54 /* | |
| 55 ** An SQL user-function registered to do the work of an ATTACH statement. The | |
| 56 ** three arguments to the function come directly from an attach statement: | |
| 57 ** | |
| 58 ** ATTACH DATABASE x AS y KEY z | |
| 59 ** | |
| 60 ** SELECT sqlite_attach(x, y, z) | |
| 61 ** | |
| 62 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the | |
| 63 ** third argument. | |
| 64 */ | |
| 65 static void attachFunc( | |
| 66 sqlite3_context *context, | |
| 67 int NotUsed, | |
| 68 sqlite3_value **argv | |
| 69 ){ | |
| 70 int i; | |
| 71 int rc = 0; | |
| 72 sqlite3 *db = sqlite3_context_db_handle(context); | |
| 73 const char *zName; | |
| 74 const char *zFile; | |
| 75 Db *aNew; | |
| 76 char *zErrDyn = 0; | |
| 77 | |
| 78 UNUSED_PARAMETER(NotUsed); | |
| 79 | |
| 80 zFile = (const char *)sqlite3_value_text(argv[0]); | |
| 81 zName = (const char *)sqlite3_value_text(argv[1]); | |
| 82 if( zFile==0 ) zFile = ""; | |
| 83 if( zName==0 ) zName = ""; | |
| 84 | |
| 85 /* Check for the following errors: | |
| 86 ** | |
| 87 ** * Too many attached databases, | |
| 88 ** * Transaction currently open | |
| 89 ** * Specified database name already being used. | |
| 90 */ | |
| 91 if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){ | |
| 92 zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d", | |
| 93 db->aLimit[SQLITE_LIMIT_ATTACHED] | |
| 94 ); | |
| 95 goto attach_error; | |
| 96 } | |
| 97 if( !db->autoCommit ){ | |
| 98 zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction"); | |
| 99 goto attach_error; | |
| 100 } | |
| 101 for(i=0; i<db->nDb; i++){ | |
| 102 char *z = db->aDb[i].zName; | |
| 103 assert( z && zName ); | |
| 104 if( sqlite3StrICmp(z, zName)==0 ){ | |
| 105 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName); | |
| 106 goto attach_error; | |
| 107 } | |
| 108 } | |
| 109 | |
| 110 /* Allocate the new entry in the db->aDb[] array and initialise the schema | |
| 111 ** hash tables. | |
| 112 */ | |
| 113 if( db->aDb==db->aDbStatic ){ | |
| 114 aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 ); | |
| 115 if( aNew==0 ) return; | |
| 116 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); | |
| 117 }else{ | |
| 118 aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); | |
| 119 if( aNew==0 ) return; | |
| 120 } | |
| 121 db->aDb = aNew; | |
| 122 aNew = &db->aDb[db->nDb]; | |
| 123 memset(aNew, 0, sizeof(*aNew)); | |
| 124 | |
| 125 /* Open the database file. If the btree is successfully opened, use | |
| 126 ** it to obtain the database schema. At this point the schema may | |
| 127 ** or may not be initialised. | |
| 128 */ | |
| 129 rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE, | |
| 130 db->openFlags | SQLITE_OPEN_MAIN_DB, | |
| 131 &aNew->pBt); | |
| 132 db->nDb++; | |
| 133 if( rc==SQLITE_CONSTRAINT ){ | |
| 134 rc = SQLITE_ERROR; | |
| 135 zErrDyn = sqlite3MPrintf(db, "database is already attached"); | |
| 136 }else if( rc==SQLITE_OK ){ | |
| 137 Pager *pPager; | |
| 138 aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt); | |
| 139 if( !aNew->pSchema ){ | |
| 140 rc = SQLITE_NOMEM; | |
| 141 }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){ | |
| 142 zErrDyn = sqlite3MPrintf(db, | |
| 143 "attached databases must use the same text encoding as main database"); | |
| 144 rc = SQLITE_ERROR; | |
| 145 } | |
| 146 pPager = sqlite3BtreePager(aNew->pBt); | |
| 147 sqlite3PagerLockingMode(pPager, db->dfltLockMode); | |
| 148 sqlite3PagerJournalMode(pPager, db->dfltJournalMode); | |
| 149 } | |
| 150 aNew->zName = sqlite3DbStrDup(db, zName); | |
| 151 aNew->safety_level = 3; | |
| 152 | |
| 153 #if SQLITE_HAS_CODEC | |
| 154 { | |
| 155 extern int sqlite3CodecAttach(sqlite3*, int, const void*, int); | |
| 156 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*); | |
| 157 int nKey; | |
| 158 char *zKey; | |
| 159 int t = sqlite3_value_type(argv[2]); | |
| 160 switch( t ){ | |
| 161 case SQLITE_INTEGER: | |
| 162 case SQLITE_FLOAT: | |
| 163 zErrDyn = sqlite3DbStrDup(db, "Invalid key value"); | |
| 164 rc = SQLITE_ERROR; | |
| 165 break; | |
| 166 | |
| 167 case SQLITE_TEXT: | |
| 168 case SQLITE_BLOB: | |
| 169 nKey = sqlite3_value_bytes(argv[2]); | |
| 170 zKey = (char *)sqlite3_value_blob(argv[2]); | |
| 171 sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); | |
| 172 break; | |
| 173 | |
| 174 case SQLITE_NULL: | |
| 175 /* No key specified. Use the key from the main database */ | |
| 176 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey); | |
| 177 sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); | |
| 178 break; | |
| 179 } | |
| 180 } | |
| 181 #endif | |
| 182 | |
| 183 /* If the file was opened successfully, read the schema for the new database. | |
| 184 ** If this fails, or if opening the file failed, then close the file and | |
| 185 ** remove the entry from the db->aDb[] array. i.e. put everything back the way | |
| 186 ** we found it. | |
| 187 */ | |
| 188 if( rc==SQLITE_OK ){ | |
| 189 (void)sqlite3SafetyOn(db); | |
| 190 sqlite3BtreeEnterAll(db); | |
| 191 rc = sqlite3Init(db, &zErrDyn); | |
| 192 sqlite3BtreeLeaveAll(db); | |
| 193 (void)sqlite3SafetyOff(db); | |
| 194 } | |
| 195 if( rc ){ | |
| 196 int iDb = db->nDb - 1; | |
| 197 assert( iDb>=2 ); | |
| 198 if( db->aDb[iDb].pBt ){ | |
| 199 sqlite3BtreeClose(db->aDb[iDb].pBt); | |
| 200 db->aDb[iDb].pBt = 0; | |
| 201 db->aDb[iDb].pSchema = 0; | |
| 202 } | |
| 203 sqlite3ResetInternalSchema(db, 0); | |
| 204 db->nDb = iDb; | |
| 205 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ | |
| 206 db->mallocFailed = 1; | |
| 207 sqlite3DbFree(db, zErrDyn); | |
| 208 zErrDyn = sqlite3MPrintf(db, "out of memory"); | |
| 209 }else if( zErrDyn==0 ){ | |
| 210 zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile); | |
| 211 } | |
| 212 goto attach_error; | |
| 213 } | |
| 214 | |
| 215 return; | |
| 216 | |
| 217 attach_error: | |
| 218 /* Return an error if we get here */ | |
| 219 if( zErrDyn ){ | |
| 220 sqlite3_result_error(context, zErrDyn, -1); | |
| 221 sqlite3DbFree(db, zErrDyn); | |
| 222 } | |
| 223 if( rc ) sqlite3_result_error_code(context, rc); | |
| 224 } | |
| 225 | |
| 226 /* | |
| 227 ** An SQL user-function registered to do the work of an DETACH statement. The | |
| 228 ** three arguments to the function come directly from a detach statement: | |
| 229 ** | |
| 230 ** DETACH DATABASE x | |
| 231 ** | |
| 232 ** SELECT sqlite_detach(x) | |
| 233 */ | |
| 234 static void detachFunc( | |
| 235 sqlite3_context *context, | |
| 236 int NotUsed, | |
| 237 sqlite3_value **argv | |
| 238 ){ | |
| 239 const char *zName = (const char *)sqlite3_value_text(argv[0]); | |
| 240 sqlite3 *db = sqlite3_context_db_handle(context); | |
| 241 int i; | |
| 242 Db *pDb = 0; | |
| 243 char zErr[128]; | |
| 244 | |
| 245 UNUSED_PARAMETER(NotUsed); | |
| 246 | |
| 247 if( zName==0 ) zName = ""; | |
| 248 for(i=0; i<db->nDb; i++){ | |
| 249 pDb = &db->aDb[i]; | |
| 250 if( pDb->pBt==0 ) continue; | |
| 251 if( sqlite3StrICmp(pDb->zName, zName)==0 ) break; | |
| 252 } | |
| 253 | |
| 254 if( i>=db->nDb ){ | |
| 255 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName); | |
| 256 goto detach_error; | |
| 257 } | |
| 258 if( i<2 ){ | |
| 259 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName); | |
| 260 goto detach_error; | |
| 261 } | |
| 262 if( !db->autoCommit ){ | |
| 263 sqlite3_snprintf(sizeof(zErr), zErr, | |
| 264 "cannot DETACH database within transaction"); | |
| 265 goto detach_error; | |
| 266 } | |
| 267 if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){ | |
| 268 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); | |
| 269 goto detach_error; | |
| 270 } | |
| 271 | |
| 272 sqlite3BtreeClose(pDb->pBt); | |
| 273 pDb->pBt = 0; | |
| 274 pDb->pSchema = 0; | |
| 275 sqlite3ResetInternalSchema(db, 0); | |
| 276 return; | |
| 277 | |
| 278 detach_error: | |
| 279 sqlite3_result_error(context, zErr, -1); | |
| 280 } | |
| 281 | |
| 282 /* | |
| 283 ** This procedure generates VDBE code for a single invocation of either the | |
| 284 ** sqlite_detach() or sqlite_attach() SQL user functions. | |
| 285 */ | |
| 286 static void codeAttach( | |
| 287 Parse *pParse, /* The parser context */ | |
| 288 int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ | |
| 289 FuncDef *pFunc, /* FuncDef wrapper for detachFunc() or attachFunc() */ | |
| 290 Expr *pAuthArg, /* Expression to pass to authorization callback */ | |
| 291 Expr *pFilename, /* Name of database file */ | |
| 292 Expr *pDbname, /* Name of the database to use internally */ | |
| 293 Expr *pKey /* Database key for encryption extension */ | |
| 294 ){ | |
| 295 int rc; | |
| 296 NameContext sName; | |
| 297 Vdbe *v; | |
| 298 sqlite3* db = pParse->db; | |
| 299 int regArgs; | |
| 300 | |
| 301 memset(&sName, 0, sizeof(NameContext)); | |
| 302 sName.pParse = pParse; | |
| 303 | |
| 304 if( | |
| 305 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || | |
| 306 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || | |
| 307 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) | |
| 308 ){ | |
| 309 pParse->nErr++; | |
| 310 goto attach_end; | |
| 311 } | |
| 312 | |
| 313 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 314 if( pAuthArg ){ | |
| 315 char *zAuthArg = pAuthArg->u.zToken; | |
| 316 int i; | |
| 317 char iBuf[32]; | |
| 318 if( sqlite3ExprIsInteger(pAuthArg, &i) ){ | |
| 319 sqlite3_snprintf(sizeof(iBuf), iBuf, "%d", pAuthArg->u.iValue); | |
| 320 zAuthArg = iBuf; | |
| 321 } | |
| 322 if( NEVER(zAuthArg==0) ){ | |
| 323 goto attach_end; | |
| 324 } | |
| 325 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); | |
| 326 if(rc!=SQLITE_OK ){ | |
| 327 goto attach_end; | |
| 328 } | |
| 329 } | |
| 330 #endif /* SQLITE_OMIT_AUTHORIZATION */ | |
| 331 | |
| 332 | |
| 333 v = sqlite3GetVdbe(pParse); | |
| 334 regArgs = sqlite3GetTempRange(pParse, 4); | |
| 335 sqlite3ExprCode(pParse, pFilename, regArgs); | |
| 336 sqlite3ExprCode(pParse, pDbname, regArgs+1); | |
| 337 sqlite3ExprCode(pParse, pKey, regArgs+2); | |
| 338 | |
| 339 assert( v || db->mallocFailed ); | |
| 340 if( v ){ | |
| 341 sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-pFunc->nArg, regArgs+3); | |
| 342 assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg ); | |
| 343 sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg)); | |
| 344 sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF); | |
| 345 | |
| 346 /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this | |
| 347 ** statement only). For DETACH, set it to false (expire all existing | |
| 348 ** statements). | |
| 349 */ | |
| 350 sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH)); | |
| 351 } | |
| 352 | |
| 353 attach_end: | |
| 354 sqlite3ExprDelete(db, pFilename); | |
| 355 sqlite3ExprDelete(db, pDbname); | |
| 356 sqlite3ExprDelete(db, pKey); | |
| 357 } | |
| 358 | |
| 359 /* | |
| 360 ** Called by the parser to compile a DETACH statement. | |
| 361 ** | |
| 362 ** DETACH pDbname | |
| 363 */ | |
| 364 void sqlite3Detach(Parse *pParse, Expr *pDbname){ | |
| 365 static FuncDef detach_func = { | |
| 366 1, /* nArg */ | |
| 367 SQLITE_UTF8, /* iPrefEnc */ | |
| 368 0, /* flags */ | |
| 369 0, /* pUserData */ | |
| 370 0, /* pNext */ | |
| 371 detachFunc, /* xFunc */ | |
| 372 0, /* xStep */ | |
| 373 0, /* xFinalize */ | |
| 374 "sqlite_detach", /* zName */ | |
| 375 0 /* pHash */ | |
| 376 }; | |
| 377 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname); | |
| 378 } | |
| 379 | |
| 380 /* | |
| 381 ** Called by the parser to compile an ATTACH statement. | |
| 382 ** | |
| 383 ** ATTACH p AS pDbname KEY pKey | |
| 384 */ | |
| 385 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ | |
| 386 static FuncDef attach_func = { | |
| 387 3, /* nArg */ | |
| 388 SQLITE_UTF8, /* iPrefEnc */ | |
| 389 0, /* flags */ | |
| 390 0, /* pUserData */ | |
| 391 0, /* pNext */ | |
| 392 attachFunc, /* xFunc */ | |
| 393 0, /* xStep */ | |
| 394 0, /* xFinalize */ | |
| 395 "sqlite_attach", /* zName */ | |
| 396 0 /* pHash */ | |
| 397 }; | |
| 398 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey); | |
| 399 } | |
| 400 #endif /* SQLITE_OMIT_ATTACH */ | |
| 401 | |
| 402 /* | |
| 403 ** Initialize a DbFixer structure. This routine must be called prior | |
| 404 ** to passing the structure to one of the sqliteFixAAAA() routines below. | |
| 405 ** | |
| 406 ** The return value indicates whether or not fixation is required. TRUE | |
| 407 ** means we do need to fix the database references, FALSE means we do not. | |
| 408 */ | |
| 409 int sqlite3FixInit( | |
| 410 DbFixer *pFix, /* The fixer to be initialized */ | |
| 411 Parse *pParse, /* Error messages will be written here */ | |
| 412 int iDb, /* This is the database that must be used */ | |
| 413 const char *zType, /* "view", "trigger", or "index" */ | |
| 414 const Token *pName /* Name of the view, trigger, or index */ | |
| 415 ){ | |
| 416 sqlite3 *db; | |
| 417 | |
| 418 if( NEVER(iDb<0) || iDb==1 ) return 0; | |
| 419 db = pParse->db; | |
| 420 assert( db->nDb>iDb ); | |
| 421 pFix->pParse = pParse; | |
| 422 pFix->zDb = db->aDb[iDb].zName; | |
| 423 pFix->zType = zType; | |
| 424 pFix->pName = pName; | |
| 425 return 1; | |
| 426 } | |
| 427 | |
| 428 /* | |
| 429 ** The following set of routines walk through the parse tree and assign | |
| 430 ** a specific database to all table references where the database name | |
| 431 ** was left unspecified in the original SQL statement. The pFix structure | |
| 432 ** must have been initialized by a prior call to sqlite3FixInit(). | |
| 433 ** | |
| 434 ** These routines are used to make sure that an index, trigger, or | |
| 435 ** view in one database does not refer to objects in a different database. | |
| 436 ** (Exception: indices, triggers, and views in the TEMP database are | |
| 437 ** allowed to refer to anything.) If a reference is explicitly made | |
| 438 ** to an object in a different database, an error message is added to | |
| 439 ** pParse->zErrMsg and these routines return non-zero. If everything | |
| 440 ** checks out, these routines return 0. | |
| 441 */ | |
| 442 int sqlite3FixSrcList( | |
| 443 DbFixer *pFix, /* Context of the fixation */ | |
| 444 SrcList *pList /* The Source list to check and modify */ | |
| 445 ){ | |
| 446 int i; | |
| 447 const char *zDb; | |
| 448 struct SrcList_item *pItem; | |
| 449 | |
| 450 if( NEVER(pList==0) ) return 0; | |
| 451 zDb = pFix->zDb; | |
| 452 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){ | |
| 453 if( pItem->zDatabase==0 ){ | |
| 454 pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb); | |
| 455 }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){ | |
| 456 sqlite3ErrorMsg(pFix->pParse, | |
| 457 "%s %T cannot reference objects in database %s", | |
| 458 pFix->zType, pFix->pName, pItem->zDatabase); | |
| 459 return 1; | |
| 460 } | |
| 461 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) | |
| 462 if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; | |
| 463 if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; | |
| 464 #endif | |
| 465 } | |
| 466 return 0; | |
| 467 } | |
| 468 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) | |
| 469 int sqlite3FixSelect( | |
| 470 DbFixer *pFix, /* Context of the fixation */ | |
| 471 Select *pSelect /* The SELECT statement to be fixed to one database */ | |
| 472 ){ | |
| 473 while( pSelect ){ | |
| 474 if( sqlite3FixExprList(pFix, pSelect->pEList) ){ | |
| 475 return 1; | |
| 476 } | |
| 477 if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ | |
| 478 return 1; | |
| 479 } | |
| 480 if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ | |
| 481 return 1; | |
| 482 } | |
| 483 if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ | |
| 484 return 1; | |
| 485 } | |
| 486 pSelect = pSelect->pPrior; | |
| 487 } | |
| 488 return 0; | |
| 489 } | |
| 490 int sqlite3FixExpr( | |
| 491 DbFixer *pFix, /* Context of the fixation */ | |
| 492 Expr *pExpr /* The expression to be fixed to one database */ | |
| 493 ){ | |
| 494 while( pExpr ){ | |
| 495 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ) break; | |
| 496 if( ExprHasProperty(pExpr, EP_xIsSelect) ){ | |
| 497 if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1; | |
| 498 }else{ | |
| 499 if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1; | |
| 500 } | |
| 501 if( sqlite3FixExpr(pFix, pExpr->pRight) ){ | |
| 502 return 1; | |
| 503 } | |
| 504 pExpr = pExpr->pLeft; | |
| 505 } | |
| 506 return 0; | |
| 507 } | |
| 508 int sqlite3FixExprList( | |
| 509 DbFixer *pFix, /* Context of the fixation */ | |
| 510 ExprList *pList /* The expression to be fixed to one database */ | |
| 511 ){ | |
| 512 int i; | |
| 513 struct ExprList_item *pItem; | |
| 514 if( pList==0 ) return 0; | |
| 515 for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){ | |
| 516 if( sqlite3FixExpr(pFix, pItem->pExpr) ){ | |
| 517 return 1; | |
| 518 } | |
| 519 } | |
| 520 return 0; | |
| 521 } | |
| 522 #endif | |
| 523 | |
| 524 #ifndef SQLITE_OMIT_TRIGGER | |
| 525 int sqlite3FixTriggerStep( | |
| 526 DbFixer *pFix, /* Context of the fixation */ | |
| 527 TriggerStep *pStep /* The trigger step be fixed to one database */ | |
| 528 ){ | |
| 529 while( pStep ){ | |
| 530 if( sqlite3FixSelect(pFix, pStep->pSelect) ){ | |
| 531 return 1; | |
| 532 } | |
| 533 if( sqlite3FixExpr(pFix, pStep->pWhere) ){ | |
| 534 return 1; | |
| 535 } | |
| 536 if( sqlite3FixExprList(pFix, pStep->pExprList) ){ | |
| 537 return 1; | |
| 538 } | |
| 539 pStep = pStep->pNext; | |
| 540 } | |
| 541 return 0; | |
| 542 } | |
| 543 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3108030:
Move bundled copy of sqlite one level deeper to better separate it... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/