AryaWu/sqlite
0
1/*2** 2003 April 63**4** The author disclaims copyright to this source code. In place of5** 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_ATTACH17/*18** Resolve an expression that was part of an ATTACH or DETACH statement. This19** is slightly different from resolving a normal SQL expression, because simple20** 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 def25**26** it treats the two expressions as literal strings 'abc' and 'def' instead of27** 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*/35static 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** Return true if zName points to a name that may be used to refer to50** database iDb attached to handle db.51*/52int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){53 return (54 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==055 || (iDb==0 && sqlite3StrICmp("main", zName)==0)56 );57}58 59/*60** An SQL user-function registered to do the work of an ATTACH statement. The61** three arguments to the function come directly from an attach statement:62**63** ATTACH DATABASE x AS y KEY z64**65** SELECT sqlite_attach(x, y, z)66**67** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the68** third argument.69**70** If the db->init.reopenMemdb flags is set, then instead of attaching a71** new database, close the database on db->init.iDb and reopen it as an72** empty MemDB.73*/74static void attachFunc(75 sqlite3_context *context,76 int NotUsed,77 sqlite3_value **argv78){79 int i;80 int rc = 0;81 sqlite3 *db = sqlite3_context_db_handle(context);82 const char *zName;83 const char *zFile;84 char *zPath = 0;85 char *zErr = 0;86 unsigned int flags;87 Db *aNew; /* New array of Db pointers */88 Db *pNew = 0; /* Db object for the newly attached database */89 char *zErrDyn = 0;90 sqlite3_vfs *pVfs;91 92 UNUSED_PARAMETER(NotUsed);93 zFile = (const char *)sqlite3_value_text(argv[0]);94 zName = (const char *)sqlite3_value_text(argv[1]);95 if( zFile==0 ) zFile = "";96 if( zName==0 ) zName = "";97 98#ifndef SQLITE_OMIT_DESERIALIZE99# define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb)100#else101# define REOPEN_AS_MEMDB(db) (0)102#endif103 104 if( REOPEN_AS_MEMDB(db) ){105 /* This is not a real ATTACH. Instead, this routine is being called106 ** from sqlite3_deserialize() to close database db->init.iDb and107 ** reopen it as a MemDB */108 Btree *pNewBt = 0;109 pVfs = sqlite3_vfs_find("memdb");110 if( pVfs==0 ) return;111 rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNewBt, 0, SQLITE_OPEN_MAIN_DB);112 if( rc==SQLITE_OK ){113 Schema *pNewSchema = sqlite3SchemaGet(db, pNewBt);114 if( pNewSchema ){115 /* Both the Btree and the new Schema were allocated successfully.116 ** Close the old db and update the aDb[] slot with the new memdb117 ** values. */118 pNew = &db->aDb[db->init.iDb];119 if( ALWAYS(pNew->pBt) ) sqlite3BtreeClose(pNew->pBt);120 pNew->pBt = pNewBt;121 pNew->pSchema = pNewSchema;122 }else{123 sqlite3BtreeClose(pNewBt);124 rc = SQLITE_NOMEM;125 }126 }127 if( rc ) goto attach_error;128 }else{129 /* This is a real ATTACH130 **131 ** Check for the following errors:132 **133 ** * Too many attached databases,134 ** * Transaction currently open135 ** * Specified database name already being used.136 */137 if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){138 zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d", 139 db->aLimit[SQLITE_LIMIT_ATTACHED]140 );141 goto attach_error;142 }143 for(i=0; i<db->nDb; i++){144 assert( zName );145 if( sqlite3DbIsNamed(db, i, zName) ){146 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);147 goto attach_error;148 }149 }150 151 /* Allocate the new entry in the db->aDb[] array and initialize the schema152 ** hash tables.153 */154 if( db->aDb==db->aDbStatic ){155 aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );156 if( aNew==0 ) return;157 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);158 }else{159 aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(1+(i64)db->nDb));160 if( aNew==0 ) return;161 }162 db->aDb = aNew;163 pNew = &db->aDb[db->nDb];164 memset(pNew, 0, sizeof(*pNew));165 166 /* Open the database file. If the btree is successfully opened, use167 ** it to obtain the database schema. At this point the schema may168 ** or may not be initialized.169 */170 flags = db->openFlags;171 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);172 if( rc!=SQLITE_OK ){173 if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);174 sqlite3_result_error(context, zErr, -1);175 sqlite3_free(zErr);176 return;177 }178 if( (db->flags & SQLITE_AttachWrite)==0 ){179 flags &= ~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE);180 flags |= SQLITE_OPEN_READONLY;181 }else if( (db->flags & SQLITE_AttachCreate)==0 ){182 flags &= ~SQLITE_OPEN_CREATE;183 }184 assert( pVfs );185 flags |= SQLITE_OPEN_MAIN_DB;186 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);187 db->nDb++;188 pNew->zDbSName = sqlite3DbStrDup(db, zName);189 }190 db->noSharedCache = 0;191 if( rc==SQLITE_CONSTRAINT ){192 rc = SQLITE_ERROR;193 zErrDyn = sqlite3MPrintf(db, "database is already attached");194 }else if( rc==SQLITE_OK ){195 Pager *pPager;196 pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);197 if( !pNew->pSchema ){198 rc = SQLITE_NOMEM_BKPT;199 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){200 zErrDyn = sqlite3MPrintf(db, 201 "attached databases must use the same text encoding as main database");202 rc = SQLITE_ERROR;203 }204 sqlite3BtreeEnter(pNew->pBt);205 pPager = sqlite3BtreePager(pNew->pBt);206 sqlite3PagerLockingMode(pPager, db->dfltLockMode);207 sqlite3BtreeSecureDelete(pNew->pBt,208 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );209#ifndef SQLITE_OMIT_PAGER_PRAGMAS210 sqlite3BtreeSetPagerFlags(pNew->pBt,211 PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));212#endif213 sqlite3BtreeLeave(pNew->pBt);214 }215 pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;216 if( rc==SQLITE_OK && pNew->zDbSName==0 ){217 rc = SQLITE_NOMEM_BKPT;218 }219 sqlite3_free_filename( zPath );220 221 /* If the file was opened successfully, read the schema for the new database.222 ** If this fails, or if opening the file failed, then close the file and 223 ** remove the entry from the db->aDb[] array. i.e. put everything back the224 ** way we found it.225 */226 if( rc==SQLITE_OK ){227 sqlite3BtreeEnterAll(db);228 db->init.iDb = 0;229 db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);230#ifdef SQLITE_ENABLE_SETLK_TIMEOUT231 if( db->setlkFlags & SQLITE_SETLK_BLOCK_ON_CONNECT ){232 int val = 1;233 sqlite3_file *fd = sqlite3PagerFile(sqlite3BtreePager(pNew->pBt));234 sqlite3OsFileControlHint(fd, SQLITE_FCNTL_BLOCK_ON_CONNECT, &val);235 }236#endif237 if( !REOPEN_AS_MEMDB(db) ){238 rc = sqlite3Init(db, &zErrDyn);239 }240 sqlite3BtreeLeaveAll(db);241 assert( zErrDyn==0 || rc!=SQLITE_OK );242 }243 if( rc ){244 if( ALWAYS(!REOPEN_AS_MEMDB(db)) ){245 int iDb = db->nDb - 1;246 assert( iDb>=2 );247 if( db->aDb[iDb].pBt ){248 sqlite3BtreeClose(db->aDb[iDb].pBt);249 db->aDb[iDb].pBt = 0;250 db->aDb[iDb].pSchema = 0;251 }252 sqlite3ResetAllSchemasOfConnection(db);253 db->nDb = iDb;254 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){255 sqlite3OomFault(db);256 sqlite3DbFree(db, zErrDyn);257 zErrDyn = sqlite3MPrintf(db, "out of memory");258 }else if( zErrDyn==0 ){259 zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);260 }261 }262 goto attach_error;263 }264 265 return;266 267attach_error:268 /* Return an error if we get here */269 if( zErrDyn ){270 sqlite3_result_error(context, zErrDyn, -1);271 sqlite3DbFree(db, zErrDyn);272 }273 if( rc ) sqlite3_result_error_code(context, rc);274}275 276/*277** An SQL user-function registered to do the work of an DETACH statement. The278** three arguments to the function come directly from a detach statement:279**280** DETACH DATABASE x281**282** SELECT sqlite_detach(x)283*/284static void detachFunc(285 sqlite3_context *context,286 int NotUsed,287 sqlite3_value **argv288){289 const char *zName = (const char *)sqlite3_value_text(argv[0]);290 sqlite3 *db = sqlite3_context_db_handle(context);291 int i;292 Db *pDb = 0;293 HashElem *pEntry;294 char zErr[128];295 296 UNUSED_PARAMETER(NotUsed);297 298 if( zName==0 ) zName = "";299 for(i=0; i<db->nDb; i++){300 pDb = &db->aDb[i];301 if( pDb->pBt==0 ) continue;302 if( sqlite3DbIsNamed(db, i, zName) ) break;303 }304 305 if( i>=db->nDb ){306 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);307 goto detach_error;308 }309 if( i<2 ){310 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);311 goto detach_error;312 }313 if( sqlite3BtreeTxnState(pDb->pBt)!=SQLITE_TXN_NONE314 || sqlite3BtreeIsInBackup(pDb->pBt)315 ){316 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);317 goto detach_error;318 }319 320 /* If any TEMP triggers reference the schema being detached, move those321 ** triggers to reference the TEMP schema itself. */322 assert( db->aDb[1].pSchema );323 pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);324 while( pEntry ){325 Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);326 if( pTrig->pTabSchema==pDb->pSchema ){327 pTrig->pTabSchema = pTrig->pSchema;328 }329 pEntry = sqliteHashNext(pEntry);330 }331 332 sqlite3BtreeClose(pDb->pBt);333 pDb->pBt = 0;334 pDb->pSchema = 0;335 sqlite3CollapseDatabaseArray(db);336 return;337 338detach_error:339 sqlite3_result_error(context, zErr, -1);340}341 342/*343** This procedure generates VDBE code for a single invocation of either the344** sqlite_detach() or sqlite_attach() SQL user functions.345*/346static void codeAttach(347 Parse *pParse, /* The parser context */348 int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */349 FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */350 Expr *pAuthArg, /* Expression to pass to authorization callback */351 Expr *pFilename, /* Name of database file */352 Expr *pDbname, /* Name of the database to use internally */353 Expr *pKey /* Database key for encryption extension */354){355 int rc;356 NameContext sName;357 Vdbe *v;358 sqlite3* db = pParse->db;359 int regArgs;360 361 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto attach_end;362 363 if( pParse->nErr ) goto attach_end;364 memset(&sName, 0, sizeof(NameContext));365 sName.pParse = pParse;366 367 if( 368 SQLITE_OK!=resolveAttachExpr(&sName, pFilename) ||369 SQLITE_OK!=resolveAttachExpr(&sName, pDbname) ||370 SQLITE_OK!=resolveAttachExpr(&sName, pKey)371 ){372 goto attach_end;373 }374 375#ifndef SQLITE_OMIT_AUTHORIZATION376 if( ALWAYS(pAuthArg) ){377 char *zAuthArg;378 if( pAuthArg->op==TK_STRING ){379 assert( !ExprHasProperty(pAuthArg, EP_IntValue) );380 zAuthArg = pAuthArg->u.zToken;381 }else{382 zAuthArg = 0;383 }384 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);385 if(rc!=SQLITE_OK ){386 goto attach_end;387 }388 }389#endif /* SQLITE_OMIT_AUTHORIZATION */390 391 392 v = sqlite3GetVdbe(pParse);393 regArgs = sqlite3GetTempRange(pParse, 4);394 sqlite3ExprCode(pParse, pFilename, regArgs);395 sqlite3ExprCode(pParse, pDbname, regArgs+1);396 sqlite3ExprCode(pParse, pKey, regArgs+2);397 398 assert( v || db->mallocFailed );399 if( v ){400 sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,401 pFunc->nArg, pFunc, 0);402 /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this403 ** statement only). For DETACH, set it to false (expire all existing404 ** statements).405 */406 sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));407 }408 409attach_end:410 sqlite3ExprDelete(db, pFilename);411 sqlite3ExprDelete(db, pDbname);412 sqlite3ExprDelete(db, pKey);413}414 415/*416** Called by the parser to compile a DETACH statement.417**418** DETACH pDbname419*/420void sqlite3Detach(Parse *pParse, Expr *pDbname){421 static const FuncDef detach_func = {422 1, /* nArg */423 SQLITE_UTF8, /* funcFlags */424 0, /* pUserData */425 0, /* pNext */426 detachFunc, /* xSFunc */427 0, /* xFinalize */428 0, 0, /* xValue, xInverse */429 "sqlite_detach", /* zName */430 {0}431 };432 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);433}434 435/*436** Called by the parser to compile an ATTACH statement.437**438** ATTACH p AS pDbname KEY pKey439*/440void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){441 static const FuncDef attach_func = {442 3, /* nArg */443 SQLITE_UTF8, /* funcFlags */444 0, /* pUserData */445 0, /* pNext */446 attachFunc, /* xSFunc */447 0, /* xFinalize */448 0, 0, /* xValue, xInverse */449 "sqlite_attach", /* zName */450 {0}451 };452 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);453}454#endif /* SQLITE_OMIT_ATTACH */455 456/*457** Expression callback used by sqlite3FixAAAA() routines.458*/459static int fixExprCb(Walker *p, Expr *pExpr){460 DbFixer *pFix = p->u.pFix;461 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);462 if( pExpr->op==TK_VARIABLE ){463 if( pFix->pParse->db->init.busy ){464 pExpr->op = TK_NULL;465 }else{466 sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);467 return WRC_Abort;468 }469 }470 return WRC_Continue;471}472 473/*474** Select callback used by sqlite3FixAAAA() routines.475*/476static int fixSelectCb(Walker *p, Select *pSelect){477 DbFixer *pFix = p->u.pFix;478 int i;479 SrcItem *pItem;480 sqlite3 *db = pFix->pParse->db;481 int iDb = sqlite3FindDbName(db, pFix->zDb);482 SrcList *pList = pSelect->pSrc;483 484 if( NEVER(pList==0) ) return WRC_Continue;485 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){486 if( pFix->bTemp==0 && pItem->fg.isSubquery==0 ){487 if( pItem->fg.fixedSchema==0 && pItem->u4.zDatabase!=0 ){488 if( iDb!=sqlite3FindDbName(db, pItem->u4.zDatabase) ){489 sqlite3ErrorMsg(pFix->pParse,490 "%s %T cannot reference objects in database %s",491 pFix->zType, pFix->pName, pItem->u4.zDatabase);492 return WRC_Abort;493 }494 sqlite3DbFree(db, pItem->u4.zDatabase);495 pItem->fg.notCte = 1;496 pItem->fg.hadSchema = 1;497 }498 pItem->u4.pSchema = pFix->pSchema;499 pItem->fg.fromDDL = 1;500 pItem->fg.fixedSchema = 1;501 }502#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)503 if( pList->a[i].fg.isUsing==0504 && sqlite3WalkExpr(&pFix->w, pList->a[i].u3.pOn)505 ){506 return WRC_Abort;507 }508#endif509 }510 if( pSelect->pWith ){511 for(i=0; i<pSelect->pWith->nCte; i++){512 if( sqlite3WalkSelect(p, pSelect->pWith->a[i].pSelect) ){513 return WRC_Abort;514 }515 }516 }517 return WRC_Continue;518}519 520/*521** Initialize a DbFixer structure. This routine must be called prior522** to passing the structure to one of the sqliteFixAAAA() routines below.523*/524void sqlite3FixInit(525 DbFixer *pFix, /* The fixer to be initialized */526 Parse *pParse, /* Error messages will be written here */527 int iDb, /* This is the database that must be used */528 const char *zType, /* "view", "trigger", or "index" */529 const Token *pName /* Name of the view, trigger, or index */530){531 sqlite3 *db = pParse->db;532 assert( db->nDb>iDb );533 pFix->pParse = pParse;534 pFix->zDb = db->aDb[iDb].zDbSName;535 pFix->pSchema = db->aDb[iDb].pSchema;536 pFix->zType = zType;537 pFix->pName = pName;538 pFix->bTemp = (iDb==1);539 pFix->w.pParse = pParse;540 pFix->w.xExprCallback = fixExprCb;541 pFix->w.xSelectCallback = fixSelectCb;542 pFix->w.xSelectCallback2 = sqlite3WalkWinDefnDummyCallback;543 pFix->w.walkerDepth = 0;544 pFix->w.eCode = 0;545 pFix->w.u.pFix = pFix;546}547 548/*549** The following set of routines walk through the parse tree and assign550** a specific database to all table references where the database name551** was left unspecified in the original SQL statement. The pFix structure552** must have been initialized by a prior call to sqlite3FixInit().553**554** These routines are used to make sure that an index, trigger, or555** view in one database does not refer to objects in a different database.556** (Exception: indices, triggers, and views in the TEMP database are557** allowed to refer to anything.) If a reference is explicitly made558** to an object in a different database, an error message is added to559** pParse->zErrMsg and these routines return non-zero. If everything560** checks out, these routines return 0.561*/562int sqlite3FixSrcList(563 DbFixer *pFix, /* Context of the fixation */564 SrcList *pList /* The Source list to check and modify */565){566 int res = 0;567 if( pList ){568 Select s; 569 memset(&s, 0, sizeof(s));570 s.pSrc = pList;571 res = sqlite3WalkSelect(&pFix->w, &s);572 }573 return res;574}575#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)576int sqlite3FixSelect(577 DbFixer *pFix, /* Context of the fixation */578 Select *pSelect /* The SELECT statement to be fixed to one database */579){580 return sqlite3WalkSelect(&pFix->w, pSelect);581}582int sqlite3FixExpr(583 DbFixer *pFix, /* Context of the fixation */584 Expr *pExpr /* The expression to be fixed to one database */585){586 return sqlite3WalkExpr(&pFix->w, pExpr);587}588#endif589 590#ifndef SQLITE_OMIT_TRIGGER591int sqlite3FixTriggerStep(592 DbFixer *pFix, /* Context of the fixation */593 TriggerStep *pStep /* The trigger step be fixed to one database */594){595 while( pStep ){596 if( sqlite3WalkSelect(&pFix->w, pStep->pSelect)597 || sqlite3WalkExpr(&pFix->w, pStep->pWhere) 598 || sqlite3WalkExprList(&pFix->w, pStep->pExprList)599 || sqlite3FixSrcList(pFix, pStep->pSrc)600 ){601 return 1;602 }603#ifndef SQLITE_OMIT_UPSERT604 {605 Upsert *pUp;606 for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){607 if( sqlite3WalkExprList(&pFix->w, pUp->pUpsertTarget)608 || sqlite3WalkExpr(&pFix->w, pUp->pUpsertTargetWhere)609 || sqlite3WalkExprList(&pFix->w, pUp->pUpsertSet)610 || sqlite3WalkExpr(&pFix->w, pUp->pUpsertWhere)611 ){612 return 1;613 }614 }615 }616#endif617 pStep = pStep->pNext;618 }619 620 return 0;621}622#endif623