Annotation of embedaddon/php/ext/sqlite/libsqlite/src/attach.c, revision 1.1
1.1 ! misho 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 195361 2005-09-07 15:11:33Z iliaa $
! 15: */
! 16: #include "sqliteInt.h"
! 17:
! 18: /*
! 19: ** This routine is called by the parser to process an ATTACH statement:
! 20: **
! 21: ** ATTACH DATABASE filename AS dbname
! 22: **
! 23: ** The pFilename and pDbname arguments are the tokens that define the
! 24: ** filename and dbname in the ATTACH statement.
! 25: */
! 26: void sqliteAttach(Parse *pParse, Token *pFilename, Token *pDbname, Token *pKey){
! 27: Db *aNew;
! 28: int rc, i;
! 29: char *zFile, *zName;
! 30: sqlite *db;
! 31: Vdbe *v;
! 32:
! 33: v = sqliteGetVdbe(pParse);
! 34: sqliteVdbeAddOp(v, OP_Halt, 0, 0);
! 35: if( pParse->explain ) return;
! 36: db = pParse->db;
! 37: if( db->file_format<4 ){
! 38: sqliteErrorMsg(pParse, "cannot attach auxiliary databases to an "
! 39: "older format master database", 0);
! 40: pParse->rc = SQLITE_ERROR;
! 41: return;
! 42: }
! 43: if( db->nDb>=MAX_ATTACHED+2 ){
! 44: sqliteErrorMsg(pParse, "too many attached databases - max %d",
! 45: MAX_ATTACHED);
! 46: pParse->rc = SQLITE_ERROR;
! 47: return;
! 48: }
! 49:
! 50: zFile = 0;
! 51: sqliteSetNString(&zFile, pFilename->z, pFilename->n, 0);
! 52: if( zFile==0 ) return;
! 53: sqliteDequote(zFile);
! 54: #ifndef SQLITE_OMIT_AUTHORIZATION
! 55: if( sqliteAuthCheck(pParse, SQLITE_ATTACH, zFile, 0, 0)!=SQLITE_OK ){
! 56: sqliteFree(zFile);
! 57: return;
! 58: }
! 59: #endif /* SQLITE_OMIT_AUTHORIZATION */
! 60:
! 61: zName = 0;
! 62: sqliteSetNString(&zName, pDbname->z, pDbname->n, 0);
! 63: if( zName==0 ) return;
! 64: sqliteDequote(zName);
! 65: for(i=0; i<db->nDb; i++){
! 66: if( db->aDb[i].zName && sqliteStrICmp(db->aDb[i].zName, zName)==0 ){
! 67: sqliteErrorMsg(pParse, "database %z is already in use", zName);
! 68: pParse->rc = SQLITE_ERROR;
! 69: sqliteFree(zFile);
! 70: return;
! 71: }
! 72: }
! 73:
! 74: if( db->aDb==db->aDbStatic ){
! 75: aNew = sqliteMalloc( sizeof(db->aDb[0])*3 );
! 76: if( aNew==0 ) return;
! 77: memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
! 78: }else{
! 79: aNew = sqliteRealloc(db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
! 80: if( aNew==0 ) return;
! 81: }
! 82: db->aDb = aNew;
! 83: aNew = &db->aDb[db->nDb++];
! 84: memset(aNew, 0, sizeof(*aNew));
! 85: sqliteHashInit(&aNew->tblHash, SQLITE_HASH_STRING, 0);
! 86: sqliteHashInit(&aNew->idxHash, SQLITE_HASH_STRING, 0);
! 87: sqliteHashInit(&aNew->trigHash, SQLITE_HASH_STRING, 0);
! 88: sqliteHashInit(&aNew->aFKey, SQLITE_HASH_STRING, 1);
! 89: aNew->zName = zName;
! 90: rc = sqliteBtreeFactory(db, zFile, 0, MAX_PAGES, &aNew->pBt);
! 91: if( rc ){
! 92: sqliteErrorMsg(pParse, "unable to open database: %s", zFile);
! 93: }
! 94: #if SQLITE_HAS_CODEC
! 95: {
! 96: extern int sqliteCodecAttach(sqlite*, int, void*, int);
! 97: char *zKey = 0;
! 98: int nKey;
! 99: if( pKey && pKey->z && pKey->n ){
! 100: sqliteSetNString(&zKey, pKey->z, pKey->n, 0);
! 101: sqliteDequote(zKey);
! 102: nKey = strlen(zKey);
! 103: }else{
! 104: zKey = 0;
! 105: nKey = 0;
! 106: }
! 107: sqliteCodecAttach(db, db->nDb-1, zKey, nKey);
! 108: }
! 109: #endif
! 110: sqliteFree(zFile);
! 111: db->flags &= ~SQLITE_Initialized;
! 112: if( pParse->nErr ) return;
! 113: if( rc==SQLITE_OK ){
! 114: rc = sqliteInit(pParse->db, &pParse->zErrMsg);
! 115: }
! 116: if( rc ){
! 117: int i = db->nDb - 1;
! 118: assert( i>=2 );
! 119: if( db->aDb[i].pBt ){
! 120: sqliteBtreeClose(db->aDb[i].pBt);
! 121: db->aDb[i].pBt = 0;
! 122: }
! 123: sqliteResetInternalSchema(db, 0);
! 124: pParse->nErr++;
! 125: pParse->rc = SQLITE_ERROR;
! 126: }
! 127: }
! 128:
! 129: /*
! 130: ** This routine is called by the parser to process a DETACH statement:
! 131: **
! 132: ** DETACH DATABASE dbname
! 133: **
! 134: ** The pDbname argument is the name of the database in the DETACH statement.
! 135: */
! 136: void sqliteDetach(Parse *pParse, Token *pDbname){
! 137: int i;
! 138: sqlite *db;
! 139: Vdbe *v;
! 140: Db *pDb;
! 141:
! 142: v = sqliteGetVdbe(pParse);
! 143: sqliteVdbeAddOp(v, OP_Halt, 0, 0);
! 144: if( pParse->explain ) return;
! 145: db = pParse->db;
! 146: for(i=0; i<db->nDb; i++){
! 147: pDb = &db->aDb[i];
! 148: if( pDb->pBt==0 || pDb->zName==0 ) continue;
! 149: if( strlen(pDb->zName)!=pDbname->n ) continue;
! 150: if( sqliteStrNICmp(pDb->zName, pDbname->z, pDbname->n)==0 ) break;
! 151: }
! 152: if( i>=db->nDb ){
! 153: sqliteErrorMsg(pParse, "no such database: %T", pDbname);
! 154: return;
! 155: }
! 156: if( i<2 ){
! 157: sqliteErrorMsg(pParse, "cannot detach database %T", pDbname);
! 158: return;
! 159: }
! 160: #ifndef SQLITE_OMIT_AUTHORIZATION
! 161: if( sqliteAuthCheck(pParse,SQLITE_DETACH,db->aDb[i].zName,0,0)!=SQLITE_OK ){
! 162: return;
! 163: }
! 164: #endif /* SQLITE_OMIT_AUTHORIZATION */
! 165: sqliteBtreeClose(pDb->pBt);
! 166: pDb->pBt = 0;
! 167: sqliteFree(pDb->zName);
! 168: sqliteResetInternalSchema(db, i);
! 169: if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux);
! 170: db->nDb--;
! 171: if( i<db->nDb ){
! 172: db->aDb[i] = db->aDb[db->nDb];
! 173: memset(&db->aDb[db->nDb], 0, sizeof(db->aDb[0]));
! 174: sqliteResetInternalSchema(db, i);
! 175: }
! 176: }
! 177:
! 178: /*
! 179: ** Initialize a DbFixer structure. This routine must be called prior
! 180: ** to passing the structure to one of the sqliteFixAAAA() routines below.
! 181: **
! 182: ** The return value indicates whether or not fixation is required. TRUE
! 183: ** means we do need to fix the database references, FALSE means we do not.
! 184: */
! 185: int sqliteFixInit(
! 186: DbFixer *pFix, /* The fixer to be initialized */
! 187: Parse *pParse, /* Error messages will be written here */
! 188: int iDb, /* This is the database that must must be used */
! 189: const char *zType, /* "view", "trigger", or "index" */
! 190: const Token *pName /* Name of the view, trigger, or index */
! 191: ){
! 192: sqlite *db;
! 193:
! 194: if( iDb<0 || iDb==1 ) return 0;
! 195: db = pParse->db;
! 196: assert( db->nDb>iDb );
! 197: pFix->pParse = pParse;
! 198: pFix->zDb = db->aDb[iDb].zName;
! 199: pFix->zType = zType;
! 200: pFix->pName = pName;
! 201: return 1;
! 202: }
! 203:
! 204: /*
! 205: ** The following set of routines walk through the parse tree and assign
! 206: ** a specific database to all table references where the database name
! 207: ** was left unspecified in the original SQL statement. The pFix structure
! 208: ** must have been initialized by a prior call to sqliteFixInit().
! 209: **
! 210: ** These routines are used to make sure that an index, trigger, or
! 211: ** view in one database does not refer to objects in a different database.
! 212: ** (Exception: indices, triggers, and views in the TEMP database are
! 213: ** allowed to refer to anything.) If a reference is explicitly made
! 214: ** to an object in a different database, an error message is added to
! 215: ** pParse->zErrMsg and these routines return non-zero. If everything
! 216: ** checks out, these routines return 0.
! 217: */
! 218: int sqliteFixSrcList(
! 219: DbFixer *pFix, /* Context of the fixation */
! 220: SrcList *pList /* The Source list to check and modify */
! 221: ){
! 222: int i;
! 223: const char *zDb;
! 224:
! 225: if( pList==0 ) return 0;
! 226: zDb = pFix->zDb;
! 227: for(i=0; i<pList->nSrc; i++){
! 228: if( pList->a[i].zDatabase==0 ){
! 229: pList->a[i].zDatabase = sqliteStrDup(zDb);
! 230: }else if( sqliteStrICmp(pList->a[i].zDatabase,zDb)!=0 ){
! 231: sqliteErrorMsg(pFix->pParse,
! 232: "%s %z cannot reference objects in database %s",
! 233: pFix->zType, sqliteStrNDup(pFix->pName->z, pFix->pName->n),
! 234: pList->a[i].zDatabase);
! 235: return 1;
! 236: }
! 237: if( sqliteFixSelect(pFix, pList->a[i].pSelect) ) return 1;
! 238: if( sqliteFixExpr(pFix, pList->a[i].pOn) ) return 1;
! 239: }
! 240: return 0;
! 241: }
! 242: int sqliteFixSelect(
! 243: DbFixer *pFix, /* Context of the fixation */
! 244: Select *pSelect /* The SELECT statement to be fixed to one database */
! 245: ){
! 246: while( pSelect ){
! 247: if( sqliteFixExprList(pFix, pSelect->pEList) ){
! 248: return 1;
! 249: }
! 250: if( sqliteFixSrcList(pFix, pSelect->pSrc) ){
! 251: return 1;
! 252: }
! 253: if( sqliteFixExpr(pFix, pSelect->pWhere) ){
! 254: return 1;
! 255: }
! 256: if( sqliteFixExpr(pFix, pSelect->pHaving) ){
! 257: return 1;
! 258: }
! 259: pSelect = pSelect->pPrior;
! 260: }
! 261: return 0;
! 262: }
! 263: int sqliteFixExpr(
! 264: DbFixer *pFix, /* Context of the fixation */
! 265: Expr *pExpr /* The expression to be fixed to one database */
! 266: ){
! 267: while( pExpr ){
! 268: if( sqliteFixSelect(pFix, pExpr->pSelect) ){
! 269: return 1;
! 270: }
! 271: if( sqliteFixExprList(pFix, pExpr->pList) ){
! 272: return 1;
! 273: }
! 274: if( sqliteFixExpr(pFix, pExpr->pRight) ){
! 275: return 1;
! 276: }
! 277: pExpr = pExpr->pLeft;
! 278: }
! 279: return 0;
! 280: }
! 281: int sqliteFixExprList(
! 282: DbFixer *pFix, /* Context of the fixation */
! 283: ExprList *pList /* The expression to be fixed to one database */
! 284: ){
! 285: int i;
! 286: if( pList==0 ) return 0;
! 287: for(i=0; i<pList->nExpr; i++){
! 288: if( sqliteFixExpr(pFix, pList->a[i].pExpr) ){
! 289: return 1;
! 290: }
! 291: }
! 292: return 0;
! 293: }
! 294: int sqliteFixTriggerStep(
! 295: DbFixer *pFix, /* Context of the fixation */
! 296: TriggerStep *pStep /* The trigger step be fixed to one database */
! 297: ){
! 298: while( pStep ){
! 299: if( sqliteFixSelect(pFix, pStep->pSelect) ){
! 300: return 1;
! 301: }
! 302: if( sqliteFixExpr(pFix, pStep->pWhere) ){
! 303: return 1;
! 304: }
! 305: if( sqliteFixExprList(pFix, pStep->pExprList) ){
! 306: return 1;
! 307: }
! 308: pStep = pStep->pNext;
! 309: }
! 310: return 0;
! 311: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to attach.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src