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 #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     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 sqlcipherCodecAttach(sqlite3*, int, const void*, int);
 205     extern void sqlcipherCodecGetKey(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 = sqlcipherCodecAttach(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           sqlcipherCodecGetKey(db, 0, (void**)&zKey, &nKey);
 228           if( nKey || sqlite3BtreeGetRequestedReserve(db->aDb[0].pBt)>0 ){
 229             rc = sqlcipherCodecAttach(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( sqlite3BtreeTxnState(pDb->pBt)!=SQLITE_TXN_NONE
 334    || sqlite3BtreeIsInBackup(pDb->pBt)
 335   ){
 336     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
 337     goto detach_error;
 338   }
 339
 340   /* If any TEMP triggers reference the schema being detached, move those
 341   ** triggers to reference the TEMP schema itself. */
 342   assert( db->aDb[1].pSchema );
 343   pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
 344   while( pEntry ){
 345     Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);
 346     if( pTrig->pTabSchema==pDb->pSchema ){
 347       pTrig->pTabSchema = pTrig->pSchema;
 348     }
 349     pEntry = sqliteHashNext(pEntry);
 350   }
 351
 352   sqlite3BtreeClose(pDb->pBt);
 353   pDb->pBt = 0;
 354   pDb->pSchema = 0;
 355   sqlite3CollapseDatabaseArray(db);
 356   return;
 357
 358 detach_error:
 359   sqlite3_result_error(context, zErr, -1);
 360 }
 361
 362 /*
 363 ** This procedure generates VDBE code for a single invocation of either the
 364 ** sqlite_detach() or sqlite_attach() SQL user functions.
 365 */
 366 static void codeAttach(
 367   Parse *pParse,       /* The parser context */
 368   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
 369   FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
 370   Expr *pAuthArg,      /* Expression to pass to authorization callback */
 371   Expr *pFilename,     /* Name of database file */
 372   Expr *pDbname,       /* Name of the database to use internally */
 373   Expr *pKey           /* Database key for encryption extension */
 374 ){
 375   int rc;
 376   NameContext sName;
 377   Vdbe *v;
 378   sqlite3* db = pParse->db;
 379   int regArgs;
 380
 381   if( pParse->nErr ) goto attach_end;
 382   memset(&sName, 0, sizeof(NameContext));
 383   sName.pParse = pParse;
 384
 385   if(
 386       SQLITE_OK!=resolveAttachExpr(&sName, pFilename) ||
 387       SQLITE_OK!=resolveAttachExpr(&sName, pDbname) ||
 388       SQLITE_OK!=resolveAttachExpr(&sName, pKey)
 389   ){
 390     goto attach_end;
 391   }
 392
 393 #ifndef SQLITE_OMIT_AUTHORIZATION
 394   if( ALWAYS(pAuthArg) ){
 395     char *zAuthArg;
 396     if( pAuthArg->op==TK_STRING ){
 397       assert( !ExprHasProperty(pAuthArg, EP_IntValue) );
 398       zAuthArg = pAuthArg->u.zToken;
 399     }else{
 400       zAuthArg = 0;
 401     }
 402     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
 403     if(rc!=SQLITE_OK ){
 404       goto attach_end;
 405     }
 406   }
 407 #endif /* SQLITE_OMIT_AUTHORIZATION */
 408
 409
 410   v = sqlite3GetVdbe(pParse);
 411   regArgs = sqlite3GetTempRange(pParse, 4);
 412   sqlite3ExprCode(pParse, pFilename, regArgs);
 413   sqlite3ExprCode(pParse, pDbname, regArgs+1);
 414   sqlite3ExprCode(pParse, pKey, regArgs+2);
 415
 416   assert( v || db->mallocFailed );
 417   if( v ){
 418     sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
 419                                pFunc->nArg, pFunc, 0);
 420     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
 421     ** statement only). For DETACH, set it to false (expire all existing
 422     ** statements).
 423     */
 424     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
 425   }
 426
 427 attach_end:
 428   sqlite3ExprDelete(db, pFilename);
 429   sqlite3ExprDelete(db, pDbname);
 430   sqlite3ExprDelete(db, pKey);
 431 }
 432
 433 /*
 434 ** Called by the parser to compile a DETACH statement.
 435 **
 436 **     DETACH pDbname
 437 */
 438 void sqlite3Detach(Parse *pParse, Expr *pDbname){
 439   static const FuncDef detach_func = {
 440     1,                /* nArg */
 441     SQLITE_UTF8,      /* funcFlags */
 442     0,                /* pUserData */
 443     0,                /* pNext */
 444     detachFunc,       /* xSFunc */
 445     0,                /* xFinalize */
 446     0, 0,             /* xValue, xInverse */
 447     "sqlite_detach",  /* zName */
 448     {0}
 449   };
 450   codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
 451 }
 452
 453 /*
 454 ** Called by the parser to compile an ATTACH statement.
 455 **
 456 **     ATTACH p AS pDbname KEY pKey
 457 */
 458 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
 459   static const FuncDef attach_func = {
 460     3,                /* nArg */
 461     SQLITE_UTF8,      /* funcFlags */
 462     0,                /* pUserData */
 463     0,                /* pNext */
 464     attachFunc,       /* xSFunc */
 465     0,                /* xFinalize */
 466     0, 0,             /* xValue, xInverse */
 467     "sqlite_attach",  /* zName */
 468     {0}
 469   };
 470   codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
 471 }
 472 #endif /* SQLITE_OMIT_ATTACH */
 473
 474 /*
 475 ** Expression callback used by sqlite3FixAAAA() routines.
 476 */
 477 static int fixExprCb(Walker *p, Expr *pExpr){
 478   DbFixer *pFix = p->u.pFix;
 479   if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
 480   if( pExpr->op==TK_VARIABLE ){
 481     if( pFix->pParse->db->init.busy ){
 482       pExpr->op = TK_NULL;
 483     }else{
 484       sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
 485       return WRC_Abort;
 486     }
 487   }
 488   return WRC_Continue;
 489 }
 490
 491 /*
 492 ** Select callback used by sqlite3FixAAAA() routines.
 493 */
 494 static int fixSelectCb(Walker *p, Select *pSelect){
 495   DbFixer *pFix = p->u.pFix;
 496   int i;
 497   SrcItem *pItem;
 498   sqlite3 *db = pFix->pParse->db;
 499   int iDb = sqlite3FindDbName(db, pFix->zDb);
 500   SrcList *pList = pSelect->pSrc;
 501
 502   if( NEVER(pList==0) ) return WRC_Continue;
 503   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
 504     if( pFix->bTemp==0 ){
 505       if( pItem->zDatabase ){
 506         if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
 507           sqlite3ErrorMsg(pFix->pParse,
 508               "%s %T cannot reference objects in database %s",
 509               pFix->zType, pFix->pName, pItem->zDatabase);
 510           return WRC_Abort;
 511         }
 512         sqlite3DbFree(db, pItem->zDatabase);
 513         pItem->zDatabase = 0;
 514         pItem->fg.notCte = 1;
 515       }
 516       pItem->pSchema = pFix->pSchema;
 517       pItem->fg.fromDDL = 1;
 518     }
 519 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 520     if( pList->a[i].fg.isUsing==0
 521      && sqlite3WalkExpr(&pFix->w, pList->a[i].u3.pOn)
 522     ){
 523       return WRC_Abort;
 524     }
 525 #endif
 526   }
 527   if( pSelect->pWith ){
 528     for(i=0; i<pSelect->pWith->nCte; i++){
 529       if( sqlite3WalkSelect(p, pSelect->pWith->a[i].pSelect) ){
 530         return WRC_Abort;
 531       }
 532     }
 533   }
 534   return WRC_Continue;
 535 }
 536
 537 /*
 538 ** Initialize a DbFixer structure.  This routine must be called prior
 539 ** to passing the structure to one of the sqliteFixAAAA() routines below.
 540 */
 541 void sqlite3FixInit(
 542   DbFixer *pFix,      /* The fixer to be initialized */
 543   Parse *pParse,      /* Error messages will be written here */
 544   int iDb,            /* This is the database that must be used */
 545   const char *zType,  /* "view", "trigger", or "index" */
 546   const Token *pName  /* Name of the view, trigger, or index */
 547 ){
 548   sqlite3 *db = pParse->db;
 549   assert( db->nDb>iDb );
 550   pFix->pParse = pParse;
 551   pFix->zDb = db->aDb[iDb].zDbSName;
 552   pFix->pSchema = db->aDb[iDb].pSchema;
 553   pFix->zType = zType;
 554   pFix->pName = pName;
 555   pFix->bTemp = (iDb==1);
 556   pFix->w.pParse = pParse;
 557   pFix->w.xExprCallback = fixExprCb;
 558   pFix->w.xSelectCallback = fixSelectCb;
 559   pFix->w.xSelectCallback2 = sqlite3WalkWinDefnDummyCallback;
 560   pFix->w.walkerDepth = 0;
 561   pFix->w.eCode = 0;
 562   pFix->w.u.pFix = pFix;
 563 }
 564
 565 /*
 566 ** The following set of routines walk through the parse tree and assign
 567 ** a specific database to all table references where the database name
 568 ** was left unspecified in the original SQL statement.  The pFix structure
 569 ** must have been initialized by a prior call to sqlite3FixInit().
 570 **
 571 ** These routines are used to make sure that an index, trigger, or
 572 ** view in one database does not refer to objects in a different database.
 573 ** (Exception: indices, triggers, and views in the TEMP database are
 574 ** allowed to refer to anything.)  If a reference is explicitly made
 575 ** to an object in a different database, an error message is added to
 576 ** pParse->zErrMsg and these routines return non-zero.  If everything
 577 ** checks out, these routines return 0.
 578 */
 579 int sqlite3FixSrcList(
 580   DbFixer *pFix,       /* Context of the fixation */
 581   SrcList *pList       /* The Source list to check and modify */
 582 ){
 583   int res = 0;
 584   if( pList ){
 585     Select s;
 586     memset(&s, 0, sizeof(s));
 587     s.pSrc = pList;
 588     res = sqlite3WalkSelect(&pFix->w, &s);
 589   }
 590   return res;
 591 }
 592 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 593 int sqlite3FixSelect(
 594   DbFixer *pFix,       /* Context of the fixation */
 595   Select *pSelect      /* The SELECT statement to be fixed to one database */
 596 ){
 597   return sqlite3WalkSelect(&pFix->w, pSelect);
 598 }
 599 int sqlite3FixExpr(
 600   DbFixer *pFix,     /* Context of the fixation */
 601   Expr *pExpr        /* The expression to be fixed to one database */
 602 ){
 603   return sqlite3WalkExpr(&pFix->w, pExpr);
 604 }
 605 #endif
 606
 607 #ifndef SQLITE_OMIT_TRIGGER
 608 int sqlite3FixTriggerStep(
 609   DbFixer *pFix,     /* Context of the fixation */
 610   TriggerStep *pStep /* The trigger step be fixed to one database */
 611 ){
 612   while( pStep ){
 613     if( sqlite3WalkSelect(&pFix->w, pStep->pSelect)
 614      || sqlite3WalkExpr(&pFix->w, pStep->pWhere)
 615      || sqlite3WalkExprList(&pFix->w, pStep->pExprList)
 616      || sqlite3FixSrcList(pFix, pStep->pFrom)
 617     ){
 618       return 1;
 619     }
 620 #ifndef SQLITE_OMIT_UPSERT
 621     {
 622       Upsert *pUp;
 623       for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){
 624         if( sqlite3WalkExprList(&pFix->w, pUp->pUpsertTarget)
 625          || sqlite3WalkExpr(&pFix->w, pUp->pUpsertTargetWhere)
 626          || sqlite3WalkExprList(&pFix->w, pUp->pUpsertSet)
 627          || sqlite3WalkExpr(&pFix->w, pUp->pUpsertWhere)
 628         ){
 629           return 1;
 630         }
 631       }
 632     }
 633 #endif
 634     pStep = pStep->pNext;
 635   }
 636
 637   return 0;
 638 }
 639 #endif