src/attach.c

   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 ** Return true if zName points to a name that may be used to refer to
  50 ** database iDb attached to handle db.
  51 */
  52 int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
  53   return (
  54       sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
  55    || (iDb==0 && sqlite3StrICmp("main", zName)==0)
  56   );
  57 }
  58
  59 /*
  60 ** An SQL user-function registered to do the work of an ATTACH statement. The
  61 ** three arguments to the function come directly from an attach statement:
  62 **
  63 **     ATTACH DATABASE x AS y KEY z
  64 **
  65 **     SELECT sqlite_attach(x, y, z)
  66 **
  67 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
  68 ** third argument.
  69 **
  70 ** If the db->init.reopenMemdb flags is set, then instead of attaching a
  71 ** new database, close the database on db->init.iDb and reopen it as an
  72 ** empty MemDB.
  73 */
  74 static void attachFunc(
  75   sqlite3_context *context,
  76   int NotUsed,
  77   sqlite3_value **argv
  78 ){
  79   int i;
  80   int rc = 0;
  81   sqlite3 *db = sqlite3_context_db_handle(context);
  82   const char *zName;
  83   const char *zFile;
  84   char *zPath = 0;
  85   char *zErr = 0;
  86   unsigned int flags;
  87   Db *aNew;                 /* New array of Db pointers */
  88   Db *pNew;                 /* Db object for the newly attached database */
  89   char *zErrDyn = 0;
  90   sqlite3_vfs *pVfs;
  91
  92   UNUSED_PARAMETER(NotUsed);
  93   zFile = (const char *)sqlite3_value_text(argv[0]);
  94   zName = (const char *)sqlite3_value_text(argv[1]);
  95   if( zFile==0 ) zFile = "";
  96   if( zName==0 ) zName = "";
  97
  98 #ifdef SQLITE_ENABLE_DESERIALIZE
  99 # define REOPEN_AS_MEMDB(db)  (db->init.reopenMemdb)
 100 #else
 101 # define REOPEN_AS_MEMDB(db)  (0)
 102 #endif
 103
 104   if( REOPEN_AS_MEMDB(db) ){
 105     /* This is not a real ATTACH.  Instead, this routine is being called
 106     ** from sqlite3_deserialize() to close database db->init.iDb and
 107     ** reopen it as a MemDB */
 108     pVfs = sqlite3_vfs_find("memdb");
 109     if( pVfs==0 ) return;
 110     pNew = &db->aDb[db->init.iDb];
 111     if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
 112     pNew->pBt = 0;
 113     pNew->pSchema = 0;
 114     rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
 115   }else{
 116     /* This is a real ATTACH
 117     **
 118     ** Check for the following errors:
 119     **
 120     **     * Too many attached databases,
 121     **     * Transaction currently open
 122     **     * Specified database name already being used.
 123     */
 124     if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
 125       zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
 126         db->aLimit[SQLITE_LIMIT_ATTACHED]
 127       );
 128       goto attach_error;
 129     }
 130     for(i=0; i<db->nDb; i++){
 131       assert( zName );
 132       if( sqlite3DbIsNamed(db, i, zName) ){
 133         zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
 134         goto attach_error;
 135       }
 136     }
 137
 138     /* Allocate the new entry in the db->aDb[] array and initialize the schema
 139     ** hash tables.
 140     */
 141     if( db->aDb==db->aDbStatic ){
 142       aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
 143       if( aNew==0 ) return;
 144       memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
 145     }else{
 146       aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
 147       if( aNew==0 ) return;
 148     }
 149     db->aDb = aNew;
 150     pNew = &db->aDb[db->nDb];
 151     memset(pNew, 0, sizeof(*pNew));
 152
 153     /* Open the database file. If the btree is successfully opened, use
 154     ** it to obtain the database schema. At this point the schema may
 155     ** or may not be initialized.
 156     */
 157     flags = db->openFlags;
 158     rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
 159     if( rc!=SQLITE_OK ){
 160       if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
 161       sqlite3_result_error(context, zErr, -1);
 162       sqlite3_free(zErr);
 163       return;
 164     }
 165     assert( pVfs );
 166     flags |= SQLITE_OPEN_MAIN_DB;
 167     rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
 168     db->nDb++;
 169     pNew->zDbSName = sqlite3DbStrDup(db, zName);
 170   }
 171   db->noSharedCache = 0;
 172   if( rc==SQLITE_CONSTRAINT ){
 173     rc = SQLITE_ERROR;
 174     zErrDyn = sqlite3MPrintf(db, "database is already attached");
 175   }else if( rc==SQLITE_OK ){
 176     Pager *pPager;
 177     pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
 178     if( !pNew->pSchema ){
 179       rc = SQLITE_NOMEM_BKPT;
 180     }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
 181       zErrDyn = sqlite3MPrintf(db,
 182         "attached databases must use the same text encoding as main database");
 183       rc = SQLITE_ERROR;
 184     }
 185     sqlite3BtreeEnter(pNew->pBt);
 186     pPager = sqlite3BtreePager(pNew->pBt);
 187     sqlite3PagerLockingMode(pPager, db->dfltLockMode);
 188     sqlite3BtreeSecureDelete(pNew->pBt,
 189                              sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
 190 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 191     sqlite3BtreeSetPagerFlags(pNew->pBt,
 192                       PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
 193 #endif
 194     sqlite3BtreeLeave(pNew->pBt);
 195   }
 196   pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
 197   if( rc==SQLITE_OK && pNew->zDbSName==0 ){
 198     rc = SQLITE_NOMEM_BKPT;
 199   }
 200
 201 /* BEGIN SQLCIPHER */
 202 #ifdef SQLITE_HAS_CODEC
 203   if( rc==SQLITE_OK ){
 204     extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
 205     extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
 206     int nKey;
 207     char *zKey;
 208     int t = sqlite3_value_type(argv[2]);
 209     switch( t ){
 210       case SQLITE_INTEGER:
 211       case SQLITE_FLOAT:
 212         zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
 213         rc = SQLITE_ERROR;
 214         break;
 215
 216       case SQLITE_TEXT:
 217       case SQLITE_BLOB:
 218         nKey = sqlite3_value_bytes(argv[2]);
 219         zKey = (char *)sqlite3_value_blob(argv[2]);
 220         rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
 221         break;
 222
 223       case SQLITE_NULL:
 224         /* No key specified.  Use the key from URI filename, or if none,
 225         ** use the key from the main database. */
 226         if( sqlite3CodecQueryParameters(db, zName, zPath)==0 ){
 227           sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
 228           if( nKey || sqlite3BtreeGetRequestedReserve(db->aDb[0].pBt)>0 ){
 229             rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
 230           }
 231         }
 232         break;
 233     }
 234   }
 235 #endif
 236 /* END SQLCIPHER */
 237   sqlite3_free_filename( zPath );
 238
 239   /* If the file was opened successfully, read the schema for the new database.
 240   ** If this fails, or if opening the file failed, then close the file and
 241   ** remove the entry from the db->aDb[] array. i.e. put everything back the
 242   ** way we found it.
 243   */
 244   if( rc==SQLITE_OK ){
 245     sqlite3BtreeEnterAll(db);
 246     db->init.iDb = 0;
 247     db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
 248     if( !REOPEN_AS_MEMDB(db) ){
 249       rc = sqlite3Init(db, &zErrDyn);
 250     }
 251     sqlite3BtreeLeaveAll(db);
 252     assert( zErrDyn==0 || rc!=SQLITE_OK );
 253   }
 254 #ifdef SQLITE_USER_AUTHENTICATION
 255   if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
 256     u8 newAuth = 0;
 257     rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
 258     if( newAuth<db->auth.authLevel ){
 259       rc = SQLITE_AUTH_USER;
 260     }
 261   }
 262 #endif
 263   if( rc ){
 264     if( !REOPEN_AS_MEMDB(db) ){
 265       int iDb = db->nDb - 1;
 266       assert( iDb>=2 );
 267       if( db->aDb[iDb].pBt ){
 268         sqlite3BtreeClose(db->aDb[iDb].pBt);
 269         db->aDb[iDb].pBt = 0;
 270         db->aDb[iDb].pSchema = 0;
 271       }
 272       sqlite3ResetAllSchemasOfConnection(db);
 273       db->nDb = iDb;
 274       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
 275         sqlite3OomFault(db);
 276         sqlite3DbFree(db, zErrDyn);
 277         zErrDyn = sqlite3MPrintf(db, "out of memory");
 278       }else if( zErrDyn==0 ){
 279         zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
 280       }
 281     }
 282     goto attach_error;
 283   }
 284
 285   return;
 286
 287 attach_error:
 288   /* Return an error if we get here */
 289   if( zErrDyn ){
 290     sqlite3_result_error(context, zErrDyn, -1);
 291     sqlite3DbFree(db, zErrDyn);
 292   }
 293   if( rc ) sqlite3_result_error_code(context, rc);
 294 }
 295
 296 /*
 297 ** An SQL user-function registered to do the work of an DETACH statement. The
 298 ** three arguments to the function come directly from a detach statement:
 299 **
 300 **     DETACH DATABASE x
 301 **
 302 **     SELECT sqlite_detach(x)
 303 */
 304 static void detachFunc(
 305   sqlite3_context *context,
 306   int NotUsed,
 307   sqlite3_value **argv
 308 ){
 309   const char *zName = (const char *)sqlite3_value_text(argv[0]);
 310   sqlite3 *db = sqlite3_context_db_handle(context);
 311   int i;
 312   Db *pDb = 0;
 313   HashElem *pEntry;
 314   char zErr[128];
 315
 316   UNUSED_PARAMETER(NotUsed);
 317
 318   if( zName==0 ) zName = "";
 319   for(i=0; i<db->nDb; i++){
 320     pDb = &db->aDb[i];
 321     if( pDb->pBt==0 ) continue;
 322     if( sqlite3DbIsNamed(db, i, zName) ) break;
 323   }
 324
 325   if( i>=db->nDb ){
 326     sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
 327     goto detach_error;
 328   }
 329   if( i<2 ){
 330     sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
 331     goto detach_error;
 332   }
 333   if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
 334     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
 335     goto detach_error;
 336   }
 337
 338   /* If any TEMP triggers reference the schema being detached, move those
 339   ** triggers to reference the TEMP schema itself. */
 340   assert( db->aDb[1].pSchema );
 341   pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
 342   while( pEntry ){
 343     Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);
 344     if( pTrig->pTabSchema==pDb->pSchema ){
 345       pTrig->pTabSchema = pTrig->pSchema;
 346     }
 347     pEntry = sqliteHashNext(pEntry);
 348   }
 349
 350   sqlite3BtreeClose(pDb->pBt);
 351   pDb->pBt = 0;
 352   pDb->pSchema = 0;
 353   sqlite3CollapseDatabaseArray(db);
 354   return;
 355
 356 detach_error:
 357   sqlite3_result_error(context, zErr, -1);
 358 }
 359
 360 /*
 361 ** This procedure generates VDBE code for a single invocation of either the
 362 ** sqlite_detach() or sqlite_attach() SQL user functions.
 363 */
 364 static void codeAttach(
 365   Parse *pParse,       /* The parser context */
 366   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
 367   FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
 368   Expr *pAuthArg,      /* Expression to pass to authorization callback */
 369   Expr *pFilename,     /* Name of database file */
 370   Expr *pDbname,       /* Name of the database to use internally */
 371   Expr *pKey           /* Database key for encryption extension */
 372 ){
 373   int rc;
 374   NameContext sName;
 375   Vdbe *v;
 376   sqlite3* db = pParse->db;
 377   int regArgs;
 378
 379   if( pParse->nErr ) goto attach_end;
 380   memset(&sName, 0, sizeof(NameContext));
 381   sName.pParse = pParse;
 382
 383   if(
 384       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
 385       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
 386       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
 387   ){
 388     goto attach_end;
 389   }
 390
 391 #ifndef SQLITE_OMIT_AUTHORIZATION
 392   if( pAuthArg ){
 393     char *zAuthArg;
 394     if( pAuthArg->op==TK_STRING ){
 395       zAuthArg = pAuthArg->u.zToken;
 396     }else{
 397       zAuthArg = 0;
 398     }
 399     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
 400     if(rc!=SQLITE_OK ){
 401       goto attach_end;
 402     }
 403   }
 404 #endif /* SQLITE_OMIT_AUTHORIZATION */
 405
 406
 407   v = sqlite3GetVdbe(pParse);
 408   regArgs = sqlite3GetTempRange(pParse, 4);
 409   sqlite3ExprCode(pParse, pFilename, regArgs);
 410   sqlite3ExprCode(pParse, pDbname, regArgs+1);
 411   sqlite3ExprCode(pParse, pKey, regArgs+2);
 412
 413   assert( v || db->mallocFailed );
 414   if( v ){
 415     sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
 416                                pFunc->nArg, pFunc, 0);
 417     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
 418     ** statement only). For DETACH, set it to false (expire all existing
 419     ** statements).
 420     */
 421     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
 422   }
 423
 424 attach_end:
 425   sqlite3ExprDelete(db, pFilename);
 426   sqlite3ExprDelete(db, pDbname);
 427   sqlite3ExprDelete(db, pKey);
 428 }
 429
 430 /*
 431 ** Called by the parser to compile a DETACH statement.
 432 **
 433 **     DETACH pDbname
 434 */
 435 void sqlite3Detach(Parse *pParse, Expr *pDbname){
 436   static const FuncDef detach_func = {
 437     1,                /* nArg */
 438     SQLITE_UTF8,      /* funcFlags */
 439     0,                /* pUserData */
 440     0,                /* pNext */
 441     detachFunc,       /* xSFunc */
 442     0,                /* xFinalize */
 443     0, 0,             /* xValue, xInverse */
 444     "sqlite_detach",  /* zName */
 445     {0}
 446   };
 447   codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
 448 }
 449
 450 /*
 451 ** Called by the parser to compile an ATTACH statement.
 452 **
 453 **     ATTACH p AS pDbname KEY pKey
 454 */
 455 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
 456   static const FuncDef attach_func = {
 457     3,                /* nArg */
 458     SQLITE_UTF8,      /* funcFlags */
 459     0,                /* pUserData */
 460     0,                /* pNext */
 461     attachFunc,       /* xSFunc */
 462     0,                /* xFinalize */
 463     0, 0,             /* xValue, xInverse */
 464     "sqlite_attach",  /* zName */
 465     {0}
 466   };
 467   codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
 468 }
 469 #endif /* SQLITE_OMIT_ATTACH */
 470
 471 /*
 472 ** Initialize a DbFixer structure.  This routine must be called prior
 473 ** to passing the structure to one of the sqliteFixAAAA() routines below.
 474 */
 475 void sqlite3FixInit(
 476   DbFixer *pFix,      /* The fixer to be initialized */
 477   Parse *pParse,      /* Error messages will be written here */
 478   int iDb,            /* This is the database that must be used */
 479   const char *zType,  /* "view", "trigger", or "index" */
 480   const Token *pName  /* Name of the view, trigger, or index */
 481 ){
 482   sqlite3 *db;
 483
 484   db = pParse->db;
 485   assert( db->nDb>iDb );
 486   pFix->pParse = pParse;
 487   pFix->zDb = db->aDb[iDb].zDbSName;
 488   pFix->pSchema = db->aDb[iDb].pSchema;
 489   pFix->zType = zType;
 490   pFix->pName = pName;
 491   pFix->bTemp = (iDb==1);
 492 }
 493
 494 /*
 495 ** The following set of routines walk through the parse tree and assign
 496 ** a specific database to all table references where the database name
 497 ** was left unspecified in the original SQL statement.  The pFix structure
 498 ** must have been initialized by a prior call to sqlite3FixInit().
 499 **
 500 ** These routines are used to make sure that an index, trigger, or
 501 ** view in one database does not refer to objects in a different database.
 502 ** (Exception: indices, triggers, and views in the TEMP database are
 503 ** allowed to refer to anything.)  If a reference is explicitly made
 504 ** to an object in a different database, an error message is added to
 505 ** pParse->zErrMsg and these routines return non-zero.  If everything
 506 ** checks out, these routines return 0.
 507 */
 508 int sqlite3FixSrcList(
 509   DbFixer *pFix,       /* Context of the fixation */
 510   SrcList *pList       /* The Source list to check and modify */
 511 ){
 512   int i;
 513   struct SrcList_item *pItem;
 514   sqlite3 *db = pFix->pParse->db;
 515   int iDb = sqlite3FindDbName(db, pFix->zDb);
 516
 517   if( NEVER(pList==0) ) return 0;
 518
 519   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
 520     if( pFix->bTemp==0 ){
 521       if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
 522         sqlite3ErrorMsg(pFix->pParse,
 523             "%s %T cannot reference objects in database %s",
 524             pFix->zType, pFix->pName, pItem->zDatabase);
 525         return 1;
 526       }
 527       sqlite3DbFree(db, pItem->zDatabase);
 528       pItem->zDatabase = 0;
 529       pItem->pSchema = pFix->pSchema;
 530       pItem->fg.fromDDL = 1;
 531     }
 532 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 533     if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
 534     if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
 535 #endif
 536     if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){
 537       return 1;
 538     }
 539   }
 540   return 0;
 541 }
 542 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 543 int sqlite3FixSelect(
 544   DbFixer *pFix,       /* Context of the fixation */
 545   Select *pSelect      /* The SELECT statement to be fixed to one database */
 546 ){
 547   while( pSelect ){
 548     if( sqlite3FixExprList(pFix, pSelect->pEList) ){
 549       return 1;
 550     }
 551     if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
 552       return 1;
 553     }
 554     if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
 555       return 1;
 556     }
 557     if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
 558       return 1;
 559     }
 560     if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
 561       return 1;
 562     }
 563     if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
 564       return 1;
 565     }
 566     if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
 567       return 1;
 568     }
 569     if( pSelect->pWith ){
 570       int i;
 571       for(i=0; i<pSelect->pWith->nCte; i++){
 572         if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
 573           return 1;
 574         }
 575       }
 576     }
 577     pSelect = pSelect->pPrior;
 578   }
 579   return 0;
 580 }
 581 int sqlite3FixExpr(
 582   DbFixer *pFix,     /* Context of the fixation */
 583   Expr *pExpr        /* The expression to be fixed to one database */
 584 ){
 585   while( pExpr ){
 586     if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
 587     if( pExpr->op==TK_VARIABLE ){
 588       if( pFix->pParse->db->init.busy ){
 589         pExpr->op = TK_NULL;
 590       }else{
 591         sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
 592         return 1;
 593       }
 594     }
 595     if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
 596     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
 597       if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
 598     }else{
 599       if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
 600     }
 601     if( sqlite3FixExpr(pFix, pExpr->pRight) ){
 602       return 1;
 603     }
 604     pExpr = pExpr->pLeft;
 605   }
 606   return 0;
 607 }
 608 int sqlite3FixExprList(
 609   DbFixer *pFix,     /* Context of the fixation */
 610   ExprList *pList    /* The expression to be fixed to one database */
 611 ){
 612   int i;
 613   struct ExprList_item *pItem;
 614   if( pList==0 ) return 0;
 615   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
 616     if( sqlite3FixExpr(pFix, pItem->pExpr) ){
 617       return 1;
 618     }
 619   }
 620   return 0;
 621 }
 622 #endif
 623
 624 #ifndef SQLITE_OMIT_TRIGGER
 625 int sqlite3FixTriggerStep(
 626   DbFixer *pFix,     /* Context of the fixation */
 627   TriggerStep *pStep /* The trigger step be fixed to one database */
 628 ){
 629   while( pStep ){
 630     if( sqlite3FixSelect(pFix, pStep->pSelect) ){
 631       return 1;
 632     }
 633     if( sqlite3FixExpr(pFix, pStep->pWhere) ){
 634       return 1;
 635     }
 636     if( sqlite3FixExprList(pFix, pStep->pExprList) ){
 637       return 1;
 638     }
 639     if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){
 640       return 1;
 641     }
 642 #ifndef SQLITE_OMIT_UPSERT
 643     if( pStep->pUpsert ){
 644       Upsert *pUp = pStep->pUpsert;
 645       if( sqlite3FixExprList(pFix, pUp->pUpsertTarget)
 646        || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere)
 647        || sqlite3FixExprList(pFix, pUp->pUpsertSet)
 648        || sqlite3FixExpr(pFix, pUp->pUpsertWhere)
 649       ){
 650         return 1;
 651       }
 652     }
 653 #endif
 654     pStep = pStep->pNext;
 655   }
 656   return 0;
 657 }
 658 #endif