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