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