665 lines
18 KiB
C#
665 lines
18 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
|
|
using u8 = System.Byte;
|
|
using u32 = System.UInt32;
|
|
|
|
namespace Community.CsharpSqlite
|
|
{
|
|
using sqlite3_value = Sqlite3.Mem;
|
|
|
|
public partial class Sqlite3
|
|
{
|
|
/*
|
|
** 2003 April 6
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
** This file contains code used to implement the ATTACH and DETACH commands.
|
|
*************************************************************************
|
|
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
|
|
** C#-SQLite is an independent reimplementation of the SQLite software library
|
|
**
|
|
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
|
|
**
|
|
*************************************************************************
|
|
*/
|
|
//#include "sqliteInt.h"
|
|
|
|
#if !SQLITE_OMIT_ATTACH
|
|
/*
|
|
** Resolve an expression that was part of an ATTACH or DETACH statement. This
|
|
** is slightly different from resolving a normal SQL expression, because simple
|
|
** identifiers are treated as strings, not possible column names or aliases.
|
|
**
|
|
** i.e. if the parser sees:
|
|
**
|
|
** ATTACH DATABASE abc AS def
|
|
**
|
|
** it treats the two expressions as literal strings 'abc' and 'def' instead of
|
|
** looking for columns of the same name.
|
|
**
|
|
** This only applies to the root node of pExpr, so the statement:
|
|
**
|
|
** ATTACH DATABASE abc||def AS 'db2'
|
|
**
|
|
** will fail because neither abc or def can be resolved.
|
|
*/
|
|
static int resolveAttachExpr( NameContext pName, Expr pExpr )
|
|
{
|
|
int rc = SQLITE_OK;
|
|
if ( pExpr != null )
|
|
{
|
|
if ( pExpr.op != TK_ID )
|
|
{
|
|
rc = sqlite3ResolveExprNames( pName, ref pExpr );
|
|
if ( rc == SQLITE_OK && sqlite3ExprIsConstant( pExpr ) == 0 )
|
|
{
|
|
sqlite3ErrorMsg( pName.pParse, "invalid name: \"%s\"", pExpr.u.zToken );
|
|
return SQLITE_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pExpr.op = TK_STRING;
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** An SQL user-function registered to do the work of an ATTACH statement. The
|
|
** three arguments to the function come directly from an attach statement:
|
|
**
|
|
** ATTACH DATABASE x AS y KEY z
|
|
**
|
|
** SELECT sqlite_attach(x, y, z)
|
|
**
|
|
** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
|
|
** third argument.
|
|
*/
|
|
static void attachFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int i;
|
|
int rc = 0;
|
|
sqlite3 db = sqlite3_context_db_handle( context );
|
|
string zName;
|
|
string zFile;
|
|
string zPath = "";
|
|
string zErr = "";
|
|
int flags;
|
|
|
|
Db aNew = null;
|
|
string zErrDyn = "";
|
|
sqlite3_vfs pVfs = null;
|
|
|
|
UNUSED_PARAMETER( NotUsed );
|
|
|
|
zFile = argv[0].z != null && ( argv[0].z.Length > 0 ) && argv[0].flags != MEM_Null ? sqlite3_value_text( argv[0] ) : "";
|
|
zName = argv[1].z != null && ( argv[1].z.Length > 0 ) && argv[1].flags != MEM_Null ? sqlite3_value_text( argv[1] ) : "";
|
|
//if( zFile==null ) zFile = "";
|
|
//if ( zName == null ) zName = "";
|
|
|
|
|
|
/* Check for the following errors:
|
|
**
|
|
** * Too many attached databases,
|
|
** * Transaction currently open
|
|
** * Specified database name already being used.
|
|
*/
|
|
if ( db.nDb >= db.aLimit[SQLITE_LIMIT_ATTACHED] + 2 )
|
|
{
|
|
zErrDyn = sqlite3MPrintf( db, "too many attached databases - max %d",
|
|
db.aLimit[SQLITE_LIMIT_ATTACHED]
|
|
);
|
|
goto attach_error;
|
|
}
|
|
if ( 0 == db.autoCommit )
|
|
{
|
|
zErrDyn = sqlite3MPrintf( db, "cannot ATTACH database within transaction" );
|
|
goto attach_error;
|
|
}
|
|
for ( i = 0; i < db.nDb; i++ )
|
|
{
|
|
string z = db.aDb[i].zName;
|
|
Debug.Assert( z != null && zName != null );
|
|
if ( z.Equals( zName, StringComparison.OrdinalIgnoreCase ) )
|
|
{
|
|
zErrDyn = sqlite3MPrintf( db, "database %s is already in use", zName );
|
|
goto attach_error;
|
|
}
|
|
}
|
|
|
|
/* Allocate the new entry in the db.aDb[] array and initialise the schema
|
|
** hash tables.
|
|
*/
|
|
/* Allocate the new entry in the db.aDb[] array and initialise the schema
|
|
** hash tables.
|
|
*/
|
|
//if( db.aDb==db.aDbStatic ){
|
|
// aNew = sqlite3DbMallocRaw(db, sizeof(db.aDb[0])*3 );
|
|
// if( aNew==0 ) return;
|
|
// memcpy(aNew, db.aDb, sizeof(db.aDb[0])*2);
|
|
//}else {
|
|
if ( db.aDb.Length <= db.nDb )
|
|
Array.Resize( ref db.aDb, db.nDb + 1 );//aNew = sqlite3DbRealloc(db, db.aDb, sizeof(db.aDb[0])*(db.nDb+1) );
|
|
if ( db.aDb == null )
|
|
return; // if( aNew==0 ) return;
|
|
//}
|
|
db.aDb[db.nDb] = new Db();//db.aDb = aNew;
|
|
aNew = db.aDb[db.nDb];//memset(aNew, 0, sizeof(*aNew));
|
|
// memset(aNew, 0, sizeof(*aNew));
|
|
|
|
/* Open the database file. If the btree is successfully opened, use
|
|
** it to obtain the database schema. At this point the schema may
|
|
** or may not be initialised.
|
|
*/
|
|
flags = (int)db.openFlags;
|
|
rc = sqlite3ParseUri( vfsList.zName, zFile, ref flags, ref pVfs, ref zPath, ref zErr );
|
|
if ( rc != SQLITE_OK )
|
|
{
|
|
//if ( rc == SQLITE_NOMEM )
|
|
//db.mallocFailed = 1;
|
|
sqlite3_result_error( context, zErr, -1 );
|
|
//sqlite3_free( zErr );
|
|
return;
|
|
}
|
|
Debug.Assert( pVfs != null);
|
|
flags |= SQLITE_OPEN_MAIN_DB;
|
|
rc = sqlite3BtreeOpen( pVfs, zPath, db, ref aNew.pBt, 0, (int)flags );
|
|
//sqlite3_free( zPath );
|
|
|
|
db.nDb++;
|
|
if ( rc == SQLITE_CONSTRAINT )
|
|
{
|
|
rc = SQLITE_ERROR;
|
|
zErrDyn = sqlite3MPrintf( db, "database is already attached" );
|
|
}
|
|
else if ( rc == SQLITE_OK )
|
|
{
|
|
Pager pPager;
|
|
aNew.pSchema = sqlite3SchemaGet( db, aNew.pBt );
|
|
//if ( aNew.pSchema == null )
|
|
//{
|
|
// rc = SQLITE_NOMEM;
|
|
//}
|
|
//else
|
|
if ( aNew.pSchema.file_format != 0 && aNew.pSchema.enc != ENC( db ) )
|
|
{
|
|
zErrDyn = sqlite3MPrintf( db,
|
|
"attached databases must use the same text encoding as main database" );
|
|
rc = SQLITE_ERROR;
|
|
}
|
|
pPager = sqlite3BtreePager( aNew.pBt );
|
|
sqlite3PagerLockingMode( pPager, db.dfltLockMode );
|
|
sqlite3BtreeSecureDelete( aNew.pBt,
|
|
sqlite3BtreeSecureDelete( db.aDb[0].pBt, -1 ) );
|
|
}
|
|
aNew.safety_level = 3;
|
|
aNew.zName = zName;//sqlite3DbStrDup(db, zName);
|
|
//if( rc==SQLITE_OK && aNew.zName==0 ){
|
|
// rc = SQLITE_NOMEM;
|
|
//}
|
|
|
|
#if SQLITE_HAS_CODEC
|
|
if ( rc == SQLITE_OK )
|
|
{
|
|
//extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
|
|
//extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
|
|
int nKey;
|
|
string zKey;
|
|
int t = sqlite3_value_type( argv[2] );
|
|
switch ( t )
|
|
{
|
|
case SQLITE_INTEGER:
|
|
case SQLITE_FLOAT:
|
|
zErrDyn = "Invalid key value"; //sqlite3DbStrDup( db, "Invalid key value" );
|
|
rc = SQLITE_ERROR;
|
|
break;
|
|
|
|
case SQLITE_TEXT:
|
|
case SQLITE_BLOB:
|
|
nKey = sqlite3_value_bytes( argv[2] );
|
|
zKey = sqlite3_value_blob( argv[2] ).ToString(); // (char *)sqlite3_value_blob(argv[2]);
|
|
rc = sqlite3CodecAttach( db, db.nDb - 1, zKey, nKey );
|
|
break;
|
|
|
|
case SQLITE_NULL:
|
|
/* No key specified. Use the key from the main database */
|
|
sqlite3CodecGetKey( db, 0, out zKey, out nKey ); //sqlite3CodecGetKey(db, 0, (void**)&zKey, nKey);
|
|
if ( nKey > 0 || sqlite3BtreeGetReserve( db.aDb[0].pBt ) > 0 )
|
|
{
|
|
rc = sqlite3CodecAttach( db, db.nDb - 1, zKey, nKey );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* If the file was opened successfully, read the schema for the new database.
|
|
** If this fails, or if opening the file failed, then close the file and
|
|
** remove the entry from the db.aDb[] array. i.e. put everything back the way
|
|
** we found it.
|
|
*/
|
|
if ( rc == SQLITE_OK )
|
|
{
|
|
sqlite3BtreeEnterAll( db );
|
|
rc = sqlite3Init( db, ref zErrDyn );
|
|
sqlite3BtreeLeaveAll( db );
|
|
}
|
|
if ( rc != 0 )
|
|
{
|
|
int iDb = db.nDb - 1;
|
|
Debug.Assert( iDb >= 2 );
|
|
if ( db.aDb[iDb].pBt != null )
|
|
{
|
|
sqlite3BtreeClose( ref db.aDb[iDb].pBt );
|
|
db.aDb[iDb].pBt = null;
|
|
db.aDb[iDb].pSchema = null;
|
|
}
|
|
sqlite3ResetInternalSchema( db, -1 );
|
|
db.nDb = iDb;
|
|
if ( rc == SQLITE_NOMEM || rc == SQLITE_IOERR_NOMEM )
|
|
{
|
|
//// db.mallocFailed = 1;
|
|
sqlite3DbFree( db, ref zErrDyn );
|
|
zErrDyn = sqlite3MPrintf( db, "out of memory" );
|
|
}
|
|
else if ( zErrDyn == "" )
|
|
{
|
|
zErrDyn = sqlite3MPrintf( db, "unable to open database: %s", zFile );
|
|
}
|
|
goto attach_error;
|
|
}
|
|
|
|
return;
|
|
|
|
attach_error:
|
|
/* Return an error if we get here */
|
|
if ( zErrDyn != "" )
|
|
{
|
|
sqlite3_result_error( context, zErrDyn, -1 );
|
|
sqlite3DbFree( db, ref zErrDyn );
|
|
}
|
|
if ( rc != 0 )
|
|
sqlite3_result_error_code( context, rc );
|
|
}
|
|
|
|
/*
|
|
** An SQL user-function registered to do the work of an DETACH statement. The
|
|
** three arguments to the function come directly from a detach statement:
|
|
**
|
|
** DETACH DATABASE x
|
|
**
|
|
** SELECT sqlite_detach(x)
|
|
*/
|
|
static void detachFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zName = zName = argv[0].z != null && ( argv[0].z.Length > 0 ) ? sqlite3_value_text( argv[0] ) : "";//(sqlite3_value_text(argv[0]);
|
|
sqlite3 db = sqlite3_context_db_handle( context );
|
|
int i;
|
|
Db pDb = null;
|
|
StringBuilder zErr = new StringBuilder( 200 );
|
|
|
|
UNUSED_PARAMETER( NotUsed );
|
|
|
|
if ( zName == null )
|
|
zName = "";
|
|
for ( i = 0; i < db.nDb; i++ )
|
|
{
|
|
pDb = db.aDb[i];
|
|
if ( pDb.pBt == null )
|
|
continue;
|
|
if ( pDb.zName.Equals( zName, StringComparison.OrdinalIgnoreCase ) )
|
|
break;
|
|
}
|
|
|
|
if ( i >= db.nDb )
|
|
{
|
|
sqlite3_snprintf( 200, zErr, "no such database: %s", zName );
|
|
goto detach_error;
|
|
}
|
|
if ( i < 2 )
|
|
{
|
|
sqlite3_snprintf( 200, zErr, "cannot detach database %s", zName );
|
|
goto detach_error;
|
|
}
|
|
if ( 0 == db.autoCommit )
|
|
{
|
|
sqlite3_snprintf( 200, zErr,
|
|
"cannot DETACH database within transaction" );
|
|
goto detach_error;
|
|
}
|
|
if ( sqlite3BtreeIsInReadTrans( pDb.pBt ) || sqlite3BtreeIsInBackup( pDb.pBt ) )
|
|
{
|
|
sqlite3_snprintf( 200, zErr, "database %s is locked", zName );
|
|
goto detach_error;
|
|
}
|
|
|
|
sqlite3BtreeClose( ref pDb.pBt );
|
|
pDb.pBt = null;
|
|
pDb.pSchema = null;
|
|
sqlite3ResetInternalSchema( db, -1 );
|
|
return;
|
|
|
|
detach_error:
|
|
sqlite3_result_error( context, zErr.ToString(), -1 );
|
|
}
|
|
|
|
/*
|
|
** This procedure generates VDBE code for a single invocation of either the
|
|
** sqlite_detach() or sqlite_attach() SQL user functions.
|
|
*/
|
|
static void codeAttach(
|
|
Parse pParse, /* The parser context */
|
|
int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */
|
|
FuncDef pFunc, /* FuncDef wrapper for detachFunc() or attachFunc() */
|
|
Expr pAuthArg, /* Expression to pass to authorization callback */
|
|
Expr pFilename, /* Name of database file */
|
|
Expr pDbname, /* Name of the database to use internally */
|
|
Expr pKey /* Database key for encryption extension */
|
|
)
|
|
{
|
|
NameContext sName;
|
|
Vdbe v;
|
|
sqlite3 db = pParse.db;
|
|
int regArgs;
|
|
|
|
sName = new NameContext();// memset( &sName, 0, sizeof(NameContext));
|
|
sName.pParse = pParse;
|
|
|
|
if (
|
|
SQLITE_OK != resolveAttachExpr( sName, pFilename ) ||
|
|
SQLITE_OK != resolveAttachExpr( sName, pDbname ) ||
|
|
SQLITE_OK != resolveAttachExpr( sName, pKey )
|
|
)
|
|
{
|
|
pParse.nErr++;
|
|
goto attach_end;
|
|
}
|
|
|
|
#if !SQLITE_OMIT_AUTHORIZATION
|
|
if( pAuthArg ){
|
|
char *zAuthArg;
|
|
if( pAuthArg->op==TK_STRING ){
|
|
zAuthArg = pAuthArg->u.zToken;
|
|
}else{
|
|
zAuthArg = 0;
|
|
}
|
|
int rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
|
|
if(rc!=SQLITE_OK ){
|
|
goto attach_end;
|
|
}
|
|
}
|
|
#endif //* SQLITE_OMIT_AUTHORIZATION */
|
|
|
|
v = sqlite3GetVdbe( pParse );
|
|
regArgs = sqlite3GetTempRange( pParse, 4 );
|
|
sqlite3ExprCode( pParse, pFilename, regArgs );
|
|
sqlite3ExprCode( pParse, pDbname, regArgs + 1 );
|
|
sqlite3ExprCode( pParse, pKey, regArgs + 2 );
|
|
|
|
Debug.Assert( v != null /*|| db.mallocFailed != 0 */ );
|
|
if ( v != null )
|
|
{
|
|
sqlite3VdbeAddOp3( v, OP_Function, 0, regArgs + 3 - pFunc.nArg, regArgs + 3 );
|
|
Debug.Assert( pFunc.nArg == -1 || ( pFunc.nArg & 0xff ) == pFunc.nArg );
|
|
sqlite3VdbeChangeP5( v, (u8)( pFunc.nArg ) );
|
|
sqlite3VdbeChangeP4( v, -1, pFunc, P4_FUNCDEF );
|
|
|
|
/* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
|
|
** statement only). For DETACH, set it to false (expire all existing
|
|
** statements).
|
|
*/
|
|
sqlite3VdbeAddOp1( v, OP_Expire, ( type == SQLITE_ATTACH ) ? 1 : 0 );
|
|
}
|
|
|
|
attach_end:
|
|
sqlite3ExprDelete( db, ref pFilename );
|
|
sqlite3ExprDelete( db, ref pDbname );
|
|
sqlite3ExprDelete( db, ref pKey );
|
|
}
|
|
|
|
/*
|
|
** Called by the parser to compile a DETACH statement.
|
|
**
|
|
** DETACH pDbname
|
|
*/
|
|
static FuncDef detach_func = new FuncDef(
|
|
1, /* nArg */
|
|
SQLITE_UTF8, /* iPrefEnc */
|
|
0, /* flags */
|
|
null, /* pUserData */
|
|
null, /* pNext */
|
|
detachFunc, /* xFunc */
|
|
null, /* xStep */
|
|
null, /* xFinalize */
|
|
"sqlite_detach", /* zName */
|
|
null, /* pHash */
|
|
null /* pDestructor */
|
|
);
|
|
static void sqlite3Detach( Parse pParse, Expr pDbname )
|
|
{
|
|
codeAttach( pParse, SQLITE_DETACH, detach_func, pDbname, null, null, pDbname );
|
|
}
|
|
|
|
/*
|
|
** Called by the parser to compile an ATTACH statement.
|
|
**
|
|
** ATTACH p AS pDbname KEY pKey
|
|
*/
|
|
static FuncDef attach_func = new FuncDef(
|
|
3, /* nArg */
|
|
SQLITE_UTF8, /* iPrefEnc */
|
|
0, /* flags */
|
|
null, /* pUserData */
|
|
null, /* pNext */
|
|
attachFunc, /* xFunc */
|
|
null, /* xStep */
|
|
null, /* xFinalize */
|
|
"sqlite_attach", /* zName */
|
|
null, /* pHash */
|
|
null /* pDestructor */
|
|
);
|
|
static void sqlite3Attach( Parse pParse, Expr p, Expr pDbname, Expr pKey )
|
|
{
|
|
codeAttach( pParse, SQLITE_ATTACH, attach_func, p, p, pDbname, pKey );
|
|
}
|
|
#endif // * SQLITE_OMIT_ATTACH */
|
|
|
|
/*
|
|
** Initialize a DbFixer structure. This routine must be called prior
|
|
** to passing the structure to one of the sqliteFixAAAA() routines below.
|
|
**
|
|
** The return value indicates whether or not fixation is required. TRUE
|
|
** means we do need to fix the database references, FALSE means we do not.
|
|
*/
|
|
static int sqlite3FixInit(
|
|
DbFixer pFix, /* The fixer to be initialized */
|
|
Parse pParse, /* Error messages will be written here */
|
|
int iDb, /* This is the database that must be used */
|
|
string zType, /* "view", "trigger", or "index" */
|
|
Token pName /* Name of the view, trigger, or index */
|
|
)
|
|
{
|
|
sqlite3 db;
|
|
|
|
if ( NEVER( iDb < 0 ) || iDb == 1 )
|
|
return 0;
|
|
db = pParse.db;
|
|
Debug.Assert( db.nDb > iDb );
|
|
pFix.pParse = pParse;
|
|
pFix.zDb = db.aDb[iDb].zName;
|
|
pFix.zType = zType;
|
|
pFix.pName = pName;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
** The following set of routines walk through the parse tree and assign
|
|
** a specific database to all table references where the database name
|
|
** was left unspecified in the original SQL statement. The pFix structure
|
|
** must have been initialized by a prior call to sqlite3FixInit().
|
|
**
|
|
** These routines are used to make sure that an index, trigger, or
|
|
** view in one database does not refer to objects in a different database.
|
|
** (Exception: indices, triggers, and views in the TEMP database are
|
|
** allowed to refer to anything.) If a reference is explicitly made
|
|
** to an object in a different database, an error message is added to
|
|
** pParse.zErrMsg and these routines return non-zero. If everything
|
|
** checks out, these routines return 0.
|
|
*/
|
|
static int sqlite3FixSrcList(
|
|
DbFixer pFix, /* Context of the fixation */
|
|
SrcList pList /* The Source list to check and modify */
|
|
)
|
|
{
|
|
int i;
|
|
string zDb;
|
|
SrcList_item pItem;
|
|
|
|
if ( NEVER( pList == null ) )
|
|
return 0;
|
|
zDb = pFix.zDb;
|
|
for ( i = 0; i < pList.nSrc; i++ )
|
|
{//, pItem++){
|
|
pItem = pList.a[i];
|
|
if ( pItem.zDatabase == null )
|
|
{
|
|
pItem.zDatabase = zDb;// sqlite3DbStrDup( pFix.pParse.db, zDb );
|
|
}
|
|
else if ( !pItem.zDatabase.Equals( zDb ,StringComparison.OrdinalIgnoreCase ) )
|
|
{
|
|
sqlite3ErrorMsg( pFix.pParse,
|
|
"%s %T cannot reference objects in database %s",
|
|
pFix.zType, pFix.pName, pItem.zDatabase );
|
|
return 1;
|
|
}
|
|
#if !SQLITE_OMIT_VIEW || !SQLITE_OMIT_TRIGGER
|
|
if ( sqlite3FixSelect( pFix, pItem.pSelect ) != 0 )
|
|
return 1;
|
|
if ( sqlite3FixExpr( pFix, pItem.pOn ) != 0 )
|
|
return 1;
|
|
#endif
|
|
}
|
|
return 0;
|
|
}
|
|
#if !SQLITE_OMIT_VIEW || !SQLITE_OMIT_TRIGGER
|
|
static int sqlite3FixSelect(
|
|
DbFixer pFix, /* Context of the fixation */
|
|
Select pSelect /* The SELECT statement to be fixed to one database */
|
|
)
|
|
{
|
|
while ( pSelect != null )
|
|
{
|
|
if ( sqlite3FixExprList( pFix, pSelect.pEList ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( sqlite3FixSrcList( pFix, pSelect.pSrc ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( sqlite3FixExpr( pFix, pSelect.pWhere ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( sqlite3FixExpr( pFix, pSelect.pHaving ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
pSelect = pSelect.pPrior;
|
|
}
|
|
return 0;
|
|
}
|
|
static int sqlite3FixExpr(
|
|
DbFixer pFix, /* Context of the fixation */
|
|
Expr pExpr /* The expression to be fixed to one database */
|
|
)
|
|
{
|
|
while ( pExpr != null )
|
|
{
|
|
if ( ExprHasAnyProperty( pExpr, EP_TokenOnly ) )
|
|
break;
|
|
if ( ExprHasProperty( pExpr, EP_xIsSelect ) )
|
|
{
|
|
if ( sqlite3FixSelect( pFix, pExpr.x.pSelect ) != 0 )
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if ( sqlite3FixExprList( pFix, pExpr.x.pList ) != 0 )
|
|
return 1;
|
|
}
|
|
if ( sqlite3FixExpr( pFix, pExpr.pRight ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
pExpr = pExpr.pLeft;
|
|
}
|
|
return 0;
|
|
}
|
|
static int sqlite3FixExprList(
|
|
DbFixer pFix, /* Context of the fixation */
|
|
ExprList pList /* The expression to be fixed to one database */
|
|
)
|
|
{
|
|
int i;
|
|
ExprList_item pItem;
|
|
if ( pList == null )
|
|
return 0;
|
|
for ( i = 0; i < pList.nExpr; i++ )//, pItem++ )
|
|
{
|
|
pItem = pList.a[i];
|
|
if ( sqlite3FixExpr( pFix, pItem.pExpr ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if !SQLITE_OMIT_TRIGGER
|
|
static int sqlite3FixTriggerStep(
|
|
DbFixer pFix, /* Context of the fixation */
|
|
TriggerStep pStep /* The trigger step be fixed to one database */
|
|
)
|
|
{
|
|
while ( pStep != null )
|
|
{
|
|
if ( sqlite3FixSelect( pFix, pStep.pSelect ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( sqlite3FixExpr( pFix, pStep.pWhere ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( sqlite3FixExprList( pFix, pStep.pExprList ) != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
pStep = pStep.pNext;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|