4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains code used to implement the ATTACH and DETACH commands.
14 #include "sqliteInt.h"
16 #ifndef SQLITE_OMIT_ATTACH
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.
22 ** i.e. if the parser sees:
24 ** ATTACH DATABASE abc AS def
26 ** it treats the two expressions as literal strings 'abc' and 'def' instead of
27 ** looking for columns of the same name.
29 ** This only applies to the root node of pExpr, so the statement:
31 ** ATTACH DATABASE abc||def AS 'db2'
33 ** will fail because neither abc or def can be resolved.
35 static int resolveAttachExpr(NameContext
*pName
, Expr
*pExpr
)
39 if( pExpr
->op
!=TK_ID
){
40 rc
= sqlite3ResolveExprNames(pName
, pExpr
);
42 pExpr
->op
= TK_STRING
;
49 ** Return true if zName points to a name that may be used to refer to
50 ** database iDb attached to handle db.
52 int sqlite3DbIsNamed(sqlite3
*db
, int iDb
, const char *zName
){
54 sqlite3StrICmp(db
->aDb
[iDb
].zDbSName
, zName
)==0
55 || (iDb
==0 && sqlite3StrICmp("main", zName
)==0)
60 ** An SQL user-function registered to do the work of an ATTACH statement. The
61 ** three arguments to the function come directly from an attach statement:
63 ** ATTACH DATABASE x AS y KEY z
65 ** SELECT sqlite_attach(x, y, z)
67 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
70 ** If the db->init.reopenMemdb flags is set, then instead of attaching a
71 ** new database, close the database on db->init.iDb and reopen it as an
74 static void attachFunc(
75 sqlite3_context
*context
,
81 sqlite3
*db
= sqlite3_context_db_handle(context
);
87 Db
*aNew
; /* New array of Db pointers */
88 Db
*pNew
; /* Db object for the newly attached database */
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
= "";
98 #ifdef SQLITE_ENABLE_DESERIALIZE
99 # define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb)
101 # define REOPEN_AS_MEMDB(db) (0)
104 if( REOPEN_AS_MEMDB(db
) ){
105 /* This is not a real ATTACH. Instead, this routine is being called
106 ** from sqlite3_deserialize() to close database db->init.iDb and
107 ** reopen it as a MemDB */
108 pVfs
= sqlite3_vfs_find("memdb");
109 if( pVfs
==0 ) return;
110 pNew
= &db
->aDb
[db
->init
.iDb
];
111 if( pNew
->pBt
) sqlite3BtreeClose(pNew
->pBt
);
114 rc
= sqlite3BtreeOpen(pVfs
, "x\0", db
, &pNew
->pBt
, 0, SQLITE_OPEN_MAIN_DB
);
116 /* This is a real ATTACH
118 ** Check for the following errors:
120 ** * Too many attached databases,
121 ** * Transaction currently open
122 ** * Specified database name already being used.
124 if( db
->nDb
>=db
->aLimit
[SQLITE_LIMIT_ATTACHED
]+2 ){
125 zErrDyn
= sqlite3MPrintf(db
, "too many attached databases - max %d",
126 db
->aLimit
[SQLITE_LIMIT_ATTACHED
]
130 for(i
=0; i
<db
->nDb
; i
++){
132 if( sqlite3DbIsNamed(db
, i
, zName
) ){
133 zErrDyn
= sqlite3MPrintf(db
, "database %s is already in use", zName
);
138 /* Allocate the new entry in the db->aDb[] array and initialize the schema
141 if( db
->aDb
==db
->aDbStatic
){
142 aNew
= sqlite3DbMallocRawNN(db
, sizeof(db
->aDb
[0])*3 );
143 if( aNew
==0 ) return;
144 memcpy(aNew
, db
->aDb
, sizeof(db
->aDb
[0])*2);
146 aNew
= sqlite3DbRealloc(db
, db
->aDb
, sizeof(db
->aDb
[0])*(db
->nDb
+1) );
147 if( aNew
==0 ) return;
150 pNew
= &db
->aDb
[db
->nDb
];
151 memset(pNew
, 0, sizeof(*pNew
));
153 /* Open the database file. If the btree is successfully opened, use
154 ** it to obtain the database schema. At this point the schema may
155 ** or may not be initialized.
157 flags
= db
->openFlags
;
158 rc
= sqlite3ParseUri(db
->pVfs
->zName
, zFile
, &flags
, &pVfs
, &zPath
, &zErr
);
160 if( rc
==SQLITE_NOMEM
) sqlite3OomFault(db
);
161 sqlite3_result_error(context
, zErr
, -1);
166 flags
|= SQLITE_OPEN_MAIN_DB
;
167 rc
= sqlite3BtreeOpen(pVfs
, zPath
, db
, &pNew
->pBt
, 0, flags
);
169 pNew
->zDbSName
= sqlite3DbStrDup(db
, zName
);
171 db
->noSharedCache
= 0;
172 if( rc
==SQLITE_CONSTRAINT
){
174 zErrDyn
= sqlite3MPrintf(db
, "database is already attached");
175 }else if( rc
==SQLITE_OK
){
177 pNew
->pSchema
= sqlite3SchemaGet(db
, pNew
->pBt
);
178 if( !pNew
->pSchema
){
179 rc
= SQLITE_NOMEM_BKPT
;
180 }else if( pNew
->pSchema
->file_format
&& pNew
->pSchema
->enc
!=ENC(db
) ){
181 zErrDyn
= sqlite3MPrintf(db
,
182 "attached databases must use the same text encoding as main database");
185 sqlite3BtreeEnter(pNew
->pBt
);
186 pPager
= sqlite3BtreePager(pNew
->pBt
);
187 sqlite3PagerLockingMode(pPager
, db
->dfltLockMode
);
188 sqlite3BtreeSecureDelete(pNew
->pBt
,
189 sqlite3BtreeSecureDelete(db
->aDb
[0].pBt
,-1) );
190 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
191 sqlite3BtreeSetPagerFlags(pNew
->pBt
,
192 PAGER_SYNCHRONOUS_FULL
| (db
->flags
& PAGER_FLAGS_MASK
));
194 sqlite3BtreeLeave(pNew
->pBt
);
196 pNew
->safety_level
= SQLITE_DEFAULT_SYNCHRONOUS
+1;
197 if( rc
==SQLITE_OK
&& pNew
->zDbSName
==0 ){
198 rc
= SQLITE_NOMEM_BKPT
;
201 /* BEGIN SQLCIPHER */
202 #ifdef SQLITE_HAS_CODEC
204 extern int sqlite3CodecAttach(sqlite3
*, int, const void*, int);
205 extern void sqlite3CodecGetKey(sqlite3
*, int, void**, int*);
208 int t
= sqlite3_value_type(argv
[2]);
212 zErrDyn
= sqlite3DbStrDup(db
, "Invalid key value");
218 nKey
= sqlite3_value_bytes(argv
[2]);
219 zKey
= (char *)sqlite3_value_blob(argv
[2]);
220 rc
= sqlite3CodecAttach(db
, db
->nDb
-1, zKey
, nKey
);
224 /* No key specified. Use the key from URI filename, or if none,
225 ** use the key from the main database. */
226 if( sqlite3CodecQueryParameters(db
, zName
, zPath
)==0 ){
227 sqlite3CodecGetKey(db
, 0, (void**)&zKey
, &nKey
);
228 if( nKey
|| sqlite3BtreeGetRequestedReserve(db
->aDb
[0].pBt
)>0 ){
229 rc
= sqlite3CodecAttach(db
, db
->nDb
-1, zKey
, nKey
);
237 sqlite3_free_filename( zPath
);
239 /* If the file was opened successfully, read the schema for the new database.
240 ** If this fails, or if opening the file failed, then close the file and
241 ** remove the entry from the db->aDb[] array. i.e. put everything back the
245 sqlite3BtreeEnterAll(db
);
247 db
->mDbFlags
&= ~(DBFLAG_SchemaKnownOk
);
248 if( !REOPEN_AS_MEMDB(db
) ){
249 rc
= sqlite3Init(db
, &zErrDyn
);
251 sqlite3BtreeLeaveAll(db
);
252 assert( zErrDyn
==0 || rc
!=SQLITE_OK
);
254 #ifdef SQLITE_USER_AUTHENTICATION
255 if( rc
==SQLITE_OK
&& !REOPEN_AS_MEMDB(db
) ){
257 rc
= sqlite3UserAuthCheckLogin(db
, zName
, &newAuth
);
258 if( newAuth
<db
->auth
.authLevel
){
259 rc
= SQLITE_AUTH_USER
;
264 if( !REOPEN_AS_MEMDB(db
) ){
265 int iDb
= db
->nDb
- 1;
267 if( db
->aDb
[iDb
].pBt
){
268 sqlite3BtreeClose(db
->aDb
[iDb
].pBt
);
269 db
->aDb
[iDb
].pBt
= 0;
270 db
->aDb
[iDb
].pSchema
= 0;
272 sqlite3ResetAllSchemasOfConnection(db
);
274 if( rc
==SQLITE_NOMEM
|| rc
==SQLITE_IOERR_NOMEM
){
276 sqlite3DbFree(db
, zErrDyn
);
277 zErrDyn
= sqlite3MPrintf(db
, "out of memory");
278 }else if( zErrDyn
==0 ){
279 zErrDyn
= sqlite3MPrintf(db
, "unable to open database: %s", zFile
);
288 /* Return an error if we get here */
290 sqlite3_result_error(context
, zErrDyn
, -1);
291 sqlite3DbFree(db
, zErrDyn
);
293 if( rc
) sqlite3_result_error_code(context
, rc
);
297 ** An SQL user-function registered to do the work of an DETACH statement. The
298 ** three arguments to the function come directly from a detach statement:
302 ** SELECT sqlite_detach(x)
304 static void detachFunc(
305 sqlite3_context
*context
,
309 const char *zName
= (const char *)sqlite3_value_text(argv
[0]);
310 sqlite3
*db
= sqlite3_context_db_handle(context
);
316 UNUSED_PARAMETER(NotUsed
);
318 if( zName
==0 ) zName
= "";
319 for(i
=0; i
<db
->nDb
; i
++){
321 if( pDb
->pBt
==0 ) continue;
322 if( sqlite3DbIsNamed(db
, i
, zName
) ) break;
326 sqlite3_snprintf(sizeof(zErr
),zErr
, "no such database: %s", zName
);
330 sqlite3_snprintf(sizeof(zErr
),zErr
, "cannot detach database %s", zName
);
333 if( sqlite3BtreeIsInReadTrans(pDb
->pBt
) || sqlite3BtreeIsInBackup(pDb
->pBt
) ){
334 sqlite3_snprintf(sizeof(zErr
),zErr
, "database %s is locked", zName
);
338 /* If any TEMP triggers reference the schema being detached, move those
339 ** triggers to reference the TEMP schema itself. */
340 assert( db
->aDb
[1].pSchema
);
341 pEntry
= sqliteHashFirst(&db
->aDb
[1].pSchema
->trigHash
);
343 Trigger
*pTrig
= (Trigger
*)sqliteHashData(pEntry
);
344 if( pTrig
->pTabSchema
==pDb
->pSchema
){
345 pTrig
->pTabSchema
= pTrig
->pSchema
;
347 pEntry
= sqliteHashNext(pEntry
);
350 sqlite3BtreeClose(pDb
->pBt
);
353 sqlite3CollapseDatabaseArray(db
);
357 sqlite3_result_error(context
, zErr
, -1);
361 ** This procedure generates VDBE code for a single invocation of either the
362 ** sqlite_detach() or sqlite_attach() SQL user functions.
364 static void codeAttach(
365 Parse
*pParse
, /* The parser context */
366 int type
, /* Either SQLITE_ATTACH or SQLITE_DETACH */
367 FuncDef
const *pFunc
,/* FuncDef wrapper for detachFunc() or attachFunc() */
368 Expr
*pAuthArg
, /* Expression to pass to authorization callback */
369 Expr
*pFilename
, /* Name of database file */
370 Expr
*pDbname
, /* Name of the database to use internally */
371 Expr
*pKey
/* Database key for encryption extension */
376 sqlite3
* db
= pParse
->db
;
379 if( pParse
->nErr
) goto attach_end
;
380 memset(&sName
, 0, sizeof(NameContext
));
381 sName
.pParse
= pParse
;
384 SQLITE_OK
!=(rc
= resolveAttachExpr(&sName
, pFilename
)) ||
385 SQLITE_OK
!=(rc
= resolveAttachExpr(&sName
, pDbname
)) ||
386 SQLITE_OK
!=(rc
= resolveAttachExpr(&sName
, pKey
))
391 #ifndef SQLITE_OMIT_AUTHORIZATION
394 if( pAuthArg
->op
==TK_STRING
){
395 zAuthArg
= pAuthArg
->u
.zToken
;
399 rc
= sqlite3AuthCheck(pParse
, type
, zAuthArg
, 0, 0);
404 #endif /* SQLITE_OMIT_AUTHORIZATION */
407 v
= sqlite3GetVdbe(pParse
);
408 regArgs
= sqlite3GetTempRange(pParse
, 4);
409 sqlite3ExprCode(pParse
, pFilename
, regArgs
);
410 sqlite3ExprCode(pParse
, pDbname
, regArgs
+1);
411 sqlite3ExprCode(pParse
, pKey
, regArgs
+2);
413 assert( v
|| db
->mallocFailed
);
415 sqlite3VdbeAddFunctionCall(pParse
, 0, regArgs
+3-pFunc
->nArg
, regArgs
+3,
416 pFunc
->nArg
, pFunc
, 0);
417 /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
418 ** statement only). For DETACH, set it to false (expire all existing
421 sqlite3VdbeAddOp1(v
, OP_Expire
, (type
==SQLITE_ATTACH
));
425 sqlite3ExprDelete(db
, pFilename
);
426 sqlite3ExprDelete(db
, pDbname
);
427 sqlite3ExprDelete(db
, pKey
);
431 ** Called by the parser to compile a DETACH statement.
435 void sqlite3Detach(Parse
*pParse
, Expr
*pDbname
){
436 static const FuncDef detach_func
= {
438 SQLITE_UTF8
, /* funcFlags */
441 detachFunc
, /* xSFunc */
443 0, 0, /* xValue, xInverse */
444 "sqlite_detach", /* zName */
447 codeAttach(pParse
, SQLITE_DETACH
, &detach_func
, pDbname
, 0, 0, pDbname
);
451 ** Called by the parser to compile an ATTACH statement.
453 ** ATTACH p AS pDbname KEY pKey
455 void sqlite3Attach(Parse
*pParse
, Expr
*p
, Expr
*pDbname
, Expr
*pKey
){
456 static const FuncDef attach_func
= {
458 SQLITE_UTF8
, /* funcFlags */
461 attachFunc
, /* xSFunc */
463 0, 0, /* xValue, xInverse */
464 "sqlite_attach", /* zName */
467 codeAttach(pParse
, SQLITE_ATTACH
, &attach_func
, p
, p
, pDbname
, pKey
);
469 #endif /* SQLITE_OMIT_ATTACH */
472 ** Initialize a DbFixer structure. This routine must be called prior
473 ** to passing the structure to one of the sqliteFixAAAA() routines below.
476 DbFixer
*pFix
, /* The fixer to be initialized */
477 Parse
*pParse
, /* Error messages will be written here */
478 int iDb
, /* This is the database that must be used */
479 const char *zType
, /* "view", "trigger", or "index" */
480 const Token
*pName
/* Name of the view, trigger, or index */
485 assert( db
->nDb
>iDb
);
486 pFix
->pParse
= pParse
;
487 pFix
->zDb
= db
->aDb
[iDb
].zDbSName
;
488 pFix
->pSchema
= db
->aDb
[iDb
].pSchema
;
491 pFix
->bTemp
= (iDb
==1);
495 ** The following set of routines walk through the parse tree and assign
496 ** a specific database to all table references where the database name
497 ** was left unspecified in the original SQL statement. The pFix structure
498 ** must have been initialized by a prior call to sqlite3FixInit().
500 ** These routines are used to make sure that an index, trigger, or
501 ** view in one database does not refer to objects in a different database.
502 ** (Exception: indices, triggers, and views in the TEMP database are
503 ** allowed to refer to anything.) If a reference is explicitly made
504 ** to an object in a different database, an error message is added to
505 ** pParse->zErrMsg and these routines return non-zero. If everything
506 ** checks out, these routines return 0.
508 int sqlite3FixSrcList(
509 DbFixer
*pFix
, /* Context of the fixation */
510 SrcList
*pList
/* The Source list to check and modify */
513 struct SrcList_item
*pItem
;
514 sqlite3
*db
= pFix
->pParse
->db
;
515 int iDb
= sqlite3FindDbName(db
, pFix
->zDb
);
517 if( NEVER(pList
==0) ) return 0;
519 for(i
=0, pItem
=pList
->a
; i
<pList
->nSrc
; i
++, pItem
++){
520 if( pFix
->bTemp
==0 ){
521 if( pItem
->zDatabase
&& iDb
!=sqlite3FindDbName(db
, pItem
->zDatabase
) ){
522 sqlite3ErrorMsg(pFix
->pParse
,
523 "%s %T cannot reference objects in database %s",
524 pFix
->zType
, pFix
->pName
, pItem
->zDatabase
);
527 sqlite3DbFree(db
, pItem
->zDatabase
);
528 pItem
->zDatabase
= 0;
529 pItem
->pSchema
= pFix
->pSchema
;
530 pItem
->fg
.fromDDL
= 1;
532 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
533 if( sqlite3FixSelect(pFix
, pItem
->pSelect
) ) return 1;
534 if( sqlite3FixExpr(pFix
, pItem
->pOn
) ) return 1;
536 if( pItem
->fg
.isTabFunc
&& sqlite3FixExprList(pFix
, pItem
->u1
.pFuncArg
) ){
542 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
543 int sqlite3FixSelect(
544 DbFixer
*pFix
, /* Context of the fixation */
545 Select
*pSelect
/* The SELECT statement to be fixed to one database */
548 if( sqlite3FixExprList(pFix
, pSelect
->pEList
) ){
551 if( sqlite3FixSrcList(pFix
, pSelect
->pSrc
) ){
554 if( sqlite3FixExpr(pFix
, pSelect
->pWhere
) ){
557 if( sqlite3FixExprList(pFix
, pSelect
->pGroupBy
) ){
560 if( sqlite3FixExpr(pFix
, pSelect
->pHaving
) ){
563 if( sqlite3FixExprList(pFix
, pSelect
->pOrderBy
) ){
566 if( sqlite3FixExpr(pFix
, pSelect
->pLimit
) ){
569 if( pSelect
->pWith
){
571 for(i
=0; i
<pSelect
->pWith
->nCte
; i
++){
572 if( sqlite3FixSelect(pFix
, pSelect
->pWith
->a
[i
].pSelect
) ){
577 pSelect
= pSelect
->pPrior
;
582 DbFixer
*pFix
, /* Context of the fixation */
583 Expr
*pExpr
/* The expression to be fixed to one database */
586 if( !pFix
->bTemp
) ExprSetProperty(pExpr
, EP_FromDDL
);
587 if( pExpr
->op
==TK_VARIABLE
){
588 if( pFix
->pParse
->db
->init
.busy
){
591 sqlite3ErrorMsg(pFix
->pParse
, "%s cannot use variables", pFix
->zType
);
595 if( ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Leaf
) ) break;
596 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
597 if( sqlite3FixSelect(pFix
, pExpr
->x
.pSelect
) ) return 1;
599 if( sqlite3FixExprList(pFix
, pExpr
->x
.pList
) ) return 1;
601 if( sqlite3FixExpr(pFix
, pExpr
->pRight
) ){
604 pExpr
= pExpr
->pLeft
;
608 int sqlite3FixExprList(
609 DbFixer
*pFix
, /* Context of the fixation */
610 ExprList
*pList
/* The expression to be fixed to one database */
613 struct ExprList_item
*pItem
;
614 if( pList
==0 ) return 0;
615 for(i
=0, pItem
=pList
->a
; i
<pList
->nExpr
; i
++, pItem
++){
616 if( sqlite3FixExpr(pFix
, pItem
->pExpr
) ){
624 #ifndef SQLITE_OMIT_TRIGGER
625 int sqlite3FixTriggerStep(
626 DbFixer
*pFix
, /* Context of the fixation */
627 TriggerStep
*pStep
/* The trigger step be fixed to one database */
630 if( sqlite3FixSelect(pFix
, pStep
->pSelect
) ){
633 if( sqlite3FixExpr(pFix
, pStep
->pWhere
) ){
636 if( sqlite3FixExprList(pFix
, pStep
->pExprList
) ){
639 if( pStep
->pFrom
&& sqlite3FixSrcList(pFix
, pStep
->pFrom
) ){
642 #ifndef SQLITE_OMIT_UPSERT
643 if( pStep
->pUpsert
){
644 Upsert
*pUp
= pStep
->pUpsert
;
645 if( sqlite3FixExprList(pFix
, pUp
->pUpsertTarget
)
646 || sqlite3FixExpr(pFix
, pUp
->pUpsertTargetWhere
)
647 || sqlite3FixExprList(pFix
, pUp
->pUpsertSet
)
648 || sqlite3FixExpr(pFix
, pUp
->pUpsertWhere
)
654 pStep
= pStep
->pNext
;