sl@0: /*
sl@0: ** 2003 April 6
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains code used to implement the ATTACH and DETACH commands.
sl@0: **
sl@0: ** $Id: attach.c,v 1.78 2008/08/20 16:35:10 drh Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: 
sl@0: #ifndef SQLITE_OMIT_ATTACH
sl@0: /*
sl@0: ** Resolve an expression that was part of an ATTACH or DETACH statement. This
sl@0: ** is slightly different from resolving a normal SQL expression, because simple
sl@0: ** identifiers are treated as strings, not possible column names or aliases.
sl@0: **
sl@0: ** i.e. if the parser sees:
sl@0: **
sl@0: **     ATTACH DATABASE abc AS def
sl@0: **
sl@0: ** it treats the two expressions as literal strings 'abc' and 'def' instead of
sl@0: ** looking for columns of the same name.
sl@0: **
sl@0: ** This only applies to the root node of pExpr, so the statement:
sl@0: **
sl@0: **     ATTACH DATABASE abc||def AS 'db2'
sl@0: **
sl@0: ** will fail because neither abc or def can be resolved.
sl@0: */
sl@0: static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
sl@0: {
sl@0:   int rc = SQLITE_OK;
sl@0:   if( pExpr ){
sl@0:     if( pExpr->op!=TK_ID ){
sl@0:       rc = sqlite3ResolveExprNames(pName, pExpr);
sl@0:       if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
sl@0:         sqlite3ErrorMsg(pName->pParse, "invalid name: \"%T\"", &pExpr->span);
sl@0:         return SQLITE_ERROR;
sl@0:       }
sl@0:     }else{
sl@0:       pExpr->op = TK_STRING;
sl@0:     }
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** An SQL user-function registered to do the work of an ATTACH statement. The
sl@0: ** three arguments to the function come directly from an attach statement:
sl@0: **
sl@0: **     ATTACH DATABASE x AS y KEY z
sl@0: **
sl@0: **     SELECT sqlite_attach(x, y, z)
sl@0: **
sl@0: ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
sl@0: ** third argument.
sl@0: */
sl@0: static void attachFunc(
sl@0:   sqlite3_context *context,
sl@0:   int argc,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   int i;
sl@0:   int rc = 0;
sl@0:   sqlite3 *db = sqlite3_context_db_handle(context);
sl@0:   const char *zName;
sl@0:   const char *zFile;
sl@0:   Db *aNew;
sl@0:   char *zErrDyn = 0;
sl@0:   char zErr[128];
sl@0: 
sl@0:   zFile = (const char *)sqlite3_value_text(argv[0]);
sl@0:   zName = (const char *)sqlite3_value_text(argv[1]);
sl@0:   if( zFile==0 ) zFile = "";
sl@0:   if( zName==0 ) zName = "";
sl@0: 
sl@0:   /* Check for the following errors:
sl@0:   **
sl@0:   **     * Too many attached databases,
sl@0:   **     * Transaction currently open
sl@0:   **     * Specified database name already being used.
sl@0:   */
sl@0:   if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
sl@0:     sqlite3_snprintf(
sl@0:       sizeof(zErr), zErr, "too many attached databases - max %d", 
sl@0:       db->aLimit[SQLITE_LIMIT_ATTACHED]
sl@0:     );
sl@0:     goto attach_error;
sl@0:   }
sl@0:   if( !db->autoCommit ){
sl@0:     sqlite3_snprintf(sizeof(zErr), zErr,
sl@0:                      "cannot ATTACH database within transaction");
sl@0:     goto attach_error;
sl@0:   }
sl@0:   for(i=0; i<db->nDb; i++){
sl@0:     char *z = db->aDb[i].zName;
sl@0:     if( z && zName && sqlite3StrICmp(z, zName)==0 ){
sl@0:       sqlite3_snprintf(sizeof(zErr), zErr, 
sl@0:                        "database %s is already in use", zName);
sl@0:       goto attach_error;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Allocate the new entry in the db->aDb[] array and initialise the schema
sl@0:   ** hash tables.
sl@0:   */
sl@0:   if( db->aDb==db->aDbStatic ){
sl@0:     aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
sl@0:     if( aNew==0 ) return;
sl@0:     memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
sl@0:   }else{
sl@0:     aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
sl@0:     if( aNew==0 ) return;
sl@0:   }
sl@0:   db->aDb = aNew;
sl@0:   aNew = &db->aDb[db->nDb++];
sl@0:   memset(aNew, 0, sizeof(*aNew));
sl@0: 
sl@0:   /* Open the database file. If the btree is successfully opened, use
sl@0:   ** it to obtain the database schema. At this point the schema may
sl@0:   ** or may not be initialised.
sl@0:   */
sl@0:   rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE,
sl@0:                            db->openFlags | SQLITE_OPEN_MAIN_DB,
sl@0:                            &aNew->pBt);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     Pager *pPager;
sl@0:     aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
sl@0:     if( !aNew->pSchema ){
sl@0:       rc = SQLITE_NOMEM;
sl@0:     }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
sl@0:       sqlite3_snprintf(sizeof(zErr), zErr, 
sl@0:         "attached databases must use the same text encoding as main database");
sl@0:       goto attach_error;
sl@0:     }
sl@0:     pPager = sqlite3BtreePager(aNew->pBt);
sl@0:     sqlite3PagerLockingMode(pPager, db->dfltLockMode);
sl@0:     sqlite3PagerJournalMode(pPager, db->dfltJournalMode);
sl@0:   }
sl@0:   aNew->safety_level = 3;
sl@0:   aNew->zName = sqlite3DbStrDup(db, zName);
sl@0:   if( rc==SQLITE_OK && aNew->zName==0 ){
sl@0:     rc = SQLITE_NOMEM;
sl@0:   }
sl@0: 
sl@0: #if SQLITE_HAS_CODEC
sl@0:   {
sl@0:     extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
sl@0:     extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
sl@0:     int nKey;
sl@0:     char *zKey;
sl@0:     int t = sqlite3_value_type(argv[2]);
sl@0:     switch( t ){
sl@0:       case SQLITE_INTEGER:
sl@0:       case SQLITE_FLOAT:
sl@0:         zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
sl@0:         rc = SQLITE_ERROR;
sl@0:         break;
sl@0:         
sl@0:       case SQLITE_TEXT:
sl@0:       case SQLITE_BLOB:
sl@0:         nKey = sqlite3_value_bytes(argv[2]);
sl@0:         zKey = (char *)sqlite3_value_blob(argv[2]);
sl@0:         sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
sl@0:         break;
sl@0: 
sl@0:       case SQLITE_NULL:
sl@0:         /* No key specified.  Use the key from the main database */
sl@0:         sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
sl@0:         sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
sl@0:         break;
sl@0:     }
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* If the file was opened successfully, read the schema for the new database.
sl@0:   ** If this fails, or if opening the file failed, then close the file and 
sl@0:   ** remove the entry from the db->aDb[] array. i.e. put everything back the way
sl@0:   ** we found it.
sl@0:   */
sl@0:   if( rc==SQLITE_OK ){
sl@0:     (void)sqlite3SafetyOn(db);
sl@0:     sqlite3BtreeEnterAll(db);
sl@0:     rc = sqlite3Init(db, &zErrDyn);
sl@0:     sqlite3BtreeLeaveAll(db);
sl@0:     (void)sqlite3SafetyOff(db);
sl@0:   }
sl@0:   if( rc ){
sl@0:     int iDb = db->nDb - 1;
sl@0:     assert( iDb>=2 );
sl@0:     if( db->aDb[iDb].pBt ){
sl@0:       sqlite3BtreeClose(db->aDb[iDb].pBt);
sl@0:       db->aDb[iDb].pBt = 0;
sl@0:       db->aDb[iDb].pSchema = 0;
sl@0:     }
sl@0:     sqlite3ResetInternalSchema(db, 0);
sl@0:     db->nDb = iDb;
sl@0:     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
sl@0:       db->mallocFailed = 1;
sl@0:       sqlite3_snprintf(sizeof(zErr),zErr, "out of memory");
sl@0:     }else{
sl@0:       sqlite3_snprintf(sizeof(zErr),zErr, "unable to open database: %s", zFile);
sl@0:     }
sl@0:     goto attach_error;
sl@0:   }
sl@0:   
sl@0:   return;
sl@0: 
sl@0: attach_error:
sl@0:   /* Return an error if we get here */
sl@0:   if( zErrDyn ){
sl@0:     sqlite3_result_error(context, zErrDyn, -1);
sl@0:     sqlite3DbFree(db, zErrDyn);
sl@0:   }else{
sl@0:     zErr[sizeof(zErr)-1] = 0;
sl@0:     sqlite3_result_error(context, zErr, -1);
sl@0:   }
sl@0:   if( rc ) sqlite3_result_error_code(context, rc);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** An SQL user-function registered to do the work of an DETACH statement. The
sl@0: ** three arguments to the function come directly from a detach statement:
sl@0: **
sl@0: **     DETACH DATABASE x
sl@0: **
sl@0: **     SELECT sqlite_detach(x)
sl@0: */
sl@0: static void detachFunc(
sl@0:   sqlite3_context *context,
sl@0:   int argc,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   const char *zName = (const char *)sqlite3_value_text(argv[0]);
sl@0:   sqlite3 *db = sqlite3_context_db_handle(context);
sl@0:   int i;
sl@0:   Db *pDb = 0;
sl@0:   char zErr[128];
sl@0: 
sl@0:   if( zName==0 ) zName = "";
sl@0:   for(i=0; i<db->nDb; i++){
sl@0:     pDb = &db->aDb[i];
sl@0:     if( pDb->pBt==0 ) continue;
sl@0:     if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
sl@0:   }
sl@0: 
sl@0:   if( i>=db->nDb ){
sl@0:     sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
sl@0:     goto detach_error;
sl@0:   }
sl@0:   if( i<2 ){
sl@0:     sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
sl@0:     goto detach_error;
sl@0:   }
sl@0:   if( !db->autoCommit ){
sl@0:     sqlite3_snprintf(sizeof(zErr), zErr,
sl@0:                      "cannot DETACH database within transaction");
sl@0:     goto detach_error;
sl@0:   }
sl@0:   if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){
sl@0:     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
sl@0:     goto detach_error;
sl@0:   }
sl@0: 
sl@0:   sqlite3BtreeClose(pDb->pBt);
sl@0:   pDb->pBt = 0;
sl@0:   pDb->pSchema = 0;
sl@0:   sqlite3ResetInternalSchema(db, 0);
sl@0:   return;
sl@0: 
sl@0: detach_error:
sl@0:   sqlite3_result_error(context, zErr, -1);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This procedure generates VDBE code for a single invocation of either the
sl@0: ** sqlite_detach() or sqlite_attach() SQL user functions.
sl@0: */
sl@0: static void codeAttach(
sl@0:   Parse *pParse,       /* The parser context */
sl@0:   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
sl@0:   const char *zFunc,   /* Either "sqlite_attach" or "sqlite_detach */
sl@0:   int nFunc,           /* Number of args to pass to zFunc */
sl@0:   Expr *pAuthArg,      /* Expression to pass to authorization callback */
sl@0:   Expr *pFilename,     /* Name of database file */
sl@0:   Expr *pDbname,       /* Name of the database to use internally */
sl@0:   Expr *pKey           /* Database key for encryption extension */
sl@0: ){
sl@0:   int rc;
sl@0:   NameContext sName;
sl@0:   Vdbe *v;
sl@0:   FuncDef *pFunc;
sl@0:   sqlite3* db = pParse->db;
sl@0:   int regArgs;
sl@0: 
sl@0: #ifndef SQLITE_OMIT_AUTHORIZATION
sl@0:   assert( db->mallocFailed || pAuthArg );
sl@0:   if( pAuthArg ){
sl@0:     char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span);
sl@0:     if( !zAuthArg ){
sl@0:       goto attach_end;
sl@0:     }
sl@0:     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
sl@0:     sqlite3DbFree(db, zAuthArg);
sl@0:     if(rc!=SQLITE_OK ){
sl@0:       goto attach_end;
sl@0:     }
sl@0:   }
sl@0: #endif /* SQLITE_OMIT_AUTHORIZATION */
sl@0: 
sl@0:   memset(&sName, 0, sizeof(NameContext));
sl@0:   sName.pParse = pParse;
sl@0: 
sl@0:   if( 
sl@0:       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
sl@0:       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
sl@0:       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
sl@0:   ){
sl@0:     pParse->nErr++;
sl@0:     goto attach_end;
sl@0:   }
sl@0: 
sl@0:   v = sqlite3GetVdbe(pParse);
sl@0:   regArgs = sqlite3GetTempRange(pParse, 4);
sl@0:   sqlite3ExprCode(pParse, pFilename, regArgs);
sl@0:   sqlite3ExprCode(pParse, pDbname, regArgs+1);
sl@0:   sqlite3ExprCode(pParse, pKey, regArgs+2);
sl@0: 
sl@0:   assert( v || db->mallocFailed );
sl@0:   if( v ){
sl@0:     sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs+3);
sl@0:     sqlite3VdbeChangeP5(v, nFunc);
sl@0:     pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);
sl@0:     sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
sl@0: 
sl@0:     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
sl@0:     ** statement only). For DETACH, set it to false (expire all existing
sl@0:     ** statements).
sl@0:     */
sl@0:     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
sl@0:   }
sl@0:   
sl@0: attach_end:
sl@0:   sqlite3ExprDelete(db, pFilename);
sl@0:   sqlite3ExprDelete(db, pDbname);
sl@0:   sqlite3ExprDelete(db, pKey);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Called by the parser to compile a DETACH statement.
sl@0: **
sl@0: **     DETACH pDbname
sl@0: */
sl@0: void sqlite3Detach(Parse *pParse, Expr *pDbname){
sl@0:   codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Called by the parser to compile an ATTACH statement.
sl@0: **
sl@0: **     ATTACH p AS pDbname KEY pKey
sl@0: */
sl@0: void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
sl@0:   codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_ATTACH */
sl@0: 
sl@0: /*
sl@0: ** Register the functions sqlite_attach and sqlite_detach.
sl@0: */
sl@0: void sqlite3AttachFunctions(sqlite3 *db){
sl@0: #ifndef SQLITE_OMIT_ATTACH
sl@0:   static const int enc = SQLITE_UTF8;
sl@0:   sqlite3CreateFunc(db, "sqlite_attach", 3, enc, 0, attachFunc, 0, 0);
sl@0:   sqlite3CreateFunc(db, "sqlite_detach", 1, enc, 0, detachFunc, 0, 0);
sl@0: #endif
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Initialize a DbFixer structure.  This routine must be called prior
sl@0: ** to passing the structure to one of the sqliteFixAAAA() routines below.
sl@0: **
sl@0: ** The return value indicates whether or not fixation is required.  TRUE
sl@0: ** means we do need to fix the database references, FALSE means we do not.
sl@0: */
sl@0: int sqlite3FixInit(
sl@0:   DbFixer *pFix,      /* The fixer to be initialized */
sl@0:   Parse *pParse,      /* Error messages will be written here */
sl@0:   int iDb,            /* This is the database that must be used */
sl@0:   const char *zType,  /* "view", "trigger", or "index" */
sl@0:   const Token *pName  /* Name of the view, trigger, or index */
sl@0: ){
sl@0:   sqlite3 *db;
sl@0: 
sl@0:   if( iDb<0 || iDb==1 ) return 0;
sl@0:   db = pParse->db;
sl@0:   assert( db->nDb>iDb );
sl@0:   pFix->pParse = pParse;
sl@0:   pFix->zDb = db->aDb[iDb].zName;
sl@0:   pFix->zType = zType;
sl@0:   pFix->pName = pName;
sl@0:   return 1;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The following set of routines walk through the parse tree and assign
sl@0: ** a specific database to all table references where the database name
sl@0: ** was left unspecified in the original SQL statement.  The pFix structure
sl@0: ** must have been initialized by a prior call to sqlite3FixInit().
sl@0: **
sl@0: ** These routines are used to make sure that an index, trigger, or
sl@0: ** view in one database does not refer to objects in a different database.
sl@0: ** (Exception: indices, triggers, and views in the TEMP database are
sl@0: ** allowed to refer to anything.)  If a reference is explicitly made
sl@0: ** to an object in a different database, an error message is added to
sl@0: ** pParse->zErrMsg and these routines return non-zero.  If everything
sl@0: ** checks out, these routines return 0.
sl@0: */
sl@0: int sqlite3FixSrcList(
sl@0:   DbFixer *pFix,       /* Context of the fixation */
sl@0:   SrcList *pList       /* The Source list to check and modify */
sl@0: ){
sl@0:   int i;
sl@0:   const char *zDb;
sl@0:   struct SrcList_item *pItem;
sl@0: 
sl@0:   if( pList==0 ) return 0;
sl@0:   zDb = pFix->zDb;
sl@0:   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
sl@0:     if( pItem->zDatabase==0 ){
sl@0:       pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);
sl@0:     }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){
sl@0:       sqlite3ErrorMsg(pFix->pParse,
sl@0:          "%s %T cannot reference objects in database %s",
sl@0:          pFix->zType, pFix->pName, pItem->zDatabase);
sl@0:       return 1;
sl@0:     }
sl@0: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
sl@0:     if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
sl@0:     if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
sl@0: #endif
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
sl@0: int sqlite3FixSelect(
sl@0:   DbFixer *pFix,       /* Context of the fixation */
sl@0:   Select *pSelect      /* The SELECT statement to be fixed to one database */
sl@0: ){
sl@0:   while( pSelect ){
sl@0:     if( sqlite3FixExprList(pFix, pSelect->pEList) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
sl@0:       return 1;
sl@0:     }
sl@0:     pSelect = pSelect->pPrior;
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: int sqlite3FixExpr(
sl@0:   DbFixer *pFix,     /* Context of the fixation */
sl@0:   Expr *pExpr        /* The expression to be fixed to one database */
sl@0: ){
sl@0:   while( pExpr ){
sl@0:     if( sqlite3FixSelect(pFix, pExpr->pSelect) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixExprList(pFix, pExpr->pList) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixExpr(pFix, pExpr->pRight) ){
sl@0:       return 1;
sl@0:     }
sl@0:     pExpr = pExpr->pLeft;
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: int sqlite3FixExprList(
sl@0:   DbFixer *pFix,     /* Context of the fixation */
sl@0:   ExprList *pList    /* The expression to be fixed to one database */
sl@0: ){
sl@0:   int i;
sl@0:   struct ExprList_item *pItem;
sl@0:   if( pList==0 ) return 0;
sl@0:   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
sl@0:     if( sqlite3FixExpr(pFix, pItem->pExpr) ){
sl@0:       return 1;
sl@0:     }
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0: int sqlite3FixTriggerStep(
sl@0:   DbFixer *pFix,     /* Context of the fixation */
sl@0:   TriggerStep *pStep /* The trigger step be fixed to one database */
sl@0: ){
sl@0:   while( pStep ){
sl@0:     if( sqlite3FixSelect(pFix, pStep->pSelect) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixExpr(pFix, pStep->pWhere) ){
sl@0:       return 1;
sl@0:     }
sl@0:     if( sqlite3FixExprList(pFix, pStep->pExprList) ){
sl@0:       return 1;
sl@0:     }
sl@0:     pStep = pStep->pNext;
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: #endif