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   sqlite3_free_filename( zPath );
 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
 205   ** way we found it.
 206   */
 207   if( rc==SQLITE_OK ){
 208     sqlite3BtreeEnterAll(db);
 209     db->init.iDb = 0;
 210     db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
 211     if( !REOPEN_AS_MEMDB(db) ){
 212       rc = sqlite3Init(db, &zErrDyn);
 213     }
 214     sqlite3BtreeLeaveAll(db);
 215     assert( zErrDyn==0 || rc!=SQLITE_OK );
 216   }
 217 #ifdef SQLITE_USER_AUTHENTICATION
 218   if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
 219     u8 newAuth = 0;
 220     rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
 221     if( newAuth<db->auth.authLevel ){
 222       rc = SQLITE_AUTH_USER;
 223     }
 224   }
 225 #endif
 226   if( rc ){
 227     if( !REOPEN_AS_MEMDB(db) ){
 228       int iDb = db->nDb - 1;
 229       assert( iDb>=2 );
 230       if( db->aDb[iDb].pBt ){
 231         sqlite3BtreeClose(db->aDb[iDb].pBt);
 232         db->aDb[iDb].pBt = 0;
 233         db->aDb[iDb].pSchema = 0;
 234       }
 235       sqlite3ResetAllSchemasOfConnection(db);
 236       db->nDb = iDb;
 237       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
 238         sqlite3OomFault(db);
 239         sqlite3DbFree(db, zErrDyn);
 240         zErrDyn = sqlite3MPrintf(db, "out of memory");
 241       }else if( zErrDyn==0 ){
 242         zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
 243       }
 244     }
 245     goto attach_error;
 246   }
 247
 248   return;
 249
 250 attach_error:
 251   /* Return an error if we get here */
 252   if( zErrDyn ){
 253     sqlite3_result_error(context, zErrDyn, -1);
 254     sqlite3DbFree(db, zErrDyn);
 255   }
 256   if( rc ) sqlite3_result_error_code(context, rc);
 257 }
 258
 259 /*
 260 ** An SQL user-function registered to do the work of an DETACH statement. The
 261 ** three arguments to the function come directly from a detach statement:
 262 **
 263 **     DETACH DATABASE x
 264 **
 265 **     SELECT sqlite_detach(x)
 266 */
 267 static void detachFunc(
 268   sqlite3_context *context,
 269   int NotUsed,
 270   sqlite3_value **argv
 271 ){
 272   const char *zName = (const char *)sqlite3_value_text(argv[0]);
 273   sqlite3 *db = sqlite3_context_db_handle(context);
 274   int i;
 275   Db *pDb = 0;
 276   HashElem *pEntry;
 277   char zErr[128];
 278
 279   UNUSED_PARAMETER(NotUsed);
 280
 281   if( zName==0 ) zName = "";
 282   for(i=0; i<db->nDb; i++){
 283     pDb = &db->aDb[i];
 284     if( pDb->pBt==0 ) continue;
 285     if( sqlite3DbIsNamed(db, i, zName) ) break;
 286   }
 287
 288   if( i>=db->nDb ){
 289     sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
 290     goto detach_error;
 291   }
 292   if( i<2 ){
 293     sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
 294     goto detach_error;
 295   }
 296   if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
 297     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
 298     goto detach_error;
 299   }
 300
 301   /* If any TEMP triggers reference the schema being detached, move those
 302   ** triggers to reference the TEMP schema itself. */
 303   assert( db->aDb[1].pSchema );
 304   pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
 305   while( pEntry ){
 306     Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);
 307     if( pTrig->pTabSchema==pDb->pSchema ){
 308       pTrig->pTabSchema = pTrig->pSchema;
 309     }
 310     pEntry = sqliteHashNext(pEntry);
 311   }
 312
 313   sqlite3BtreeClose(pDb->pBt);
 314   pDb->pBt = 0;
 315   pDb->pSchema = 0;
 316   sqlite3CollapseDatabaseArray(db);
 317   return;
 318
 319 detach_error:
 320   sqlite3_result_error(context, zErr, -1);
 321 }
 322
 323 /*
 324 ** This procedure generates VDBE code for a single invocation of either the
 325 ** sqlite_detach() or sqlite_attach() SQL user functions.
 326 */
 327 static void codeAttach(
 328   Parse *pParse,       /* The parser context */
 329   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
 330   FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
 331   Expr *pAuthArg,      /* Expression to pass to authorization callback */
 332   Expr *pFilename,     /* Name of database file */
 333   Expr *pDbname,       /* Name of the database to use internally */
 334   Expr *pKey           /* Database key for encryption extension */
 335 ){
 336   int rc;
 337   NameContext sName;
 338   Vdbe *v;
 339   sqlite3* db = pParse->db;
 340   int regArgs;
 341
 342   if( pParse->nErr ) goto attach_end;
 343   memset(&sName, 0, sizeof(NameContext));
 344   sName.pParse = pParse;
 345
 346   if(
 347       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
 348       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
 349       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
 350   ){
 351     goto attach_end;
 352   }
 353
 354 #ifndef SQLITE_OMIT_AUTHORIZATION
 355   if( pAuthArg ){
 356     char *zAuthArg;
 357     if( pAuthArg->op==TK_STRING ){
 358       zAuthArg = pAuthArg->u.zToken;
 359     }else{
 360       zAuthArg = 0;
 361     }
 362     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
 363     if(rc!=SQLITE_OK ){
 364       goto attach_end;
 365     }
 366   }
 367 #endif /* SQLITE_OMIT_AUTHORIZATION */
 368
 369
 370   v = sqlite3GetVdbe(pParse);
 371   regArgs = sqlite3GetTempRange(pParse, 4);
 372   sqlite3ExprCode(pParse, pFilename, regArgs);
 373   sqlite3ExprCode(pParse, pDbname, regArgs+1);
 374   sqlite3ExprCode(pParse, pKey, regArgs+2);
 375
 376   assert( v || db->mallocFailed );
 377   if( v ){
 378     sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
 379                                pFunc->nArg, pFunc, 0);
 380     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
 381     ** statement only). For DETACH, set it to false (expire all existing
 382     ** statements).
 383     */
 384     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
 385   }
 386
 387 attach_end:
 388   sqlite3ExprDelete(db, pFilename);
 389   sqlite3ExprDelete(db, pDbname);
 390   sqlite3ExprDelete(db, pKey);
 391 }
 392
 393 /*
 394 ** Called by the parser to compile a DETACH statement.
 395 **
 396 **     DETACH pDbname
 397 */
 398 void sqlite3Detach(Parse *pParse, Expr *pDbname){
 399   static const FuncDef detach_func = {
 400     1,                /* nArg */
 401     SQLITE_UTF8,      /* funcFlags */
 402     0,                /* pUserData */
 403     0,                /* pNext */
 404     detachFunc,       /* xSFunc */
 405     0,                /* xFinalize */
 406     0, 0,             /* xValue, xInverse */
 407     "sqlite_detach",  /* zName */
 408     {0}
 409   };
 410   codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
 411 }
 412
 413 /*
 414 ** Called by the parser to compile an ATTACH statement.
 415 **
 416 **     ATTACH p AS pDbname KEY pKey
 417 */
 418 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
 419   static const FuncDef attach_func = {
 420     3,                /* nArg */
 421     SQLITE_UTF8,      /* funcFlags */
 422     0,                /* pUserData */
 423     0,                /* pNext */
 424     attachFunc,       /* xSFunc */
 425     0,                /* xFinalize */
 426     0, 0,             /* xValue, xInverse */
 427     "sqlite_attach",  /* zName */
 428     {0}
 429   };
 430   codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
 431 }
 432 #endif /* SQLITE_OMIT_ATTACH */
 433
 434 /*
 435 ** Initialize a DbFixer structure.  This routine must be called prior
 436 ** to passing the structure to one of the sqliteFixAAAA() routines below.
 437 */
 438 void sqlite3FixInit(
 439   DbFixer *pFix,      /* The fixer to be initialized */
 440   Parse *pParse,      /* Error messages will be written here */
 441   int iDb,            /* This is the database that must be used */
 442   const char *zType,  /* "view", "trigger", or "index" */
 443   const Token *pName  /* Name of the view, trigger, or index */
 444 ){
 445   sqlite3 *db;
 446
 447   db = pParse->db;
 448   assert( db->nDb>iDb );
 449   pFix->pParse = pParse;
 450   pFix->zDb = db->aDb[iDb].zDbSName;
 451   pFix->pSchema = db->aDb[iDb].pSchema;
 452   pFix->zType = zType;
 453   pFix->pName = pName;
 454   pFix->bTemp = (iDb==1);
 455 }
 456
 457 /*
 458 ** The following set of routines walk through the parse tree and assign
 459 ** a specific database to all table references where the database name
 460 ** was left unspecified in the original SQL statement.  The pFix structure
 461 ** must have been initialized by a prior call to sqlite3FixInit().
 462 **
 463 ** These routines are used to make sure that an index, trigger, or
 464 ** view in one database does not refer to objects in a different database.
 465 ** (Exception: indices, triggers, and views in the TEMP database are
 466 ** allowed to refer to anything.)  If a reference is explicitly made
 467 ** to an object in a different database, an error message is added to
 468 ** pParse->zErrMsg and these routines return non-zero.  If everything
 469 ** checks out, these routines return 0.
 470 */
 471 int sqlite3FixSrcList(
 472   DbFixer *pFix,       /* Context of the fixation */
 473   SrcList *pList       /* The Source list to check and modify */
 474 ){
 475   int i;
 476   struct SrcList_item *pItem;
 477   sqlite3 *db = pFix->pParse->db;
 478   int iDb = sqlite3FindDbName(db, pFix->zDb);
 479
 480   if( NEVER(pList==0) ) return 0;
 481
 482   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
 483     if( pFix->bTemp==0 ){
 484       if( pItem->zDatabase && 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 1;
 489       }
 490       sqlite3DbFree(db, pItem->zDatabase);
 491       pItem->zDatabase = 0;
 492       pItem->pSchema = pFix->pSchema;
 493       pItem->fg.fromDDL = 1;
 494     }
 495 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 496     if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
 497     if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
 498 #endif
 499     if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){
 500       return 1;
 501     }
 502   }
 503   return 0;
 504 }
 505 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 506 int sqlite3FixSelect(
 507   DbFixer *pFix,       /* Context of the fixation */
 508   Select *pSelect      /* The SELECT statement to be fixed to one database */
 509 ){
 510   while( pSelect ){
 511     if( sqlite3FixExprList(pFix, pSelect->pEList) ){
 512       return 1;
 513     }
 514     if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
 515       return 1;
 516     }
 517     if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
 518       return 1;
 519     }
 520     if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
 521       return 1;
 522     }
 523     if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
 524       return 1;
 525     }
 526     if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
 527       return 1;
 528     }
 529     if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
 530       return 1;
 531     }
 532     if( pSelect->pWith ){
 533       int i;
 534       for(i=0; i<pSelect->pWith->nCte; i++){
 535         if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
 536           return 1;
 537         }
 538       }
 539     }
 540     pSelect = pSelect->pPrior;
 541   }
 542   return 0;
 543 }
 544 int sqlite3FixExpr(
 545   DbFixer *pFix,     /* Context of the fixation */
 546   Expr *pExpr        /* The expression to be fixed to one database */
 547 ){
 548   while( pExpr ){
 549     if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
 550     if( pExpr->op==TK_VARIABLE ){
 551       if( pFix->pParse->db->init.busy ){
 552         pExpr->op = TK_NULL;
 553       }else{
 554         sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
 555         return 1;
 556       }
 557     }
 558     if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
 559     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
 560       if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
 561     }else{
 562       if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
 563     }
 564     if( sqlite3FixExpr(pFix, pExpr->pRight) ){
 565       return 1;
 566     }
 567     pExpr = pExpr->pLeft;
 568   }
 569   return 0;
 570 }
 571 int sqlite3FixExprList(
 572   DbFixer *pFix,     /* Context of the fixation */
 573   ExprList *pList    /* The expression to be fixed to one database */
 574 ){
 575   int i;
 576   struct ExprList_item *pItem;
 577   if( pList==0 ) return 0;
 578   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
 579     if( sqlite3FixExpr(pFix, pItem->pExpr) ){
 580       return 1;
 581     }
 582   }
 583   return 0;
 584 }
 585 #endif
 586
 587 #ifndef SQLITE_OMIT_TRIGGER
 588 int sqlite3FixTriggerStep(
 589   DbFixer *pFix,     /* Context of the fixation */
 590   TriggerStep *pStep /* The trigger step be fixed to one database */
 591 ){
 592   while( pStep ){
 593     if( sqlite3FixSelect(pFix, pStep->pSelect) ){
 594       return 1;
 595     }
 596     if( sqlite3FixExpr(pFix, pStep->pWhere) ){
 597       return 1;
 598     }
 599     if( sqlite3FixExprList(pFix, pStep->pExprList) ){
 600       return 1;
 601     }
 602 #ifndef SQLITE_OMIT_UPSERT
 603     if( pStep->pUpsert ){
 604       Upsert *pUp = pStep->pUpsert;
 605       if( sqlite3FixExprList(pFix, pUp->pUpsertTarget)
 606        || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere)
 607        || sqlite3FixExprList(pFix, pUp->pUpsertSet)
 608        || sqlite3FixExpr(pFix, pUp->pUpsertWhere)
 609       ){
 610         return 1;
 611       }
 612     }
 613 #endif
 614     pStep = pStep->pNext;
 615   }
 616   return 0;
 617 }
 618 #endif