attach.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:15k
源码类别:

数据库系统

开发平台:

C/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. ** $Id: attach.c,v 1.74 2008/03/20 14:03:29 drh Exp $
  15. */
  16. #include "sqliteInt.h"
  17. #ifndef SQLITE_OMIT_ATTACH
  18. /*
  19. ** Resolve an expression that was part of an ATTACH or DETACH statement. This
  20. ** is slightly different from resolving a normal SQL expression, because simple
  21. ** identifiers are treated as strings, not possible column names or aliases.
  22. **
  23. ** i.e. if the parser sees:
  24. **
  25. **     ATTACH DATABASE abc AS def
  26. **
  27. ** it treats the two expressions as literal strings 'abc' and 'def' instead of
  28. ** looking for columns of the same name.
  29. **
  30. ** This only applies to the root node of pExpr, so the statement:
  31. **
  32. **     ATTACH DATABASE abc||def AS 'db2'
  33. **
  34. ** will fail because neither abc or def can be resolved.
  35. */
  36. static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
  37. {
  38.   int rc = SQLITE_OK;
  39.   if( pExpr ){
  40.     if( pExpr->op!=TK_ID ){
  41.       rc = sqlite3ExprResolveNames(pName, pExpr);
  42.       if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
  43.         sqlite3ErrorMsg(pName->pParse, "invalid name: "%T"", &pExpr->span);
  44.         return SQLITE_ERROR;
  45.       }
  46.     }else{
  47.       pExpr->op = TK_STRING;
  48.     }
  49.   }
  50.   return rc;
  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. */
  63. static void attachFunc(
  64.   sqlite3_context *context,
  65.   int argc,
  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.   char zErr[128];
  76.   zFile = (const char *)sqlite3_value_text(argv[0]);
  77.   zName = (const char *)sqlite3_value_text(argv[1]);
  78.   if( zFile==0 ) zFile = "";
  79.   if( zName==0 ) zName = "";
  80.   /* Check for the following errors:
  81.   **
  82.   **     * Too many attached databases,
  83.   **     * Transaction currently open
  84.   **     * Specified database name already being used.
  85.   */
  86.   if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
  87.     sqlite3_snprintf(
  88.       sizeof(zErr), zErr, "too many attached databases - max %d", 
  89.       db->aLimit[SQLITE_LIMIT_ATTACHED]
  90.     );
  91.     goto attach_error;
  92.   }
  93.   if( !db->autoCommit ){
  94.     sqlite3_snprintf(sizeof(zErr), zErr,
  95.                      "cannot ATTACH database within transaction");
  96.     goto attach_error;
  97.   }
  98.   for(i=0; i<db->nDb; i++){
  99.     char *z = db->aDb[i].zName;
  100.     if( z && zName && sqlite3StrICmp(z, zName)==0 ){
  101.       sqlite3_snprintf(sizeof(zErr), zErr, 
  102.                        "database %s is already in use", zName);
  103.       goto attach_error;
  104.     }
  105.   }
  106.   /* Allocate the new entry in the db->aDb[] array and initialise the schema
  107.   ** hash tables.
  108.   */
  109.   if( db->aDb==db->aDbStatic ){
  110.     aNew = sqlite3_malloc( sizeof(db->aDb[0])*3 );
  111.     if( aNew==0 ){
  112.       db->mallocFailed = 1;
  113.       return;
  114.     }
  115.     memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
  116.   }else{
  117.     aNew = sqlite3_realloc(db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
  118.     if( aNew==0 ){
  119.       db->mallocFailed = 1;
  120.       return;
  121.     } 
  122.   }
  123.   db->aDb = aNew;
  124.   aNew = &db->aDb[db->nDb++];
  125.   memset(aNew, 0, sizeof(*aNew));
  126.   /* Open the database file. If the btree is successfully opened, use
  127.   ** it to obtain the database schema. At this point the schema may
  128.   ** or may not be initialised.
  129.   */
  130.   rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE,
  131.                            db->openFlags | SQLITE_OPEN_MAIN_DB,
  132.                            &aNew->pBt);
  133.   if( rc==SQLITE_OK ){
  134.     aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
  135.     if( !aNew->pSchema ){
  136.       rc = SQLITE_NOMEM;
  137.     }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
  138.       sqlite3_snprintf(sizeof(zErr), zErr, 
  139.         "attached databases must use the same text encoding as main database");
  140.       goto attach_error;
  141.     }
  142.     sqlite3PagerLockingMode(sqlite3BtreePager(aNew->pBt), db->dfltLockMode);
  143.   }
  144.   aNew->zName = sqlite3DbStrDup(db, zName);
  145.   aNew->safety_level = 3;
  146. #if SQLITE_HAS_CODEC
  147.   {
  148.     extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
  149.     extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
  150.     int nKey;
  151.     char *zKey;
  152.     int t = sqlite3_value_type(argv[2]);
  153.     switch( t ){
  154.       case SQLITE_INTEGER:
  155.       case SQLITE_FLOAT:
  156.         zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
  157.         rc = SQLITE_ERROR;
  158.         break;
  159.         
  160.       case SQLITE_TEXT:
  161.       case SQLITE_BLOB:
  162.         nKey = sqlite3_value_bytes(argv[2]);
  163.         zKey = (char *)sqlite3_value_blob(argv[2]);
  164.         sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
  165.         break;
  166.       case SQLITE_NULL:
  167.         /* No key specified.  Use the key from the main database */
  168.         sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
  169.         sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
  170.         break;
  171.     }
  172.   }
  173. #endif
  174.   /* If the file was opened successfully, read the schema for the new database.
  175.   ** If this fails, or if opening the file failed, then close the file and 
  176.   ** remove the entry from the db->aDb[] array. i.e. put everything back the way
  177.   ** we found it.
  178.   */
  179.   if( rc==SQLITE_OK ){
  180.     (void)sqlite3SafetyOn(db);
  181.     sqlite3BtreeEnterAll(db);
  182.     rc = sqlite3Init(db, &zErrDyn);
  183.     sqlite3BtreeLeaveAll(db);
  184.     (void)sqlite3SafetyOff(db);
  185.   }
  186.   if( rc ){
  187.     int iDb = db->nDb - 1;
  188.     assert( iDb>=2 );
  189.     if( db->aDb[iDb].pBt ){
  190.       sqlite3BtreeClose(db->aDb[iDb].pBt);
  191.       db->aDb[iDb].pBt = 0;
  192.       db->aDb[iDb].pSchema = 0;
  193.     }
  194.     sqlite3ResetInternalSchema(db, 0);
  195.     db->nDb = iDb;
  196.     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
  197.       db->mallocFailed = 1;
  198.       sqlite3_snprintf(sizeof(zErr),zErr, "out of memory");
  199.     }else{
  200.       sqlite3_snprintf(sizeof(zErr),zErr, "unable to open database: %s", zFile);
  201.     }
  202.     goto attach_error;
  203.   }
  204.   
  205.   return;
  206. attach_error:
  207.   /* Return an error if we get here */
  208.   if( zErrDyn ){
  209.     sqlite3_result_error(context, zErrDyn, -1);
  210.     sqlite3_free(zErrDyn);
  211.   }else{
  212.     zErr[sizeof(zErr)-1] = 0;
  213.     sqlite3_result_error(context, zErr, -1);
  214.   }
  215.   if( rc ) sqlite3_result_error_code(context, rc);
  216. }
  217. /*
  218. ** An SQL user-function registered to do the work of an DETACH statement. The
  219. ** three arguments to the function come directly from a detach statement:
  220. **
  221. **     DETACH DATABASE x
  222. **
  223. **     SELECT sqlite_detach(x)
  224. */
  225. static void detachFunc(
  226.   sqlite3_context *context,
  227.   int argc,
  228.   sqlite3_value **argv
  229. ){
  230.   const char *zName = (const char *)sqlite3_value_text(argv[0]);
  231.   sqlite3 *db = sqlite3_context_db_handle(context);
  232.   int i;
  233.   Db *pDb = 0;
  234.   char zErr[128];
  235.   if( zName==0 ) zName = "";
  236.   for(i=0; i<db->nDb; i++){
  237.     pDb = &db->aDb[i];
  238.     if( pDb->pBt==0 ) continue;
  239.     if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
  240.   }
  241.   if( i>=db->nDb ){
  242.     sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
  243.     goto detach_error;
  244.   }
  245.   if( i<2 ){
  246.     sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
  247.     goto detach_error;
  248.   }
  249.   if( !db->autoCommit ){
  250.     sqlite3_snprintf(sizeof(zErr), zErr,
  251.                      "cannot DETACH database within transaction");
  252.     goto detach_error;
  253.   }
  254.   if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){
  255.     sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
  256.     goto detach_error;
  257.   }
  258.   sqlite3BtreeClose(pDb->pBt);
  259.   pDb->pBt = 0;
  260.   pDb->pSchema = 0;
  261.   sqlite3ResetInternalSchema(db, 0);
  262.   return;
  263. detach_error:
  264.   sqlite3_result_error(context, zErr, -1);
  265. }
  266. /*
  267. ** This procedure generates VDBE code for a single invocation of either the
  268. ** sqlite_detach() or sqlite_attach() SQL user functions.
  269. */
  270. static void codeAttach(
  271.   Parse *pParse,       /* The parser context */
  272.   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
  273.   const char *zFunc,   /* Either "sqlite_attach" or "sqlite_detach */
  274.   int nFunc,           /* Number of args to pass to zFunc */
  275.   Expr *pAuthArg,      /* Expression to pass to authorization callback */
  276.   Expr *pFilename,     /* Name of database file */
  277.   Expr *pDbname,       /* Name of the database to use internally */
  278.   Expr *pKey           /* Database key for encryption extension */
  279. ){
  280.   int rc;
  281.   NameContext sName;
  282.   Vdbe *v;
  283.   FuncDef *pFunc;
  284.   sqlite3* db = pParse->db;
  285.   int regArgs;
  286. #ifndef SQLITE_OMIT_AUTHORIZATION
  287.   assert( db->mallocFailed || pAuthArg );
  288.   if( pAuthArg ){
  289.     char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span);
  290.     if( !zAuthArg ){
  291.       goto attach_end;
  292.     }
  293.     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
  294.     sqlite3_free(zAuthArg);
  295.     if(rc!=SQLITE_OK ){
  296.       goto attach_end;
  297.     }
  298.   }
  299. #endif /* SQLITE_OMIT_AUTHORIZATION */
  300.   memset(&sName, 0, sizeof(NameContext));
  301.   sName.pParse = pParse;
  302.   if( 
  303.       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
  304.       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
  305.       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
  306.   ){
  307.     pParse->nErr++;
  308.     goto attach_end;
  309.   }
  310.   v = sqlite3GetVdbe(pParse);
  311.   regArgs = sqlite3GetTempRange(pParse, 4);
  312.   sqlite3ExprCode(pParse, pFilename, regArgs);
  313.   sqlite3ExprCode(pParse, pDbname, regArgs+1);
  314.   sqlite3ExprCode(pParse, pKey, regArgs+2);
  315.   assert( v || db->mallocFailed );
  316.   if( v ){
  317.     sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs+3);
  318.     sqlite3VdbeChangeP5(v, nFunc);
  319.     pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);
  320.     sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
  321.     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
  322.     ** statement only). For DETACH, set it to false (expire all existing
  323.     ** statements).
  324.     */
  325.     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
  326.   }
  327.   
  328. attach_end:
  329.   sqlite3ExprDelete(pFilename);
  330.   sqlite3ExprDelete(pDbname);
  331.   sqlite3ExprDelete(pKey);
  332. }
  333. /*
  334. ** Called by the parser to compile a DETACH statement.
  335. **
  336. **     DETACH pDbname
  337. */
  338. void sqlite3Detach(Parse *pParse, Expr *pDbname){
  339.   codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname);
  340. }
  341. /*
  342. ** Called by the parser to compile an ATTACH statement.
  343. **
  344. **     ATTACH p AS pDbname KEY pKey
  345. */
  346. void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
  347.   codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey);
  348. }
  349. #endif /* SQLITE_OMIT_ATTACH */
  350. /*
  351. ** Register the functions sqlite_attach and sqlite_detach.
  352. */
  353. void sqlite3AttachFunctions(sqlite3 *db){
  354. #ifndef SQLITE_OMIT_ATTACH
  355.   static const int enc = SQLITE_UTF8;
  356.   sqlite3CreateFunc(db, "sqlite_attach", 3, enc, 0, attachFunc, 0, 0);
  357.   sqlite3CreateFunc(db, "sqlite_detach", 1, enc, 0, detachFunc, 0, 0);
  358. #endif
  359. }
  360. /*
  361. ** Initialize a DbFixer structure.  This routine must be called prior
  362. ** to passing the structure to one of the sqliteFixAAAA() routines below.
  363. **
  364. ** The return value indicates whether or not fixation is required.  TRUE
  365. ** means we do need to fix the database references, FALSE means we do not.
  366. */
  367. int sqlite3FixInit(
  368.   DbFixer *pFix,      /* The fixer to be initialized */
  369.   Parse *pParse,      /* Error messages will be written here */
  370.   int iDb,            /* This is the database that must be used */
  371.   const char *zType,  /* "view", "trigger", or "index" */
  372.   const Token *pName  /* Name of the view, trigger, or index */
  373. ){
  374.   sqlite3 *db;
  375.   if( iDb<0 || iDb==1 ) return 0;
  376.   db = pParse->db;
  377.   assert( db->nDb>iDb );
  378.   pFix->pParse = pParse;
  379.   pFix->zDb = db->aDb[iDb].zName;
  380.   pFix->zType = zType;
  381.   pFix->pName = pName;
  382.   return 1;
  383. }
  384. /*
  385. ** The following set of routines walk through the parse tree and assign
  386. ** a specific database to all table references where the database name
  387. ** was left unspecified in the original SQL statement.  The pFix structure
  388. ** must have been initialized by a prior call to sqlite3FixInit().
  389. **
  390. ** These routines are used to make sure that an index, trigger, or
  391. ** view in one database does not refer to objects in a different database.
  392. ** (Exception: indices, triggers, and views in the TEMP database are
  393. ** allowed to refer to anything.)  If a reference is explicitly made
  394. ** to an object in a different database, an error message is added to
  395. ** pParse->zErrMsg and these routines return non-zero.  If everything
  396. ** checks out, these routines return 0.
  397. */
  398. int sqlite3FixSrcList(
  399.   DbFixer *pFix,       /* Context of the fixation */
  400.   SrcList *pList       /* The Source list to check and modify */
  401. ){
  402.   int i;
  403.   const char *zDb;
  404.   struct SrcList_item *pItem;
  405.   if( pList==0 ) return 0;
  406.   zDb = pFix->zDb;
  407.   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
  408.     if( pItem->zDatabase==0 ){
  409.       pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);
  410.     }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){
  411.       sqlite3ErrorMsg(pFix->pParse,
  412.          "%s %T cannot reference objects in database %s",
  413.          pFix->zType, pFix->pName, pItem->zDatabase);
  414.       return 1;
  415.     }
  416. #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
  417.     if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
  418.     if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
  419. #endif
  420.   }
  421.   return 0;
  422. }
  423. #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
  424. int sqlite3FixSelect(
  425.   DbFixer *pFix,       /* Context of the fixation */
  426.   Select *pSelect      /* The SELECT statement to be fixed to one database */
  427. ){
  428.   while( pSelect ){
  429.     if( sqlite3FixExprList(pFix, pSelect->pEList) ){
  430.       return 1;
  431.     }
  432.     if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
  433.       return 1;
  434.     }
  435.     if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
  436.       return 1;
  437.     }
  438.     if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
  439.       return 1;
  440.     }
  441.     pSelect = pSelect->pPrior;
  442.   }
  443.   return 0;
  444. }
  445. int sqlite3FixExpr(
  446.   DbFixer *pFix,     /* Context of the fixation */
  447.   Expr *pExpr        /* The expression to be fixed to one database */
  448. ){
  449.   while( pExpr ){
  450.     if( sqlite3FixSelect(pFix, pExpr->pSelect) ){
  451.       return 1;
  452.     }
  453.     if( sqlite3FixExprList(pFix, pExpr->pList) ){
  454.       return 1;
  455.     }
  456.     if( sqlite3FixExpr(pFix, pExpr->pRight) ){
  457.       return 1;
  458.     }
  459.     pExpr = pExpr->pLeft;
  460.   }
  461.   return 0;
  462. }
  463. int sqlite3FixExprList(
  464.   DbFixer *pFix,     /* Context of the fixation */
  465.   ExprList *pList    /* The expression to be fixed to one database */
  466. ){
  467.   int i;
  468.   struct ExprList_item *pItem;
  469.   if( pList==0 ) return 0;
  470.   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
  471.     if( sqlite3FixExpr(pFix, pItem->pExpr) ){
  472.       return 1;
  473.     }
  474.   }
  475.   return 0;
  476. }
  477. #endif
  478. #ifndef SQLITE_OMIT_TRIGGER
  479. int sqlite3FixTriggerStep(
  480.   DbFixer *pFix,     /* Context of the fixation */
  481.   TriggerStep *pStep /* The trigger step be fixed to one database */
  482. ){
  483.   while( pStep ){
  484.     if( sqlite3FixSelect(pFix, pStep->pSelect) ){
  485.       return 1;
  486.     }
  487.     if( sqlite3FixExpr(pFix, pStep->pWhere) ){
  488.       return 1;
  489.     }
  490.     if( sqlite3FixExprList(pFix, pStep->pExprList) ){
  491.       return 1;
  492.     }
  493.     pStep = pStep->pNext;
  494.   }
  495.   return 0;
  496. }
  497. #endif