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 ** $Id: attach.c,v 1.78 2008/08/20 16:35:10 drh Exp $

    15 */

    16 #include "sqliteInt.h"

    17 

    18 #ifndef SQLITE_OMIT_ATTACH

    19 /*

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

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

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

    23 **

    24 ** i.e. if the parser sees:

    25 **

    26 **     ATTACH DATABASE abc AS def

    27 **

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

    29 ** looking for columns of the same name.

    30 **

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

    32 **

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

    34 **

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

    36 */

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

    38 {

    39   int rc = SQLITE_OK;

    40   if( pExpr ){

    41     if( pExpr->op!=TK_ID ){

    42       rc = sqlite3ResolveExprNames(pName, pExpr);

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

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

    45         return SQLITE_ERROR;

    46       }

    47     }else{

    48       pExpr->op = TK_STRING;

    49     }

    50   }

    51   return rc;

    52 }

    53 

    54 /*

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

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

    57 **

    58 **     ATTACH DATABASE x AS y KEY z

    59 **

    60 **     SELECT sqlite_attach(x, y, z)

    61 **

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

    63 ** third argument.

    64 */

    65 static void attachFunc(

    66   sqlite3_context *context,

    67   int argc,

    68   sqlite3_value **argv

    69 ){

    70   int i;

    71   int rc = 0;

    72   sqlite3 *db = sqlite3_context_db_handle(context);

    73   const char *zName;

    74   const char *zFile;

    75   Db *aNew;

    76   char *zErrDyn = 0;

    77   char zErr[128];

    78 

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

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

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

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

    83 

    84   /* Check for the following errors:

    85   **

    86   **     * Too many attached databases,

    87   **     * Transaction currently open

    88   **     * Specified database name already being used.

    89   */

    90   if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){

    91     sqlite3_snprintf(

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

    93       db->aLimit[SQLITE_LIMIT_ATTACHED]

    94     );

    95     goto attach_error;

    96   }

    97   if( !db->autoCommit ){

    98     sqlite3_snprintf(sizeof(zErr), zErr,

    99                      "cannot ATTACH database within transaction");

   100     goto attach_error;

   101   }

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

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

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

   105       sqlite3_snprintf(sizeof(zErr), zErr, 

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

   107       goto attach_error;

   108     }

   109   }

   110 

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

   112   ** hash tables.

   113   */

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

   115     aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );

   116     if( aNew==0 ) return;

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

   118   }else{

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

   120     if( aNew==0 ) return;

   121   }

   122   db->aDb = aNew;

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

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

   125 

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

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

   128   ** or may not be initialised.

   129   */

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

   131                            db->openFlags | SQLITE_OPEN_MAIN_DB,

   132                            &aNew->pBt);

   133   if( rc==SQLITE_OK ){

   134     Pager *pPager;

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

   136     if( !aNew->pSchema ){

   137       rc = SQLITE_NOMEM;

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

   139       sqlite3_snprintf(sizeof(zErr), zErr, 

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

   141       goto attach_error;

   142     }

   143     pPager = sqlite3BtreePager(aNew->pBt);

   144     sqlite3PagerLockingMode(pPager, db->dfltLockMode);

   145     sqlite3PagerJournalMode(pPager, db->dfltJournalMode);

   146   }

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

   148   aNew->safety_level = 3;

   149 

   150 #if SQLITE_HAS_CODEC

   151   {

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

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

   154     int nKey;

   155     char *zKey;

   156     int t = sqlite3_value_type(argv[2]);

   157     switch( t ){

   158       case SQLITE_INTEGER:

   159       case SQLITE_FLOAT:

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

   161         rc = SQLITE_ERROR;

   162         break;

   163         

   164       case SQLITE_TEXT:

   165       case SQLITE_BLOB:

   166         nKey = sqlite3_value_bytes(argv[2]);

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

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

   169         break;

   170 

   171       case SQLITE_NULL:

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

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

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

   175         break;

   176     }

   177   }

   178 #endif

   179 

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

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

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

   183   ** we found it.

   184   */

   185   if( rc==SQLITE_OK ){

   186     (void)sqlite3SafetyOn(db);

   187     sqlite3BtreeEnterAll(db);

   188     rc = sqlite3Init(db, &zErrDyn);

   189     sqlite3BtreeLeaveAll(db);

   190     (void)sqlite3SafetyOff(db);

   191   }

   192   if( rc ){

   193     int iDb = db->nDb - 1;

   194     assert( iDb>=2 );

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

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

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

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

   199     }

   200     sqlite3ResetInternalSchema(db, 0);

   201     db->nDb = iDb;

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

   203       db->mallocFailed = 1;

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

   205     }else{

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

   207     }

   208     goto attach_error;

   209   }

   210   

   211   return;

   212 

   213 attach_error:

   214   /* Return an error if we get here */

   215   if( zErrDyn ){

   216     sqlite3_result_error(context, zErrDyn, -1);

   217     sqlite3DbFree(db, zErrDyn);

   218   }else{

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

   220     sqlite3_result_error(context, zErr, -1);

   221   }

   222   if( rc ) sqlite3_result_error_code(context, rc);

   223 }

   224 

   225 /*

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

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

   228 **

   229 **     DETACH DATABASE x

   230 **

   231 **     SELECT sqlite_detach(x)

   232 */

   233 static void detachFunc(

   234   sqlite3_context *context,

   235   int argc,

   236   sqlite3_value **argv

   237 ){

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

   239   sqlite3 *db = sqlite3_context_db_handle(context);

   240   int i;

   241   Db *pDb = 0;

   242   char zErr[128];

   243 

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

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

   246     pDb = &db->aDb[i];

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

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

   249   }

   250 

   251   if( i>=db->nDb ){

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

   253     goto detach_error;

   254   }

   255   if( i<2 ){

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

   257     goto detach_error;

   258   }

   259   if( !db->autoCommit ){

   260     sqlite3_snprintf(sizeof(zErr), zErr,

   261                      "cannot DETACH database within transaction");

   262     goto detach_error;

   263   }

   264   if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){

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

   266     goto detach_error;

   267   }

   268 

   269   sqlite3BtreeClose(pDb->pBt);

   270   pDb->pBt = 0;

   271   pDb->pSchema = 0;

   272   sqlite3ResetInternalSchema(db, 0);

   273   return;

   274 

   275 detach_error:

   276   sqlite3_result_error(context, zErr, -1);

   277 }

   278 

   279 /*

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

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

   282 */

   283 static void codeAttach(

   284   Parse *pParse,       /* The parser context */

   285   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */

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

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

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

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

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

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

   292 ){

   293   int rc;

   294   NameContext sName;

   295   Vdbe *v;

   296   FuncDef *pFunc;

   297   sqlite3* db = pParse->db;

   298   int regArgs;

   299 

   300 #ifndef SQLITE_OMIT_AUTHORIZATION

   301   assert( db->mallocFailed || pAuthArg );

   302   if( pAuthArg ){

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

   304     if( !zAuthArg ){

   305       goto attach_end;

   306     }

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

   308     sqlite3DbFree(db, zAuthArg);

   309     if(rc!=SQLITE_OK ){

   310       goto attach_end;

   311     }

   312   }

   313 #endif /* SQLITE_OMIT_AUTHORIZATION */

   314 

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

   316   sName.pParse = pParse;

   317 

   318   if( 

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

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

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

   322   ){

   323     pParse->nErr++;

   324     goto attach_end;

   325   }

   326 

   327   v = sqlite3GetVdbe(pParse);

   328   regArgs = sqlite3GetTempRange(pParse, 4);

   329   sqlite3ExprCode(pParse, pFilename, regArgs);

   330   sqlite3ExprCode(pParse, pDbname, regArgs+1);

   331   sqlite3ExprCode(pParse, pKey, regArgs+2);

   332 

   333   assert( v || db->mallocFailed );

   334   if( v ){

   335     sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs+3);

   336     sqlite3VdbeChangeP5(v, nFunc);

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

   338     sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);

   339 

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

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

   342     ** statements).

   343     */

   344     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));

   345   }

   346   

   347 attach_end:

   348   sqlite3ExprDelete(db, pFilename);

   349   sqlite3ExprDelete(db, pDbname);

   350   sqlite3ExprDelete(db, pKey);

   351 }

   352 

   353 /*

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

   355 **

   356 **     DETACH pDbname

   357 */

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

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

   360 }

   361 

   362 /*

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

   364 **

   365 **     ATTACH p AS pDbname KEY pKey

   366 */

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

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

   369 }

   370 #endif /* SQLITE_OMIT_ATTACH */

   371 

   372 /*

   373 ** Register the functions sqlite_attach and sqlite_detach.

   374 */

   375 void sqlite3AttachFunctions(sqlite3 *db){

   376 #ifndef SQLITE_OMIT_ATTACH

   377   static const int enc = SQLITE_UTF8;

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

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

   380 #endif

   381 }

   382 

   383 /*

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

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

   386 **

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

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

   389 */

   390 int sqlite3FixInit(

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

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

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

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

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

   396 ){

   397   sqlite3 *db;

   398 

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

   400   db = pParse->db;

   401   assert( db->nDb>iDb );

   402   pFix->pParse = pParse;

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

   404   pFix->zType = zType;

   405   pFix->pName = pName;

   406   return 1;

   407 }

   408 

   409 /*

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

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

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

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

   414 **

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

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

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

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

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

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

   421 ** checks out, these routines return 0.

   422 */

   423 int sqlite3FixSrcList(

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

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

   426 ){

   427   int i;

   428   const char *zDb;

   429   struct SrcList_item *pItem;

   430 

   431   if( pList==0 ) return 0;

   432   zDb = pFix->zDb;

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

   434     if( pItem->zDatabase==0 ){

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

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

   437       sqlite3ErrorMsg(pFix->pParse,

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

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

   440       return 1;

   441     }

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

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

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

   445 #endif

   446   }

   447   return 0;

   448 }

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

   450 int sqlite3FixSelect(

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

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

   453 ){

   454   while( pSelect ){

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

   456       return 1;

   457     }

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

   459       return 1;

   460     }

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

   462       return 1;

   463     }

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

   465       return 1;

   466     }

   467     pSelect = pSelect->pPrior;

   468   }

   469   return 0;

   470 }

   471 int sqlite3FixExpr(

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

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

   474 ){

   475   while( pExpr ){

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

   477       return 1;

   478     }

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

   480       return 1;

   481     }

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

   483       return 1;

   484     }

   485     pExpr = pExpr->pLeft;

   486   }

   487   return 0;

   488 }

   489 int sqlite3FixExprList(

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

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

   492 ){

   493   int i;

   494   struct ExprList_item *pItem;

   495   if( pList==0 ) return 0;

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

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

   498       return 1;

   499     }

   500   }

   501   return 0;

   502 }

   503 #endif

   504 

   505 #ifndef SQLITE_OMIT_TRIGGER

   506 int sqlite3FixTriggerStep(

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

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

   509 ){

   510   while( pStep ){

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

   512       return 1;

   513     }

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

   515       return 1;

   516     }

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

   518       return 1;

   519     }

   520     pStep = pStep->pNext;

   521   }

   522   return 0;

   523 }

   524 #endif