1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite364/attach.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,527 @@
1.4 +/*
1.5 +** 2003 April 6
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file contains code used to implement the ATTACH and DETACH commands.
1.16 +**
1.17 +** $Id: attach.c,v 1.78 2008/08/20 16:35:10 drh Exp $
1.18 +*/
1.19 +#include "sqliteInt.h"
1.20 +
1.21 +#ifndef SQLITE_OMIT_ATTACH
1.22 +/*
1.23 +** Resolve an expression that was part of an ATTACH or DETACH statement. This
1.24 +** is slightly different from resolving a normal SQL expression, because simple
1.25 +** identifiers are treated as strings, not possible column names or aliases.
1.26 +**
1.27 +** i.e. if the parser sees:
1.28 +**
1.29 +** ATTACH DATABASE abc AS def
1.30 +**
1.31 +** it treats the two expressions as literal strings 'abc' and 'def' instead of
1.32 +** looking for columns of the same name.
1.33 +**
1.34 +** This only applies to the root node of pExpr, so the statement:
1.35 +**
1.36 +** ATTACH DATABASE abc||def AS 'db2'
1.37 +**
1.38 +** will fail because neither abc or def can be resolved.
1.39 +*/
1.40 +static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
1.41 +{
1.42 + int rc = SQLITE_OK;
1.43 + if( pExpr ){
1.44 + if( pExpr->op!=TK_ID ){
1.45 + rc = sqlite3ResolveExprNames(pName, pExpr);
1.46 + if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
1.47 + sqlite3ErrorMsg(pName->pParse, "invalid name: \"%T\"", &pExpr->span);
1.48 + return SQLITE_ERROR;
1.49 + }
1.50 + }else{
1.51 + pExpr->op = TK_STRING;
1.52 + }
1.53 + }
1.54 + return rc;
1.55 +}
1.56 +
1.57 +/*
1.58 +** An SQL user-function registered to do the work of an ATTACH statement. The
1.59 +** three arguments to the function come directly from an attach statement:
1.60 +**
1.61 +** ATTACH DATABASE x AS y KEY z
1.62 +**
1.63 +** SELECT sqlite_attach(x, y, z)
1.64 +**
1.65 +** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
1.66 +** third argument.
1.67 +*/
1.68 +static void attachFunc(
1.69 + sqlite3_context *context,
1.70 + int argc,
1.71 + sqlite3_value **argv
1.72 +){
1.73 + int i;
1.74 + int rc = 0;
1.75 + sqlite3 *db = sqlite3_context_db_handle(context);
1.76 + const char *zName;
1.77 + const char *zFile;
1.78 + Db *aNew;
1.79 + char *zErrDyn = 0;
1.80 + char zErr[128];
1.81 +
1.82 + zFile = (const char *)sqlite3_value_text(argv[0]);
1.83 + zName = (const char *)sqlite3_value_text(argv[1]);
1.84 + if( zFile==0 ) zFile = "";
1.85 + if( zName==0 ) zName = "";
1.86 +
1.87 + /* Check for the following errors:
1.88 + **
1.89 + ** * Too many attached databases,
1.90 + ** * Transaction currently open
1.91 + ** * Specified database name already being used.
1.92 + */
1.93 + if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
1.94 + sqlite3_snprintf(
1.95 + sizeof(zErr), zErr, "too many attached databases - max %d",
1.96 + db->aLimit[SQLITE_LIMIT_ATTACHED]
1.97 + );
1.98 + goto attach_error;
1.99 + }
1.100 + if( !db->autoCommit ){
1.101 + sqlite3_snprintf(sizeof(zErr), zErr,
1.102 + "cannot ATTACH database within transaction");
1.103 + goto attach_error;
1.104 + }
1.105 + for(i=0; i<db->nDb; i++){
1.106 + char *z = db->aDb[i].zName;
1.107 + if( z && zName && sqlite3StrICmp(z, zName)==0 ){
1.108 + sqlite3_snprintf(sizeof(zErr), zErr,
1.109 + "database %s is already in use", zName);
1.110 + goto attach_error;
1.111 + }
1.112 + }
1.113 +
1.114 + /* Allocate the new entry in the db->aDb[] array and initialise the schema
1.115 + ** hash tables.
1.116 + */
1.117 + if( db->aDb==db->aDbStatic ){
1.118 + aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
1.119 + if( aNew==0 ) return;
1.120 + memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
1.121 + }else{
1.122 + aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
1.123 + if( aNew==0 ) return;
1.124 + }
1.125 + db->aDb = aNew;
1.126 + aNew = &db->aDb[db->nDb++];
1.127 + memset(aNew, 0, sizeof(*aNew));
1.128 +
1.129 + /* Open the database file. If the btree is successfully opened, use
1.130 + ** it to obtain the database schema. At this point the schema may
1.131 + ** or may not be initialised.
1.132 + */
1.133 + rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE,
1.134 + db->openFlags | SQLITE_OPEN_MAIN_DB,
1.135 + &aNew->pBt);
1.136 + if( rc==SQLITE_OK ){
1.137 + Pager *pPager;
1.138 + aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
1.139 + if( !aNew->pSchema ){
1.140 + rc = SQLITE_NOMEM;
1.141 + }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
1.142 + sqlite3_snprintf(sizeof(zErr), zErr,
1.143 + "attached databases must use the same text encoding as main database");
1.144 + goto attach_error;
1.145 + }
1.146 + pPager = sqlite3BtreePager(aNew->pBt);
1.147 + sqlite3PagerLockingMode(pPager, db->dfltLockMode);
1.148 + sqlite3PagerJournalMode(pPager, db->dfltJournalMode);
1.149 + }
1.150 + aNew->safety_level = 3;
1.151 + aNew->zName = sqlite3DbStrDup(db, zName);
1.152 + if( rc==SQLITE_OK && aNew->zName==0 ){
1.153 + rc = SQLITE_NOMEM;
1.154 + }
1.155 +
1.156 +#if SQLITE_HAS_CODEC
1.157 + {
1.158 + extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
1.159 + extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
1.160 + int nKey;
1.161 + char *zKey;
1.162 + int t = sqlite3_value_type(argv[2]);
1.163 + switch( t ){
1.164 + case SQLITE_INTEGER:
1.165 + case SQLITE_FLOAT:
1.166 + zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
1.167 + rc = SQLITE_ERROR;
1.168 + break;
1.169 +
1.170 + case SQLITE_TEXT:
1.171 + case SQLITE_BLOB:
1.172 + nKey = sqlite3_value_bytes(argv[2]);
1.173 + zKey = (char *)sqlite3_value_blob(argv[2]);
1.174 + sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
1.175 + break;
1.176 +
1.177 + case SQLITE_NULL:
1.178 + /* No key specified. Use the key from the main database */
1.179 + sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
1.180 + sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
1.181 + break;
1.182 + }
1.183 + }
1.184 +#endif
1.185 +
1.186 + /* If the file was opened successfully, read the schema for the new database.
1.187 + ** If this fails, or if opening the file failed, then close the file and
1.188 + ** remove the entry from the db->aDb[] array. i.e. put everything back the way
1.189 + ** we found it.
1.190 + */
1.191 + if( rc==SQLITE_OK ){
1.192 + (void)sqlite3SafetyOn(db);
1.193 + sqlite3BtreeEnterAll(db);
1.194 + rc = sqlite3Init(db, &zErrDyn);
1.195 + sqlite3BtreeLeaveAll(db);
1.196 + (void)sqlite3SafetyOff(db);
1.197 + }
1.198 + if( rc ){
1.199 + int iDb = db->nDb - 1;
1.200 + assert( iDb>=2 );
1.201 + if( db->aDb[iDb].pBt ){
1.202 + sqlite3BtreeClose(db->aDb[iDb].pBt);
1.203 + db->aDb[iDb].pBt = 0;
1.204 + db->aDb[iDb].pSchema = 0;
1.205 + }
1.206 + sqlite3ResetInternalSchema(db, 0);
1.207 + db->nDb = iDb;
1.208 + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
1.209 + db->mallocFailed = 1;
1.210 + sqlite3_snprintf(sizeof(zErr),zErr, "out of memory");
1.211 + }else{
1.212 + sqlite3_snprintf(sizeof(zErr),zErr, "unable to open database: %s", zFile);
1.213 + }
1.214 + goto attach_error;
1.215 + }
1.216 +
1.217 + return;
1.218 +
1.219 +attach_error:
1.220 + /* Return an error if we get here */
1.221 + if( zErrDyn ){
1.222 + sqlite3_result_error(context, zErrDyn, -1);
1.223 + sqlite3DbFree(db, zErrDyn);
1.224 + }else{
1.225 + zErr[sizeof(zErr)-1] = 0;
1.226 + sqlite3_result_error(context, zErr, -1);
1.227 + }
1.228 + if( rc ) sqlite3_result_error_code(context, rc);
1.229 +}
1.230 +
1.231 +/*
1.232 +** An SQL user-function registered to do the work of an DETACH statement. The
1.233 +** three arguments to the function come directly from a detach statement:
1.234 +**
1.235 +** DETACH DATABASE x
1.236 +**
1.237 +** SELECT sqlite_detach(x)
1.238 +*/
1.239 +static void detachFunc(
1.240 + sqlite3_context *context,
1.241 + int argc,
1.242 + sqlite3_value **argv
1.243 +){
1.244 + const char *zName = (const char *)sqlite3_value_text(argv[0]);
1.245 + sqlite3 *db = sqlite3_context_db_handle(context);
1.246 + int i;
1.247 + Db *pDb = 0;
1.248 + char zErr[128];
1.249 +
1.250 + if( zName==0 ) zName = "";
1.251 + for(i=0; i<db->nDb; i++){
1.252 + pDb = &db->aDb[i];
1.253 + if( pDb->pBt==0 ) continue;
1.254 + if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
1.255 + }
1.256 +
1.257 + if( i>=db->nDb ){
1.258 + sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
1.259 + goto detach_error;
1.260 + }
1.261 + if( i<2 ){
1.262 + sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
1.263 + goto detach_error;
1.264 + }
1.265 + if( !db->autoCommit ){
1.266 + sqlite3_snprintf(sizeof(zErr), zErr,
1.267 + "cannot DETACH database within transaction");
1.268 + goto detach_error;
1.269 + }
1.270 + if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){
1.271 + sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
1.272 + goto detach_error;
1.273 + }
1.274 +
1.275 + sqlite3BtreeClose(pDb->pBt);
1.276 + pDb->pBt = 0;
1.277 + pDb->pSchema = 0;
1.278 + sqlite3ResetInternalSchema(db, 0);
1.279 + return;
1.280 +
1.281 +detach_error:
1.282 + sqlite3_result_error(context, zErr, -1);
1.283 +}
1.284 +
1.285 +/*
1.286 +** This procedure generates VDBE code for a single invocation of either the
1.287 +** sqlite_detach() or sqlite_attach() SQL user functions.
1.288 +*/
1.289 +static void codeAttach(
1.290 + Parse *pParse, /* The parser context */
1.291 + int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */
1.292 + const char *zFunc, /* Either "sqlite_attach" or "sqlite_detach */
1.293 + int nFunc, /* Number of args to pass to zFunc */
1.294 + Expr *pAuthArg, /* Expression to pass to authorization callback */
1.295 + Expr *pFilename, /* Name of database file */
1.296 + Expr *pDbname, /* Name of the database to use internally */
1.297 + Expr *pKey /* Database key for encryption extension */
1.298 +){
1.299 + int rc;
1.300 + NameContext sName;
1.301 + Vdbe *v;
1.302 + FuncDef *pFunc;
1.303 + sqlite3* db = pParse->db;
1.304 + int regArgs;
1.305 +
1.306 +#ifndef SQLITE_OMIT_AUTHORIZATION
1.307 + assert( db->mallocFailed || pAuthArg );
1.308 + if( pAuthArg ){
1.309 + char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span);
1.310 + if( !zAuthArg ){
1.311 + goto attach_end;
1.312 + }
1.313 + rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
1.314 + sqlite3DbFree(db, zAuthArg);
1.315 + if(rc!=SQLITE_OK ){
1.316 + goto attach_end;
1.317 + }
1.318 + }
1.319 +#endif /* SQLITE_OMIT_AUTHORIZATION */
1.320 +
1.321 + memset(&sName, 0, sizeof(NameContext));
1.322 + sName.pParse = pParse;
1.323 +
1.324 + if(
1.325 + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
1.326 + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
1.327 + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
1.328 + ){
1.329 + pParse->nErr++;
1.330 + goto attach_end;
1.331 + }
1.332 +
1.333 + v = sqlite3GetVdbe(pParse);
1.334 + regArgs = sqlite3GetTempRange(pParse, 4);
1.335 + sqlite3ExprCode(pParse, pFilename, regArgs);
1.336 + sqlite3ExprCode(pParse, pDbname, regArgs+1);
1.337 + sqlite3ExprCode(pParse, pKey, regArgs+2);
1.338 +
1.339 + assert( v || db->mallocFailed );
1.340 + if( v ){
1.341 + sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs+3);
1.342 + sqlite3VdbeChangeP5(v, nFunc);
1.343 + pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);
1.344 + sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
1.345 +
1.346 + /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
1.347 + ** statement only). For DETACH, set it to false (expire all existing
1.348 + ** statements).
1.349 + */
1.350 + sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
1.351 + }
1.352 +
1.353 +attach_end:
1.354 + sqlite3ExprDelete(db, pFilename);
1.355 + sqlite3ExprDelete(db, pDbname);
1.356 + sqlite3ExprDelete(db, pKey);
1.357 +}
1.358 +
1.359 +/*
1.360 +** Called by the parser to compile a DETACH statement.
1.361 +**
1.362 +** DETACH pDbname
1.363 +*/
1.364 +void sqlite3Detach(Parse *pParse, Expr *pDbname){
1.365 + codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname);
1.366 +}
1.367 +
1.368 +/*
1.369 +** Called by the parser to compile an ATTACH statement.
1.370 +**
1.371 +** ATTACH p AS pDbname KEY pKey
1.372 +*/
1.373 +void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
1.374 + codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey);
1.375 +}
1.376 +#endif /* SQLITE_OMIT_ATTACH */
1.377 +
1.378 +/*
1.379 +** Register the functions sqlite_attach and sqlite_detach.
1.380 +*/
1.381 +void sqlite3AttachFunctions(sqlite3 *db){
1.382 +#ifndef SQLITE_OMIT_ATTACH
1.383 + static const int enc = SQLITE_UTF8;
1.384 + sqlite3CreateFunc(db, "sqlite_attach", 3, enc, 0, attachFunc, 0, 0);
1.385 + sqlite3CreateFunc(db, "sqlite_detach", 1, enc, 0, detachFunc, 0, 0);
1.386 +#endif
1.387 +}
1.388 +
1.389 +/*
1.390 +** Initialize a DbFixer structure. This routine must be called prior
1.391 +** to passing the structure to one of the sqliteFixAAAA() routines below.
1.392 +**
1.393 +** The return value indicates whether or not fixation is required. TRUE
1.394 +** means we do need to fix the database references, FALSE means we do not.
1.395 +*/
1.396 +int sqlite3FixInit(
1.397 + DbFixer *pFix, /* The fixer to be initialized */
1.398 + Parse *pParse, /* Error messages will be written here */
1.399 + int iDb, /* This is the database that must be used */
1.400 + const char *zType, /* "view", "trigger", or "index" */
1.401 + const Token *pName /* Name of the view, trigger, or index */
1.402 +){
1.403 + sqlite3 *db;
1.404 +
1.405 + if( iDb<0 || iDb==1 ) return 0;
1.406 + db = pParse->db;
1.407 + assert( db->nDb>iDb );
1.408 + pFix->pParse = pParse;
1.409 + pFix->zDb = db->aDb[iDb].zName;
1.410 + pFix->zType = zType;
1.411 + pFix->pName = pName;
1.412 + return 1;
1.413 +}
1.414 +
1.415 +/*
1.416 +** The following set of routines walk through the parse tree and assign
1.417 +** a specific database to all table references where the database name
1.418 +** was left unspecified in the original SQL statement. The pFix structure
1.419 +** must have been initialized by a prior call to sqlite3FixInit().
1.420 +**
1.421 +** These routines are used to make sure that an index, trigger, or
1.422 +** view in one database does not refer to objects in a different database.
1.423 +** (Exception: indices, triggers, and views in the TEMP database are
1.424 +** allowed to refer to anything.) If a reference is explicitly made
1.425 +** to an object in a different database, an error message is added to
1.426 +** pParse->zErrMsg and these routines return non-zero. If everything
1.427 +** checks out, these routines return 0.
1.428 +*/
1.429 +int sqlite3FixSrcList(
1.430 + DbFixer *pFix, /* Context of the fixation */
1.431 + SrcList *pList /* The Source list to check and modify */
1.432 +){
1.433 + int i;
1.434 + const char *zDb;
1.435 + struct SrcList_item *pItem;
1.436 +
1.437 + if( pList==0 ) return 0;
1.438 + zDb = pFix->zDb;
1.439 + for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
1.440 + if( pItem->zDatabase==0 ){
1.441 + pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);
1.442 + }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){
1.443 + sqlite3ErrorMsg(pFix->pParse,
1.444 + "%s %T cannot reference objects in database %s",
1.445 + pFix->zType, pFix->pName, pItem->zDatabase);
1.446 + return 1;
1.447 + }
1.448 +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
1.449 + if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
1.450 + if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
1.451 +#endif
1.452 + }
1.453 + return 0;
1.454 +}
1.455 +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
1.456 +int sqlite3FixSelect(
1.457 + DbFixer *pFix, /* Context of the fixation */
1.458 + Select *pSelect /* The SELECT statement to be fixed to one database */
1.459 +){
1.460 + while( pSelect ){
1.461 + if( sqlite3FixExprList(pFix, pSelect->pEList) ){
1.462 + return 1;
1.463 + }
1.464 + if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
1.465 + return 1;
1.466 + }
1.467 + if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
1.468 + return 1;
1.469 + }
1.470 + if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
1.471 + return 1;
1.472 + }
1.473 + pSelect = pSelect->pPrior;
1.474 + }
1.475 + return 0;
1.476 +}
1.477 +int sqlite3FixExpr(
1.478 + DbFixer *pFix, /* Context of the fixation */
1.479 + Expr *pExpr /* The expression to be fixed to one database */
1.480 +){
1.481 + while( pExpr ){
1.482 + if( sqlite3FixSelect(pFix, pExpr->pSelect) ){
1.483 + return 1;
1.484 + }
1.485 + if( sqlite3FixExprList(pFix, pExpr->pList) ){
1.486 + return 1;
1.487 + }
1.488 + if( sqlite3FixExpr(pFix, pExpr->pRight) ){
1.489 + return 1;
1.490 + }
1.491 + pExpr = pExpr->pLeft;
1.492 + }
1.493 + return 0;
1.494 +}
1.495 +int sqlite3FixExprList(
1.496 + DbFixer *pFix, /* Context of the fixation */
1.497 + ExprList *pList /* The expression to be fixed to one database */
1.498 +){
1.499 + int i;
1.500 + struct ExprList_item *pItem;
1.501 + if( pList==0 ) return 0;
1.502 + for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
1.503 + if( sqlite3FixExpr(pFix, pItem->pExpr) ){
1.504 + return 1;
1.505 + }
1.506 + }
1.507 + return 0;
1.508 +}
1.509 +#endif
1.510 +
1.511 +#ifndef SQLITE_OMIT_TRIGGER
1.512 +int sqlite3FixTriggerStep(
1.513 + DbFixer *pFix, /* Context of the fixation */
1.514 + TriggerStep *pStep /* The trigger step be fixed to one database */
1.515 +){
1.516 + while( pStep ){
1.517 + if( sqlite3FixSelect(pFix, pStep->pSelect) ){
1.518 + return 1;
1.519 + }
1.520 + if( sqlite3FixExpr(pFix, pStep->pWhere) ){
1.521 + return 1;
1.522 + }
1.523 + if( sqlite3FixExprList(pFix, pStep->pExprList) ){
1.524 + return 1;
1.525 + }
1.526 + pStep = pStep->pNext;
1.527 + }
1.528 + return 0;
1.529 +}
1.530 +#endif