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