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