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