| 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 pPager = sqlite3BtreePager(aNew->pBt); | |
| 154 sqlite3PagerLockingMode(pPager, db->dfltLockMode); | |
| 155 sqlite3BtreeSecureDelete(aNew->pBt, | |
| 156 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) ); | |
| 157 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
| 158 sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK)); | |
| 159 #endif | |
| 160 } | |
| 161 aNew->safety_level = 3; | |
| 162 aNew->zName = sqlite3DbStrDup(db, zName); | |
| 163 if( rc==SQLITE_OK && aNew->zName==0 ){ | |
| 164 rc = SQLITE_NOMEM; | |
| 165 } | |
| 166 | |
| 167 | |
| 168 #ifdef SQLITE_HAS_CODEC | |
| 169 if( rc==SQLITE_OK ){ | |
| 170 extern int sqlite3CodecAttach(sqlite3*, int, const void*, int); | |
| 171 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*); | |
| 172 int nKey; | |
| 173 char *zKey; | |
| 174 int t = sqlite3_value_type(argv[2]); | |
| 175 switch( t ){ | |
| 176 case SQLITE_INTEGER: | |
| 177 case SQLITE_FLOAT: | |
| 178 zErrDyn = sqlite3DbStrDup(db, "Invalid key value"); | |
| 179 rc = SQLITE_ERROR; | |
| 180 break; | |
| 181 | |
| 182 case SQLITE_TEXT: | |
| 183 case SQLITE_BLOB: | |
| 184 nKey = sqlite3_value_bytes(argv[2]); | |
| 185 zKey = (char *)sqlite3_value_blob(argv[2]); | |
| 186 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); | |
| 187 break; | |
| 188 | |
| 189 case SQLITE_NULL: | |
| 190 /* No key specified. Use the key from the main database */ | |
| 191 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey); | |
| 192 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){ | |
| 193 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); | |
| 194 } | |
| 195 break; | |
| 196 } | |
| 197 } | |
| 198 #endif | |
| 199 | |
| 200 /* If the file was opened successfully, read the schema for the new database. | |
| 201 ** If this fails, or if opening the file failed, then close the file and | |
| 202 ** remove the entry from the db->aDb[] array. i.e. put everything back the way | |
| 203 ** we found it. | |
| 204 */ | |
| 205 if( rc==SQLITE_OK ){ | |
| 206 sqlite3BtreeEnterAll(db); | |
| 207 rc = sqlite3Init(db, &zErrDyn); | |
| 208 sqlite3BtreeLeaveAll(db); | |
| 209 } | |
| 210 #ifdef SQLITE_USER_AUTHENTICATION | |
| 211 if( rc==SQLITE_OK ){ | |
| 212 u8 newAuth = 0; | |
| 213 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth); | |
| 214 if( newAuth<db->auth.authLevel ){ | |
| 215 rc = SQLITE_AUTH_USER; | |
| 216 } | |
| 217 } | |
| 218 #endif | |
| 219 if( rc ){ | |
| 220 int iDb = db->nDb - 1; | |
| 221 assert( iDb>=2 ); | |
| 222 if( db->aDb[iDb].pBt ){ | |
| 223 sqlite3BtreeClose(db->aDb[iDb].pBt); | |
| 224 db->aDb[iDb].pBt = 0; | |
| 225 db->aDb[iDb].pSchema = 0; | |
| 226 } | |
| 227 sqlite3ResetAllSchemasOfConnection(db); | |
| 228 db->nDb = iDb; | |
| 229 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ | |
| 230 db->mallocFailed = 1; | |
| 231 sqlite3DbFree(db, zErrDyn); | |
| 232 zErrDyn = sqlite3MPrintf(db, "out of memory"); | |
| 233 }else if( zErrDyn==0 ){ | |
| 234 zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile); | |
| 235 } | |
| 236 goto attach_error; | |
| 237 } | |
| 238 | |
| 239 return; | |
| 240 | |
| 241 attach_error: | |
| 242 /* Return an error if we get here */ | |
| 243 if( zErrDyn ){ | |
| 244 sqlite3_result_error(context, zErrDyn, -1); | |
| 245 sqlite3DbFree(db, zErrDyn); | |
| 246 } | |
| 247 if( rc ) sqlite3_result_error_code(context, rc); | |
| 248 } | |
| 249 | |
| 250 /* | |
| 251 ** An SQL user-function registered to do the work of an DETACH statement. The | |
| 252 ** three arguments to the function come directly from a detach statement: | |
| 253 ** | |
| 254 ** DETACH DATABASE x | |
| 255 ** | |
| 256 ** SELECT sqlite_detach(x) | |
| 257 */ | |
| 258 static void detachFunc( | |
| 259 sqlite3_context *context, | |
| 260 int NotUsed, | |
| 261 sqlite3_value **argv | |
| 262 ){ | |
| 263 const char *zName = (const char *)sqlite3_value_text(argv[0]); | |
| 264 sqlite3 *db = sqlite3_context_db_handle(context); | |
| 265 int i; | |
| 266 Db *pDb = 0; | |
| 267 char zErr[128]; | |
| 268 | |
| 269 UNUSED_PARAMETER(NotUsed); | |
| 270 | |
| 271 if( zName==0 ) zName = ""; | |
| 272 for(i=0; i<db->nDb; i++){ | |
| 273 pDb = &db->aDb[i]; | |
| 274 if( pDb->pBt==0 ) continue; | |
| 275 if( sqlite3StrICmp(pDb->zName, zName)==0 ) break; | |
| 276 } | |
| 277 | |
| 278 if( i>=db->nDb ){ | |
| 279 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName); | |
| 280 goto detach_error; | |
| 281 } | |
| 282 if( i<2 ){ | |
| 283 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName); | |
| 284 goto detach_error; | |
| 285 } | |
| 286 if( !db->autoCommit ){ | |
| 287 sqlite3_snprintf(sizeof(zErr), zErr, | |
| 288 "cannot DETACH database within transaction"); | |
| 289 goto detach_error; | |
| 290 } | |
| 291 if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){ | |
| 292 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); | |
| 293 goto detach_error; | |
| 294 } | |
| 295 | |
| 296 sqlite3BtreeClose(pDb->pBt); | |
| 297 pDb->pBt = 0; | |
| 298 pDb->pSchema = 0; | |
| 299 sqlite3ResetAllSchemasOfConnection(db); | |
| 300 return; | |
| 301 | |
| 302 detach_error: | |
| 303 sqlite3_result_error(context, zErr, -1); | |
| 304 } | |
| 305 | |
| 306 /* | |
| 307 ** This procedure generates VDBE code for a single invocation of either the | |
| 308 ** sqlite_detach() or sqlite_attach() SQL user functions. | |
| 309 */ | |
| 310 static void codeAttach( | |
| 311 Parse *pParse, /* The parser context */ | |
| 312 int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ | |
| 313 FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */ | |
| 314 Expr *pAuthArg, /* Expression to pass to authorization callback */ | |
| 315 Expr *pFilename, /* Name of database file */ | |
| 316 Expr *pDbname, /* Name of the database to use internally */ | |
| 317 Expr *pKey /* Database key for encryption extension */ | |
| 318 ){ | |
| 319 int rc; | |
| 320 NameContext sName; | |
| 321 Vdbe *v; | |
| 322 sqlite3* db = pParse->db; | |
| 323 int regArgs; | |
| 324 | |
| 325 memset(&sName, 0, sizeof(NameContext)); | |
| 326 sName.pParse = pParse; | |
| 327 | |
| 328 if( | |
| 329 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || | |
| 330 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || | |
| 331 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) | |
| 332 ){ | |
| 333 pParse->nErr++; | |
| 334 goto attach_end; | |
| 335 } | |
| 336 | |
| 337 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 338 if( pAuthArg ){ | |
| 339 char *zAuthArg; | |
| 340 if( pAuthArg->op==TK_STRING ){ | |
| 341 zAuthArg = pAuthArg->u.zToken; | |
| 342 }else{ | |
| 343 zAuthArg = 0; | |
| 344 } | |
| 345 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); | |
| 346 if(rc!=SQLITE_OK ){ | |
| 347 goto attach_end; | |
| 348 } | |
| 349 } | |
| 350 #endif /* SQLITE_OMIT_AUTHORIZATION */ | |
| 351 | |
| 352 | |
| 353 v = sqlite3GetVdbe(pParse); | |
| 354 regArgs = sqlite3GetTempRange(pParse, 4); | |
| 355 sqlite3ExprCode(pParse, pFilename, regArgs); | |
| 356 sqlite3ExprCode(pParse, pDbname, regArgs+1); | |
| 357 sqlite3ExprCode(pParse, pKey, regArgs+2); | |
| 358 | |
| 359 assert( v || db->mallocFailed ); | |
| 360 if( v ){ | |
| 361 sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-pFunc->nArg, regArgs+3); | |
| 362 assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg ); | |
| 363 sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg)); | |
| 364 sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF); | |
| 365 | |
| 366 /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this | |
| 367 ** statement only). For DETACH, set it to false (expire all existing | |
| 368 ** statements). | |
| 369 */ | |
| 370 sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH)); | |
| 371 } | |
| 372 | |
| 373 attach_end: | |
| 374 sqlite3ExprDelete(db, pFilename); | |
| 375 sqlite3ExprDelete(db, pDbname); | |
| 376 sqlite3ExprDelete(db, pKey); | |
| 377 } | |
| 378 | |
| 379 /* | |
| 380 ** Called by the parser to compile a DETACH statement. | |
| 381 ** | |
| 382 ** DETACH pDbname | |
| 383 */ | |
| 384 void sqlite3Detach(Parse *pParse, Expr *pDbname){ | |
| 385 static const FuncDef detach_func = { | |
| 386 1, /* nArg */ | |
| 387 SQLITE_UTF8, /* funcFlags */ | |
| 388 0, /* pUserData */ | |
| 389 0, /* pNext */ | |
| 390 detachFunc, /* xFunc */ | |
| 391 0, /* xStep */ | |
| 392 0, /* xFinalize */ | |
| 393 "sqlite_detach", /* zName */ | |
| 394 0, /* pHash */ | |
| 395 0 /* pDestructor */ | |
| 396 }; | |
| 397 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname); | |
| 398 } | |
| 399 | |
| 400 /* | |
| 401 ** Called by the parser to compile an ATTACH statement. | |
| 402 ** | |
| 403 ** ATTACH p AS pDbname KEY pKey | |
| 404 */ | |
| 405 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ | |
| 406 static const FuncDef attach_func = { | |
| 407 3, /* nArg */ | |
| 408 SQLITE_UTF8, /* funcFlags */ | |
| 409 0, /* pUserData */ | |
| 410 0, /* pNext */ | |
| 411 attachFunc, /* xFunc */ | |
| 412 0, /* xStep */ | |
| 413 0, /* xFinalize */ | |
| 414 "sqlite_attach", /* zName */ | |
| 415 0, /* pHash */ | |
| 416 0 /* pDestructor */ | |
| 417 }; | |
| 418 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey); | |
| 419 } | |
| 420 #endif /* SQLITE_OMIT_ATTACH */ | |
| 421 | |
| 422 /* | |
| 423 ** Initialize a DbFixer structure. This routine must be called prior | |
| 424 ** to passing the structure to one of the sqliteFixAAAA() routines below. | |
| 425 */ | |
| 426 void sqlite3FixInit( | |
| 427 DbFixer *pFix, /* The fixer to be initialized */ | |
| 428 Parse *pParse, /* Error messages will be written here */ | |
| 429 int iDb, /* This is the database that must be used */ | |
| 430 const char *zType, /* "view", "trigger", or "index" */ | |
| 431 const Token *pName /* Name of the view, trigger, or index */ | |
| 432 ){ | |
| 433 sqlite3 *db; | |
| 434 | |
| 435 db = pParse->db; | |
| 436 assert( db->nDb>iDb ); | |
| 437 pFix->pParse = pParse; | |
| 438 pFix->zDb = db->aDb[iDb].zName; | |
| 439 pFix->pSchema = db->aDb[iDb].pSchema; | |
| 440 pFix->zType = zType; | |
| 441 pFix->pName = pName; | |
| 442 pFix->bVarOnly = (iDb==1); | |
| 443 } | |
| 444 | |
| 445 /* | |
| 446 ** The following set of routines walk through the parse tree and assign | |
| 447 ** a specific database to all table references where the database name | |
| 448 ** was left unspecified in the original SQL statement. The pFix structure | |
| 449 ** must have been initialized by a prior call to sqlite3FixInit(). | |
| 450 ** | |
| 451 ** These routines are used to make sure that an index, trigger, or | |
| 452 ** view in one database does not refer to objects in a different database. | |
| 453 ** (Exception: indices, triggers, and views in the TEMP database are | |
| 454 ** allowed to refer to anything.) If a reference is explicitly made | |
| 455 ** to an object in a different database, an error message is added to | |
| 456 ** pParse->zErrMsg and these routines return non-zero. If everything | |
| 457 ** checks out, these routines return 0. | |
| 458 */ | |
| 459 int sqlite3FixSrcList( | |
| 460 DbFixer *pFix, /* Context of the fixation */ | |
| 461 SrcList *pList /* The Source list to check and modify */ | |
| 462 ){ | |
| 463 int i; | |
| 464 const char *zDb; | |
| 465 struct SrcList_item *pItem; | |
| 466 | |
| 467 if( NEVER(pList==0) ) return 0; | |
| 468 zDb = pFix->zDb; | |
| 469 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){ | |
| 470 if( pFix->bVarOnly==0 ){ | |
| 471 if( pItem->zDatabase && sqlite3StrICmp(pItem->zDatabase, zDb) ){ | |
| 472 sqlite3ErrorMsg(pFix->pParse, | |
| 473 "%s %T cannot reference objects in database %s", | |
| 474 pFix->zType, pFix->pName, pItem->zDatabase); | |
| 475 return 1; | |
| 476 } | |
| 477 sqlite3DbFree(pFix->pParse->db, pItem->zDatabase); | |
| 478 pItem->zDatabase = 0; | |
| 479 pItem->pSchema = pFix->pSchema; | |
| 480 } | |
| 481 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) | |
| 482 if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; | |
| 483 if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; | |
| 484 #endif | |
| 485 } | |
| 486 return 0; | |
| 487 } | |
| 488 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) | |
| 489 int sqlite3FixSelect( | |
| 490 DbFixer *pFix, /* Context of the fixation */ | |
| 491 Select *pSelect /* The SELECT statement to be fixed to one database */ | |
| 492 ){ | |
| 493 while( pSelect ){ | |
| 494 if( sqlite3FixExprList(pFix, pSelect->pEList) ){ | |
| 495 return 1; | |
| 496 } | |
| 497 if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ | |
| 498 return 1; | |
| 499 } | |
| 500 if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ | |
| 501 return 1; | |
| 502 } | |
| 503 if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){ | |
| 504 return 1; | |
| 505 } | |
| 506 if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ | |
| 507 return 1; | |
| 508 } | |
| 509 if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){ | |
| 510 return 1; | |
| 511 } | |
| 512 if( sqlite3FixExpr(pFix, pSelect->pLimit) ){ | |
| 513 return 1; | |
| 514 } | |
| 515 if( sqlite3FixExpr(pFix, pSelect->pOffset) ){ | |
| 516 return 1; | |
| 517 } | |
| 518 pSelect = pSelect->pPrior; | |
| 519 } | |
| 520 return 0; | |
| 521 } | |
| 522 int sqlite3FixExpr( | |
| 523 DbFixer *pFix, /* Context of the fixation */ | |
| 524 Expr *pExpr /* The expression to be fixed to one database */ | |
| 525 ){ | |
| 526 while( pExpr ){ | |
| 527 if( pExpr->op==TK_VARIABLE ){ | |
| 528 if( pFix->pParse->db->init.busy ){ | |
| 529 pExpr->op = TK_NULL; | |
| 530 }else{ | |
| 531 sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType); | |
| 532 return 1; | |
| 533 } | |
| 534 } | |
| 535 if( ExprHasProperty(pExpr, EP_TokenOnly) ) break; | |
| 536 if( ExprHasProperty(pExpr, EP_xIsSelect) ){ | |
| 537 if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1; | |
| 538 }else{ | |
| 539 if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1; | |
| 540 } | |
| 541 if( sqlite3FixExpr(pFix, pExpr->pRight) ){ | |
| 542 return 1; | |
| 543 } | |
| 544 pExpr = pExpr->pLeft; | |
| 545 } | |
| 546 return 0; | |
| 547 } | |
| 548 int sqlite3FixExprList( | |
| 549 DbFixer *pFix, /* Context of the fixation */ | |
| 550 ExprList *pList /* The expression to be fixed to one database */ | |
| 551 ){ | |
| 552 int i; | |
| 553 struct ExprList_item *pItem; | |
| 554 if( pList==0 ) return 0; | |
| 555 for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){ | |
| 556 if( sqlite3FixExpr(pFix, pItem->pExpr) ){ | |
| 557 return 1; | |
| 558 } | |
| 559 } | |
| 560 return 0; | |
| 561 } | |
| 562 #endif | |
| 563 | |
| 564 #ifndef SQLITE_OMIT_TRIGGER | |
| 565 int sqlite3FixTriggerStep( | |
| 566 DbFixer *pFix, /* Context of the fixation */ | |
| 567 TriggerStep *pStep /* The trigger step be fixed to one database */ | |
| 568 ){ | |
| 569 while( pStep ){ | |
| 570 if( sqlite3FixSelect(pFix, pStep->pSelect) ){ | |
| 571 return 1; | |
| 572 } | |
| 573 if( sqlite3FixExpr(pFix, pStep->pWhere) ){ | |
| 574 return 1; | |
| 575 } | |
| 576 if( sqlite3FixExprList(pFix, pStep->pExprList) ){ | |
| 577 return 1; | |
| 578 } | |
| 579 pStep = pStep->pNext; | |
| 580 } | |
| 581 return 0; | |
| 582 } | |
| 583 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
