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 ** An SQL user-function registered to do the work of an ATTACH statement. The
  50 ** three arguments to the function come directly from an attach statement:
  51 **
  52 **     ATTACH DATABASE x AS y KEY z
  53 **
  54 **     SELECT sqlite_attach(x, y, z)
  55 **
  56 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
  57 ** third argument.
  58 */
  59 static void attachFunc(
  60   sqlite3_context *context,
  61   int NotUsed,
  62   sqlite3_value **argv
  63 ){
  64   int i;
  65   int rc = 0;
  66   sqlite3 *db = sqlite3_context_db_handle(context);
  67   const char *zName;
  68   const char *zFile;
  69   char *zPath = 0;
  70   char *zErr = 0;
  71   unsigned int flags;
  72   Db *aNew;
  73   char *zErrDyn = 0;
  74   sqlite3_vfs *pVfs;
  75
  76   UNUSED_PARAMETER(NotUsed);
  77
  78   zFile = (const char *)sqlite3_value_text(argv[0]);
  79   zName = (const char *)sqlite3_value_text(argv[1]);
  80   if( zFile==0 ) zFile = "";
  81   if( zName==0 ) zName = "";
  82
  83   /* Check for the following errors:
  84   **
  85   **     * Too many attached databases,
  86   **     * Transaction currently open
  87   **     * Specified database name already being used.
  88   */
  89   if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
  90     zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
  91       db->aLimit[SQLITE_LIMIT_ATTACHED]
  92     );
  93     goto attach_error;
  94   }
  95   if( !db->autoCommit ){
  96     zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");
  97     goto attach_error;
  98   }
  99   for(i=0; i<db->nDb; i++){
 100     char *z = db->aDb[i].zDbSName;
 101     assert( z && zName );
 102     if( sqlite3StrICmp(z, zName)==0 ){
 103       zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
 104       goto attach_error;
 105     }
 106   }
 107
 108   /* Allocate the new entry in the db->aDb[] array and initialize the schema
 109   ** hash tables.
 110   */
 111   if( db->aDb==db->aDbStatic ){
 112     aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
 113     if( aNew==0 ) return;
 114     memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
 115   }else{
 116     aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
 117     if( aNew==0 ) return;
 118   }
 119   db->aDb = aNew;
 120   aNew = &db->aDb[db->nDb];
 121   memset(aNew, 0, sizeof(*aNew));
 122
 123   /* Open the database file. If the btree is successfully opened, use
 124   ** it to obtain the database schema. At this point the schema may
 125   ** or may not be initialized.
 126   */
 127   flags = db->openFlags;
 128   rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
 129   if( rc!=SQLITE_OK ){
 130     if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
 131     sqlite3_result_error(context, zErr, -1);
 132     sqlite3_free(zErr);
 133     return;
 134   }
 135   assert( pVfs );
 136   flags |= SQLITE_OPEN_MAIN_DB;
 137   rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);
 138   sqlite3_free( zPath );
 139   db->nDb++;
 140   if( rc==SQLITE_CONSTRAINT ){
 141     rc = SQLITE_ERROR;
 142     zErrDyn = sqlite3MPrintf(db, "database is already attached");
 143   }else if( rc==SQLITE_OK ){
 144     Pager *pPager;
 145     aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
 146     if( !aNew->pSchema ){
 147       rc = SQLITE_NOMEM_BKPT;
 148     }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
 149       zErrDyn = sqlite3MPrintf(db,
 150         "attached databases must use the same text encoding as main database");
 151       rc = SQLITE_ERROR;
 152     }
 153     sqlite3BtreeEnter(aNew->pBt);
 154     pPager = sqlite3BtreePager(aNew->pBt);
 155     sqlite3PagerLockingMode(pPager, db->dfltLockMode);
 156     sqlite3BtreeSecureDelete(aNew->pBt,
 157                              sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
 158 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 159     sqlite3BtreeSetPagerFlags(aNew->pBt,
 160                       PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
 161 #endif
 162     sqlite3BtreeLeave(aNew->pBt);
 163   }
 164   aNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
 165   aNew->zDbSName = sqlite3DbStrDup(db, zName);
 166   if( rc==SQLITE_OK && aNew->zDbSName==0 ){
 167     rc = SQLITE_NOMEM_BKPT;
 168   }
 169
 170
 171 #ifdef SQLITE_HAS_CODEC
 172   if( rc==SQLITE_OK ){
 173     extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
 174     extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
 175     int nKey;
 176     char *zKey;
 177     int t = sqlite3_value_type(argv[2]);
 178     switch( t ){
 179       case SQLITE_INTEGER:
 180       case SQLITE_FLOAT:
 181         zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
 182         rc = SQLITE_ERROR;
 183         break;
 184
 185       case SQLITE_TEXT:
 186       case SQLITE_BLOB:
 187         nKey = sqlite3_value_bytes(argv[2]);
 188         zKey = (char *)sqlite3_value_blob(argv[2]);
 189         rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
 190         break;
 191
 192       case SQLITE_NULL:
 193         /* No key specified.  Use the key from the main database */
 194         sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
 195         if( nKey || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){
 196           rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
 197         }
 198         break;
 199     }
 200   }
 201 #endif
 202
 203   /* If the file was opened successfully, read the schema for the new database.
 204   ** If this fails, or if opening the file failed, then close the file and
 205   ** remove the entry from the db->aDb[] array. i.e. put everything back the way
 206   ** we found it.
 207   */
 208   if( rc==SQLITE_OK ){
 209     sqlite3BtreeEnterAll(db);
 210     rc = sqlite3Init(db, &zErrDyn);
 211     sqlite3BtreeLeaveAll(db);
 212   }
 213 #ifdef SQLITE_USER_AUTHENTICATION
 214   if( rc==SQLITE_OK ){
 215     u8 newAuth = 0;
 216     rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
 217     if( newAuth<db->auth.authLevel ){
 218       rc = SQLITE_AUTH_USER;
 219     }
 220   }
 221 #endif
 222   if( rc ){
 223     int iDb = db->nDb - 1;
 224     assert( iDb>=2 );
 225     if( db->aDb[iDb].pBt ){
 226       sqlite3BtreeClose(db->aDb[iDb].pBt);
 227       db->aDb[iDb].pBt = 0;
 228       db->aDb[iDb].pSchema = 0;
 229     }
 230     sqlite3ResetAllSchemasOfConnection(db);
 231     db->nDb = iDb;
 232     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
 233       sqlite3OomFault(db);
 234       sqlite3DbFree(db, zErrDyn);
 235       zErrDyn = sqlite3MPrintf(db, "out of memory");
 236     }else if( zErrDyn==0 ){
 237       zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
 238     }
 239     goto attach_error;
 240   }
 241
 242   return;
 243
 244 attach_error:
 245   /* Return an error if we get here */
 246   if( zErrDyn ){
 247     sqlite3_result_error(context, zErrDyn, -1);
 248     sqlite3DbFree(db, zErrDyn);
 249   }
 250   if( rc ) sqlite3_result_error_code(context, rc);
 251 }
 252
 253 /*
 254 ** An SQL user-function registered to do the work of an DETACH statement. The
 255 ** three arguments to the function come directly from a detach statement:
 256 **
 257 **     DETACH DATABASE x
 258 **
 259 **     SELECT sqlite_detach(x)
 260 */
 261 static void detachFunc(
 262   sqlite3_context *context,
 263   int NotUsed,
 264   sqlite3_value **argv
 265 ){
 266   const char *zName = (const char *)sqlite3_value_text(argv[0]);
 267   sqlite3 *db = sqlite3_context_db_handle(context);
 268   int i;
 269   Db *pDb = 0;
 270   char zErr[128];
 271
 272   UNUSED_PARAMETER(NotUsed);
 273
 274   if( zName==0 ) zName = "";
 275   for(i=0; i<db->nDb; i++){
 276     pDb = &db->aDb[i];
 277     if( pDb->pBt==0 ) continue;
 278     if( sqlite3StrICmp(pDb->zDbSName, zName)==0 ) break;
 279   }
 280
 281   if( i>=db->nDb ){
 282     sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
 283     goto detach_error;
 284   }
 285   if( i<2 ){
 286     sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
 287     goto detach_error;
 288   }
 289   if( !db->autoCommit ){
 290     sqlite3_snprintf(sizeof(zErr), zErr,
 291                      "cannot DETACH database within transaction");
 292     goto detach_error;
 293   }
 294   if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
 295     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
 296     goto detach_error;
 297   }
 298
 299   sqlite3BtreeClose(pDb->pBt);
 300   pDb->pBt = 0;
 301   pDb->pSchema = 0;
 302   sqlite3CollapseDatabaseArray(db);
 303   return;
 304
 305 detach_error:
 306   sqlite3_result_error(context, zErr, -1);
 307 }
 308
 309 /*
 310 ** This procedure generates VDBE code for a single invocation of either the
 311 ** sqlite_detach() or sqlite_attach() SQL user functions.
 312 */
 313 static void codeAttach(
 314   Parse *pParse,       /* The parser context */
 315   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
 316   FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
 317   Expr *pAuthArg,      /* Expression to pass to authorization callback */
 318   Expr *pFilename,     /* Name of database file */
 319   Expr *pDbname,       /* Name of the database to use internally */
 320   Expr *pKey           /* Database key for encryption extension */
 321 ){
 322   int rc;
 323   NameContext sName;
 324   Vdbe *v;
 325   sqlite3* db = pParse->db;
 326   int regArgs;
 327
 328   if( pParse->nErr ) goto attach_end;
 329   memset(&sName, 0, sizeof(NameContext));
 330   sName.pParse = pParse;
 331
 332   if(
 333       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
 334       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
 335       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
 336   ){
 337     goto attach_end;
 338   }
 339
 340 #ifndef SQLITE_OMIT_AUTHORIZATION
 341   if( pAuthArg ){
 342     char *zAuthArg;
 343     if( pAuthArg->op==TK_STRING ){
 344       zAuthArg = pAuthArg->u.zToken;
 345     }else{
 346       zAuthArg = 0;
 347     }
 348     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
 349     if(rc!=SQLITE_OK ){
 350       goto attach_end;
 351     }
 352   }
 353 #endif /* SQLITE_OMIT_AUTHORIZATION */
 354
 355
 356   v = sqlite3GetVdbe(pParse);
 357   regArgs = sqlite3GetTempRange(pParse, 4);
 358   sqlite3ExprCode(pParse, pFilename, regArgs);
 359   sqlite3ExprCode(pParse, pDbname, regArgs+1);
 360   sqlite3ExprCode(pParse, pKey, regArgs+2);
 361
 362   assert( v || db->mallocFailed );
 363   if( v ){
 364     sqlite3VdbeAddOp4(v, OP_Function0, 0, regArgs+3-pFunc->nArg, regArgs+3,
 365                       (char *)pFunc, P4_FUNCDEF);
 366     assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
 367     sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg));
 368
 369     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
 370     ** statement only). For DETACH, set it to false (expire all existing
 371     ** statements).
 372     */
 373     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
 374   }
 375
 376 attach_end:
 377   sqlite3ExprDelete(db, pFilename);
 378   sqlite3ExprDelete(db, pDbname);
 379   sqlite3ExprDelete(db, pKey);
 380 }
 381
 382 /*
 383 ** Called by the parser to compile a DETACH statement.
 384 **
 385 **     DETACH pDbname
 386 */
 387 void sqlite3Detach(Parse *pParse, Expr *pDbname){
 388   static const FuncDef detach_func = {
 389     1,                /* nArg */
 390     SQLITE_UTF8,      /* funcFlags */
 391     0,                /* pUserData */
 392     0,                /* pNext */
 393     detachFunc,       /* xSFunc */
 394     0,                /* xFinalize */
 395     "sqlite_detach",  /* zName */
 396     {0}
 397   };
 398   codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
 399 }
 400
 401 /*
 402 ** Called by the parser to compile an ATTACH statement.
 403 **
 404 **     ATTACH p AS pDbname KEY pKey
 405 */
 406 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
 407   static const FuncDef attach_func = {
 408     3,                /* nArg */
 409     SQLITE_UTF8,      /* funcFlags */
 410     0,                /* pUserData */
 411     0,                /* pNext */
 412     attachFunc,       /* xSFunc */
 413     0,                /* xFinalize */
 414     "sqlite_attach",  /* zName */
 415     {0}
 416   };
 417   codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
 418 }
 419 #endif /* SQLITE_OMIT_ATTACH */
 420
 421 /*
 422 ** Initialize a DbFixer structure.  This routine must be called prior
 423 ** to passing the structure to one of the sqliteFixAAAA() routines below.
 424 */
 425 void sqlite3FixInit(
 426   DbFixer *pFix,      /* The fixer to be initialized */
 427   Parse *pParse,      /* Error messages will be written here */
 428   int iDb,            /* This is the database that must be used */
 429   const char *zType,  /* "view", "trigger", or "index" */
 430   const Token *pName  /* Name of the view, trigger, or index */
 431 ){
 432   sqlite3 *db;
 433
 434   db = pParse->db;
 435   assert( db->nDb>iDb );
 436   pFix->pParse = pParse;
 437   pFix->zDb = db->aDb[iDb].zDbSName;
 438   pFix->pSchema = db->aDb[iDb].pSchema;
 439   pFix->zType = zType;
 440   pFix->pName = pName;
 441   pFix->bVarOnly = (iDb==1);
 442 }
 443
 444 /*
 445 ** The following set of routines walk through the parse tree and assign
 446 ** a specific database to all table references where the database name
 447 ** was left unspecified in the original SQL statement.  The pFix structure
 448 ** must have been initialized by a prior call to sqlite3FixInit().
 449 **
 450 ** These routines are used to make sure that an index, trigger, or
 451 ** view in one database does not refer to objects in a different database.
 452 ** (Exception: indices, triggers, and views in the TEMP database are
 453 ** allowed to refer to anything.)  If a reference is explicitly made
 454 ** to an object in a different database, an error message is added to
 455 ** pParse->zErrMsg and these routines return non-zero.  If everything
 456 ** checks out, these routines return 0.
 457 */
 458 int sqlite3FixSrcList(
 459   DbFixer *pFix,       /* Context of the fixation */
 460   SrcList *pList       /* The Source list to check and modify */
 461 ){
 462   int i;
 463   const char *zDb;
 464   struct SrcList_item *pItem;
 465
 466   if( NEVER(pList==0) ) return 0;
 467   zDb = pFix->zDb;
 468   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
 469     if( pFix->bVarOnly==0 ){
 470       if( pItem->zDatabase && sqlite3StrICmp(pItem->zDatabase, zDb) ){
 471         sqlite3ErrorMsg(pFix->pParse,
 472             "%s %T cannot reference objects in database %s",
 473             pFix->zType, pFix->pName, pItem->zDatabase);
 474         return 1;
 475       }
 476       sqlite3DbFree(pFix->pParse->db, pItem->zDatabase);
 477       pItem->zDatabase = 0;
 478       pItem->pSchema = pFix->pSchema;
 479     }
 480 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 481     if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
 482     if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
 483 #endif
 484   }
 485   return 0;
 486 }
 487 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 488 int sqlite3FixSelect(
 489   DbFixer *pFix,       /* Context of the fixation */
 490   Select *pSelect      /* The SELECT statement to be fixed to one database */
 491 ){
 492   while( pSelect ){
 493     if( sqlite3FixExprList(pFix, pSelect->pEList) ){
 494       return 1;
 495     }
 496     if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
 497       return 1;
 498     }
 499     if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
 500       return 1;
 501     }
 502     if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
 503       return 1;
 504     }
 505     if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
 506       return 1;
 507     }
 508     if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
 509       return 1;
 510     }
 511     if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
 512       return 1;
 513     }
 514     if( sqlite3FixExpr(pFix, pSelect->pOffset) ){
 515       return 1;
 516     }
 517     pSelect = pSelect->pPrior;
 518   }
 519   return 0;
 520 }
 521 int sqlite3FixExpr(
 522   DbFixer *pFix,     /* Context of the fixation */
 523   Expr *pExpr        /* The expression to be fixed to one database */
 524 ){
 525   while( pExpr ){
 526     if( pExpr->op==TK_VARIABLE ){
 527       if( pFix->pParse->db->init.busy ){
 528         pExpr->op = TK_NULL;
 529       }else{
 530         sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
 531         return 1;
 532       }
 533     }
 534     if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
 535     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
 536       if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
 537     }else{
 538       if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
 539     }
 540     if( sqlite3FixExpr(pFix, pExpr->pRight) ){
 541       return 1;
 542     }
 543     pExpr = pExpr->pLeft;
 544   }
 545   return 0;
 546 }
 547 int sqlite3FixExprList(
 548   DbFixer *pFix,     /* Context of the fixation */
 549   ExprList *pList    /* The expression to be fixed to one database */
 550 ){
 551   int i;
 552   struct ExprList_item *pItem;
 553   if( pList==0 ) return 0;
 554   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
 555     if( sqlite3FixExpr(pFix, pItem->pExpr) ){
 556       return 1;
 557     }
 558   }
 559   return 0;
 560 }
 561 #endif
 562
 563 #ifndef SQLITE_OMIT_TRIGGER
 564 int sqlite3FixTriggerStep(
 565   DbFixer *pFix,     /* Context of the fixation */
 566   TriggerStep *pStep /* The trigger step be fixed to one database */
 567 ){
 568   while( pStep ){
 569     if( sqlite3FixSelect(pFix, pStep->pSelect) ){
 570       return 1;
 571     }
 572     if( sqlite3FixExpr(pFix, pStep->pWhere) ){
 573       return 1;
 574     }
 575     if( sqlite3FixExprList(pFix, pStep->pExprList) ){
 576       return 1;
 577     }
 578     pStep = pStep->pNext;
 579   }
 580   return 0;
 581 }
 582 #endif