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