/*

 ** 2003 April 6

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** This file contains code used to implement the ATTACH and DETACH commands.

 **

 ** $Id$

 */

 #include "sqliteInt.h"

 #ifndef SQLITE_OMIT_ATTACH

 /*

 ** Resolve an expression that was part of an ATTACH or DETACH statement. This

 ** is slightly different from resolving a normal SQL expression, because simple

 ** identifiers are treated as strings, not possible column names or aliases.

 **

 ** i.e. if the parser sees:

 **

 **     ATTACH DATABASE abc AS def

 **

 ** it treats the two expressions as literal strings 'abc' and 'def' instead of

 ** looking for columns of the same name.

 **

 ** This only applies to the root node of pExpr, so the statement:

 **

 **     ATTACH DATABASE abc||def AS 'db2'

 **

 ** will fail because neither abc or def can be resolved.

 */

 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)

 {

   int rc = SQLITE_OK;

   if( pExpr ){

     if( pExpr->op!=TK_ID ){

       rc = sqlite3ExprResolveNames(pName, pExpr);

       if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){

         sqlite3ErrorMsg(pName->pParse, "invalid name: \"%T\"", &pExpr->span);

         return SQLITE_ERROR;

       }

     }else{

       pExpr->op = TK_STRING;

     }

   }

   return rc;

 }

 /*

 ** An SQL user-function registered to do the work of an ATTACH statement. The

 ** three arguments to the function come directly from an attach statement:

 **

 **     ATTACH DATABASE x AS y KEY z

 **

 **     SELECT sqlite_attach(x, y, z)

 **

 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the

 ** third argument.

 */

 static void attachFunc(

   sqlite3_context *context,

   int argc,

   sqlite3_value **argv

 ){

   int i;

   int rc = 0;

   sqlite3 *db = sqlite3_user_data(context);

   const char *zName;

   const char *zFile;

   Db *aNew;

   char *zErrDyn = 0;

   char zErr[128];

   zFile = (const char *)sqlite3_value_text(argv[0]);

   zName = (const char *)sqlite3_value_text(argv[1]);

   if( zFile==0 ) zFile = "";

   if( zName==0 ) zName = "";

   /* Check for the following errors:

   **

   **     * Too many attached databases,

   **     * Transaction currently open

   **     * Specified database name already being used.

   */

   if( db->nDb>=SQLITE_MAX_ATTACHED+2 ){

     sqlite3_snprintf(

       sizeof(zErr), zErr, "too many attached databases - max %d", 

       SQLITE_MAX_ATTACHED

     );

     goto attach_error;

   }

   if( !db->autoCommit ){

     sqlite3_snprintf(sizeof(zErr), zErr,

                      "cannot ATTACH database within transaction");

     goto attach_error;

   }

   for(i=0; i<db->nDb; i++){

     char *z = db->aDb[i].zName;

     if( z && zName && sqlite3StrICmp(z, zName)==0 ){

       sqlite3_snprintf(sizeof(zErr), zErr, 

                        "database %s is already in use", zName);

       goto attach_error;

     }

   }

   /* Allocate the new entry in the db->aDb[] array and initialise the schema

   ** hash tables.

   */

   if( db->aDb==db->aDbStatic ){

     aNew = sqlite3_malloc( sizeof(db->aDb[0])*3 );

     if( aNew==0 ){

       db->mallocFailed = 1;

       return;

     }

     memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);

   }else{

     aNew = sqlite3_realloc(db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );

     if( aNew==0 ){

       db->mallocFailed = 1;

       return;

     } 

   }

   db->aDb = aNew;

   aNew = &db->aDb[db->nDb++];

   memset(aNew, 0, sizeof(*aNew));

   /* Open the database file. If the btree is successfully opened, use

   ** it to obtain the database schema. At this point the schema may

   ** or may not be initialised.

   */

   rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE,

                            db->openFlags | SQLITE_OPEN_MAIN_DB,

                            &aNew->pBt);

   if( rc==SQLITE_OK ){

     aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);

     if( !aNew->pSchema ){

       rc = SQLITE_NOMEM;

     }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){

       sqlite3_snprintf(sizeof(zErr), zErr, 

         "attached databases must use the same text encoding as main database");

       goto attach_error;

     }

     sqlite3PagerLockingMode(sqlite3BtreePager(aNew->pBt), db->dfltLockMode);

   }

   aNew->zName = sqlite3DbStrDup(db, zName);

   aNew->safety_level = 3;

 #if SQLITE_HAS_CODEC

   {

     extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);

     extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);

     int nKey;

     char *zKey;

     int t = sqlite3_value_type(argv[2]);

     switch( t ){

       case SQLITE_INTEGER:

       case SQLITE_FLOAT:

         zErrDyn = sqlite3DbStrDup(db, "Invalid key value");

         rc = SQLITE_ERROR;

         break;

       case SQLITE_TEXT:

       case SQLITE_BLOB:

         nKey = sqlite3_value_bytes(argv[2]);

         zKey = (char *)sqlite3_value_blob(argv[2]);

         sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);

         break;

       case SQLITE_NULL:

         /* No key specified.  Use the key from the main database */

         sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);

         sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);

         break;

     }

   }

 #endif

   /* If the file was opened successfully, read the schema for the new database.

   ** If this fails, or if opening the file failed, then close the file and 

   ** remove the entry from the db->aDb[] array. i.e. put everything back the way

   ** we found it.

   */

   if( rc==SQLITE_OK ){

     sqlite3SafetyOn(db);

     rc = sqlite3Init(db, &zErrDyn);

     sqlite3SafetyOff(db);

   }

   if( rc ){

     int iDb = db->nDb - 1;

     assert( iDb>=2 );

     if( db->aDb[iDb].pBt ){

       sqlite3BtreeClose(db->aDb[iDb].pBt);

       db->aDb[iDb].pBt = 0;

       db->aDb[iDb].pSchema = 0;

     }

     sqlite3ResetInternalSchema(db, 0);

     db->nDb = iDb;

     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){

       db->mallocFailed = 1;

       sqlite3_snprintf(sizeof(zErr),zErr, "out of memory");

     }else{

       sqlite3_snprintf(sizeof(zErr),zErr, "unable to open database: %s", zFile);

     }

     goto attach_error;

   }

   return;

 attach_error:

   /* Return an error if we get here */

   if( zErrDyn ){

     sqlite3_result_error(context, zErrDyn, -1);

     sqlite3_free(zErrDyn);

   }else{

     zErr[sizeof(zErr)-1] = 0;

     sqlite3_result_error(context, zErr, -1);

   }

 }

 /*

 ** An SQL user-function registered to do the work of an DETACH statement. The

 ** three arguments to the function come directly from a detach statement:

 **

 **     DETACH DATABASE x

 **

 **     SELECT sqlite_detach(x)

 */

 static void detachFunc(

   sqlite3_context *context,

   int argc,

   sqlite3_value **argv

 ){

   const char *zName = (const char *)sqlite3_value_text(argv[0]);

   sqlite3 *db = sqlite3_user_data(context);

   int i;

   Db *pDb = 0;

   char zErr[128];

   if( zName==0 ) zName = "";

   for(i=0; i<db->nDb; i++){

     pDb = &db->aDb[i];

     if( pDb->pBt==0 ) continue;

     if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;

   }

   if( i>=db->nDb ){

     sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);

     goto detach_error;

   }

   if( i<2 ){

     sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);

     goto detach_error;

   }

   if( !db->autoCommit ){

     sqlite3_snprintf(sizeof(zErr), zErr,

                      "cannot DETACH database within transaction");

     goto detach_error;

   }

   if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){

     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);

     goto detach_error;

   }

   sqlite3BtreeClose(pDb->pBt);

   pDb->pBt = 0;

   pDb->pSchema = 0;

   sqlite3ResetInternalSchema(db, 0);

   return;

 detach_error:

   sqlite3_result_error(context, zErr, -1);

 }

 /*

 ** This procedure generates VDBE code for a single invocation of either the

 ** sqlite_detach() or sqlite_attach() SQL user functions.

 */

 static void codeAttach(

   Parse *pParse,       /* The parser context */

   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */

   const char *zFunc,   /* Either "sqlite_attach" or "sqlite_detach */

   int nFunc,           /* Number of args to pass to zFunc */

   Expr *pAuthArg,      /* Expression to pass to authorization callback */

   Expr *pFilename,     /* Name of database file */

   Expr *pDbname,       /* Name of the database to use internally */

   Expr *pKey           /* Database key for encryption extension */

 ){

   int rc;

   NameContext sName;

   Vdbe *v;

   FuncDef *pFunc;

   sqlite3* db = pParse->db;

 #ifndef SQLITE_OMIT_AUTHORIZATION

   assert( db->mallocFailed || pAuthArg );

   if( pAuthArg ){

     char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span);

     if( !zAuthArg ){

       goto attach_end;

     }

     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);

     sqlite3_free(zAuthArg);

     if(rc!=SQLITE_OK ){

       goto attach_end;

     }

   }

 #endif /* SQLITE_OMIT_AUTHORIZATION */

   memset(&sName, 0, sizeof(NameContext));

   sName.pParse = pParse;

   if( 

       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||

       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||

       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))

   ){

     pParse->nErr++;

     goto attach_end;

   }

   v = sqlite3GetVdbe(pParse);

   sqlite3ExprCode(pParse, pFilename);

   sqlite3ExprCode(pParse, pDbname);

   sqlite3ExprCode(pParse, pKey);

   assert( v || db->mallocFailed );

   if( v ){

     sqlite3VdbeAddOp(v, OP_Function, 0, nFunc);

     pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);

     sqlite3VdbeChangeP3(v, -1, (char *)pFunc, P3_FUNCDEF);

     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this

     ** statement only). For DETACH, set it to false (expire all existing

     ** statements).

     */

     sqlite3VdbeAddOp(v, OP_Expire, (type==SQLITE_ATTACH), 0);

   }

 attach_end:

   sqlite3ExprDelete(pFilename);

   sqlite3ExprDelete(pDbname);

   sqlite3ExprDelete(pKey);

 }

 /*

 ** Called by the parser to compile a DETACH statement.

 **

 **     DETACH pDbname

 */

 void sqlite3Detach(Parse *pParse, Expr *pDbname){

   codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname);

 }

 /*

 ** Called by the parser to compile an ATTACH statement.

 **

 **     ATTACH p AS pDbname KEY pKey

 */

 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){

   codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey);

 }

 #endif /* SQLITE_OMIT_ATTACH */

 /*

 ** Register the functions sqlite_attach and sqlite_detach.

 */

 void sqlite3AttachFunctions(sqlite3 *db){

 #ifndef SQLITE_OMIT_ATTACH

   static const int enc = SQLITE_UTF8;

   sqlite3CreateFunc(db, "sqlite_attach", 3, enc, db, attachFunc, 0, 0);

   sqlite3CreateFunc(db, "sqlite_detach", 1, enc, db, detachFunc, 0, 0);

 #endif

 }

 /*

 ** Initialize a DbFixer structure.  This routine must be called prior

 ** to passing the structure to one of the sqliteFixAAAA() routines below.

 **

 ** The return value indicates whether or not fixation is required.  TRUE

 ** means we do need to fix the database references, FALSE means we do not.

 */

 int sqlite3FixInit(

   DbFixer *pFix,      /* The fixer to be initialized */

   Parse *pParse,      /* Error messages will be written here */

   int iDb,            /* This is the database that must be used */

   const char *zType,  /* "view", "trigger", or "index" */

   const Token *pName  /* Name of the view, trigger, or index */

 ){

   sqlite3 *db;

   if( iDb<0 || iDb==1 ) return 0;

   db = pParse->db;

   assert( db->nDb>iDb );

   pFix->pParse = pParse;

   pFix->zDb = db->aDb[iDb].zName;

   pFix->zType = zType;

   pFix->pName = pName;

   return 1;

 }

 /*

 ** The following set of routines walk through the parse tree and assign

 ** a specific database to all table references where the database name

 ** was left unspecified in the original SQL statement.  The pFix structure

 ** must have been initialized by a prior call to sqlite3FixInit().

 **

 ** These routines are used to make sure that an index, trigger, or

 ** view in one database does not refer to objects in a different database.

 ** (Exception: indices, triggers, and views in the TEMP database are

 ** allowed to refer to anything.)  If a reference is explicitly made

 ** to an object in a different database, an error message is added to

 ** pParse->zErrMsg and these routines return non-zero.  If everything

 ** checks out, these routines return 0.

 */

 int sqlite3FixSrcList(

   DbFixer *pFix,       /* Context of the fixation */

   SrcList *pList       /* The Source list to check and modify */

 ){

   int i;

   const char *zDb;

   struct SrcList_item *pItem;

   if( pList==0 ) return 0;

   zDb = pFix->zDb;

   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){

     if( pItem->zDatabase==0 ){

       pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);

     }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){

       sqlite3ErrorMsg(pFix->pParse,

          "%s %T cannot reference objects in database %s",

          pFix->zType, pFix->pName, pItem->zDatabase);

       return 1;

     }

 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)

     if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;

     if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;

 #endif

   }

   return 0;

 }

 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)

 int sqlite3FixSelect(

   DbFixer *pFix,       /* Context of the fixation */

   Select *pSelect      /* The SELECT statement to be fixed to one database */

 ){

   while( pSelect ){

     if( sqlite3FixExprList(pFix, pSelect->pEList) ){

       return 1;

     }

     if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){

       return 1;

     }

     if( sqlite3FixExpr(pFix, pSelect->pWhere) ){

       return 1;

     }

     if( sqlite3FixExpr(pFix, pSelect->pHaving) ){

       return 1;

     }

     pSelect = pSelect->pPrior;

   }

   return 0;

 }

 int sqlite3FixExpr(

   DbFixer *pFix,     /* Context of the fixation */

   Expr *pExpr        /* The expression to be fixed to one database */

 ){

   while( pExpr ){

     if( sqlite3FixSelect(pFix, pExpr->pSelect) ){

       return 1;

     }

     if( sqlite3FixExprList(pFix, pExpr->pList) ){

       return 1;

     }

     if( sqlite3FixExpr(pFix, pExpr->pRight) ){

       return 1;

     }

     pExpr = pExpr->pLeft;

   }

   return 0;

 }

 int sqlite3FixExprList(

   DbFixer *pFix,     /* Context of the fixation */

   ExprList *pList    /* The expression to be fixed to one database */

 ){

   int i;

   struct ExprList_item *pItem;

   if( pList==0 ) return 0;

   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){

     if( sqlite3FixExpr(pFix, pItem->pExpr) ){

       return 1;

     }

   }

   return 0;

 }

 #endif

 #ifndef SQLITE_OMIT_TRIGGER

 int sqlite3FixTriggerStep(

   DbFixer *pFix,     /* Context of the fixation */

   TriggerStep *pStep /* The trigger step be fixed to one database */

 ){

   while( pStep ){

     if( sqlite3FixSelect(pFix, pStep->pSelect) ){

       return 1;

     }

     if( sqlite3FixExpr(pFix, pStep->pWhere) ){

       return 1;

     }

     if( sqlite3FixExprList(pFix, pStep->pExprList) ){

       return 1;

     }

     pStep = pStep->pNext;

   }

   return 0;

 }

 #endif