{

/*

//#include "sqliteInt.h"

/*

#if (SQLITE_TEST) || (SQLITE_DEBUG)

static bool sqlite3WhereTrace = false;

#endif

#if (SQLITE_TEST) && (SQLITE_DEBUG) && TRACE

static void WHERETRACE( string X, params object[] ap ) { if ( sqlite3WhereTrace ) sqlite3DebugPrintf( X, ap ); }

#else

//# define WHERETRACE(X)

static void WHERETRACE(string X, params object[] ap)

{

}

#endif

/* Forward reference

//typedef struct WhereClause WhereClause;

//typedef struct WhereMaskSet WhereMaskSet;

//typedef struct WhereOrInfo WhereOrInfo;

//typedef struct WhereAndInfo WhereAndInfo;

//typedef struct WhereCost WhereCost;

/*

//typedef struct WhereTerm WhereTerm;

public class WhereTerm

{

public Expr pExpr; /* Pointer to the subexpression that is this term */

public int iParent; /* Disable pWC.a[iParent] when this term disabled */

public int leftCursor; /* Cursor number of X in "X <op> <expr>" */

public class _u

{

public int leftColumn; /* Column number of X in "X <op> <expr>" */

public WhereOrInfo pOrInfo; /* Extra information if eOperator==WO_OR */

public WhereAndInfo pAndInfo; /* Extra information if eOperator==WO_AND */

}

public _u u = new _u();

public u16 eOperator; /* A WO_xx value describing <op> */

public u8 wtFlags; /* TERM_xxx bit flags. See below */

public u8 nChild; /* Number of children that must disable us */

public WhereClause pWC; /* The clause this term is part of */

public Bitmask prereqRight; /* Bitmask of tables used by pExpr.pRight */

public Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */

};

/*

//#define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, ref pExpr) */

//#define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */

//#define TERM_CODED 0x04 /* This term is already coded */

//#define TERM_COPIED 0x08 /* Has a child */

//#define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */

//#define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */

//#define TERM_OR_OK 0x40 /* Used during OR-clause processing */

#if SQLITE_ENABLE_STAT2

//# define TERM_VNULL 0x80 /* Manufactured x>NULL or x<=NULL term */

#else

//# define TERM_VNULL 0x00 /* Disabled if not using stat2 */

#endif

const int TERM_DYNAMIC = 0x01; /* Need to call sqlite3ExprDelete(db, ref pExpr) */

const int TERM_VIRTUAL = 0x02; /* Added by the optimizer. Do not code */

const int TERM_CODED = 0x04; /* This term is already coded */

const int TERM_COPIED = 0x08; /* Has a child */

const int TERM_ORINFO = 0x10; /* Need to free the WhereTerm.u.pOrInfo object */

const int TERM_ANDINFO = 0x20; /* Need to free the WhereTerm.u.pAndInfo obj */

const int TERM_OR_OK = 0x40; /* Used during OR-clause processing */

#if SQLITE_ENABLE_STAT2

const int TERM_VNULL = 0x80; /* Manufactured x>NULL or x<=NULL term */

#else

const int TERM_VNULL = 0x00; /* Disabled if not using stat2 */

#endif

/*

public class WhereClause

{

public Parse pParse; /* The parser context */

public WhereMaskSet pMaskSet; /* Mapping of table cursor numbers to bitmasks */

public Bitmask vmask; /* Bitmask identifying virtual table cursors */

public u8 op; /* Split operator. TK_AND or TK_OR */

public int nTerm; /* Number of terms */

public int nSlot; /* Number of entries in a[] */

public WhereTerm[] a; /* Each a[] describes a term of the WHERE cluase */

#if (SQLITE_SMALL_STACK)

public WhereTerm[] aStatic = new WhereTerm[1]; /* Initial static space for a[] */

#else

public WhereTerm[] aStatic = new WhereTerm[8]; /* Initial static space for a[] */

#endif

public void CopyTo(WhereClause wc)

{

wc.pParse = this.pParse;

wc.pMaskSet = new WhereMaskSet();

this.pMaskSet.CopyTo(wc.pMaskSet);

wc.op = this.op;

wc.nTerm = this.nTerm;

wc.nSlot = this.nSlot;

wc.a = (WhereTerm[])this.a.Clone();

wc.aStatic = (WhereTerm[])this.aStatic.Clone();

}

};

/*

public class WhereOrInfo

{

public WhereClause wc = new WhereClause();/* Decomposition into subterms */

public Bitmask indexable; /* Bitmask of all indexable tables in the clause */

};

/*

public class WhereAndInfo

{

public WhereClause wc = new WhereClause(); /* The subexpression broken out */

};

/*

public class WhereMaskSet

{

public int n; /* Number of Debug.Assigned cursor values */

public int[] ix = new int[BMS]; /* Cursor Debug.Assigned to each bit */

public void CopyTo(WhereMaskSet wms)

{

wms.n = this.n;

wms.ix = (int[])this.ix.Clone();

}

}

/*

public class WhereCost

{

public WherePlan plan = new WherePlan();/* The lookup strategy */

public double rCost; /* Overall cost of pursuing this search strategy */

public Bitmask used; /* Bitmask of cursors used by this plan */

public void Clear()

{

plan.Clear();

rCost = 0;

used = 0;

}

};

/*

//#define WO_IN 0x001

//#define WO_EQ 0x002

//#define WO_LT (WO_EQ<<(TK_LT-TK_EQ))

//#define WO_LE (WO_EQ<<(TK_LE-TK_EQ))

//#define WO_GT (WO_EQ<<(TK_GT-TK_EQ))

//#define WO_GE (WO_EQ<<(TK_GE-TK_EQ))

//#define WO_MATCH 0x040

//#define WO_ISNULL 0x080

//#define WO_OR 0x100 /* Two or more OR-connected terms */

//#define WO_AND 0x200 /* Two or more AND-connected terms */

//#define WO_NOOP 0x800 /* This term does not restrict search space */

//#define WO_ALL 0xfff /* Mask of all possible WO_* values */

//#define WO_SINGLE 0x0ff /* Mask of all non-compound WO_* values */

const int WO_IN = 0x001;

const int WO_EQ = 0x002;

const int WO_LT = (WO_EQ << (TK_LT - TK_EQ));

const int WO_LE = (WO_EQ << (TK_LE - TK_EQ));

const int WO_GT = (WO_EQ << (TK_GT - TK_EQ));

const int WO_GE = (WO_EQ << (TK_GE - TK_EQ));

const int WO_MATCH = 0x040;

const int WO_ISNULL = 0x080;

const int WO_OR = 0x100; /* Two or more OR-connected terms */

const int WO_AND = 0x200; /* Two or more AND-connected terms */

const int WO_NOOP = 0x800; /* This term does not restrict search space */

const int WO_ALL = 0xfff; /* Mask of all possible WO_* values */

const int WO_SINGLE = 0x0ff; /* Mask of all non-compound WO_* values */

/*

//#define WHERE_ROWID_EQ 0x00001000 /* rowid=EXPR or rowid IN (...) */

//#define WHERE_ROWID_RANGE 0x00002000 /* rowid<EXPR and/or rowid>EXPR */

//#define WHERE_COLUMN_EQ 0x00010000 /* x=EXPR or x IN (...) or x IS NULL */

//#define WHERE_COLUMN_RANGE 0x00020000 /* x<EXPR and/or x>EXPR */

//#define WHERE_COLUMN_IN 0x00040000 /* x IN (...) */

//#define WHERE_COLUMN_NULL 0x00080000 /* x IS NULL */

//#define WHERE_INDEXED 0x000f0000 /* Anything that uses an index */

//#define WHERE_IN_ABLE 0x000f1000 /* Able to support an IN operator */

//#define WHERE_NOT_FULLSCAN 0x100f3000 /* Does not do a full table scan */

//#define WHERE_TOP_LIMIT 0x00100000 /* x<EXPR or x<=EXPR constraint */

//#define WHERE_BTM_LIMIT 0x00200000 /* x>EXPR or x>=EXPR constraint */

//#define WHERE_BOTH_LIMIT 0x00300000 /* Both x>EXPR and x<EXPR */

//#define WHERE_IDX_ONLY 0x00800000 /* Use index only - omit table */

//#define WHERE_ORDERBY 0x01000000 /* Output will appear in correct order */

//#define WHERE_REVERSE 0x02000000 /* Scan in reverse order */

//#define WHERE_UNIQUE 0x04000000 /* Selects no more than one row */

//#define WHERE_VIRTUALTABLE 0x08000000 /* Use virtual-table processing */

//#define WHERE_MULTI_OR 0x10000000 /* OR using multiple indices */

//#define WHERE_TEMP_INDEX 0x20000000 /* Uses an ephemeral index */

const int WHERE_ROWID_EQ = 0x00001000;

const int WHERE_ROWID_RANGE = 0x00002000;

const int WHERE_COLUMN_EQ = 0x00010000;

const int WHERE_COLUMN_RANGE = 0x00020000;

const int WHERE_COLUMN_IN = 0x00040000;

const int WHERE_COLUMN_NULL = 0x00080000;

const int WHERE_INDEXED = 0x000f0000;

const int WHERE_IN_ABLE = 0x000f1000;

const int WHERE_NOT_FULLSCAN = 0x100f3000;

const int WHERE_TOP_LIMIT = 0x00100000;

const int WHERE_BTM_LIMIT = 0x00200000;

const int WHERE_BOTH_LIMIT = 0x00300000;

const int WHERE_IDX_ONLY = 0x00800000;

const int WHERE_ORDERBY = 0x01000000;

const int WHERE_REVERSE = 0x02000000;

const int WHERE_UNIQUE = 0x04000000;

const int WHERE_VIRTUALTABLE = 0x08000000;

const int WHERE_MULTI_OR = 0x10000000;

const int WHERE_TEMP_INDEX = 0x20000000;

/*

static void whereClauseInit(

WhereClause pWC, /* The WhereClause to be initialized */

Parse pParse, /* The parsing context */

WhereMaskSet pMaskSet /* Mapping from table cursor numbers to bitmasks */

)

{

pWC.pParse = pParse;

pWC.pMaskSet = pMaskSet;

pWC.nTerm = 0;

pWC.nSlot = ArraySize(pWC.aStatic) - 1;

pWC.a = pWC.aStatic;

pWC.vmask = 0;

}

/* Forward reference */

//static void whereClauseClear(WhereClause);

/*

static void whereOrInfoDelete(sqlite3 db, WhereOrInfo p)

{

whereClauseClear(p.wc);

sqlite3DbFree(db, ref p);

}

/*

static void whereAndInfoDelete(sqlite3 db, WhereAndInfo p)

{

whereClauseClear(p.wc);

sqlite3DbFree(db, ref p);

}

/*

static void whereClauseClear(WhereClause pWC)

{

int i;

WhereTerm a;

sqlite3 db = pWC.pParse.db;

for (i = pWC.nTerm - 1; i >= 0; i--)//, a++)

{

a = pWC.a[i];

if ((a.wtFlags & TERM_DYNAMIC) != 0)

{

sqlite3ExprDelete(db, ref a.pExpr);

}

if ((a.wtFlags & TERM_ORINFO) != 0)

{

whereOrInfoDelete(db, a.u.pOrInfo);

}

else if ((a.wtFlags & TERM_ANDINFO) != 0)

{

whereAndInfoDelete(db, a.u.pAndInfo);

}

}

if (pWC.a != pWC.aStatic)

{

sqlite3DbFree(db, ref pWC.a);

}

}

/*

static int whereClauseInsert(WhereClause pWC, Expr p, u8 wtFlags)

{

WhereTerm pTerm;

int idx;

testcase(wtFlags & TERM_VIRTUAL); /* EV: R-00211-15100 */

if (pWC.nTerm >= pWC.nSlot)

{

Array.Resize(ref pWC.a, pWC.nSlot * 2);

pWC.nSlot = pWC.a.Length - 1;

}

pWC.a[idx = pWC.nTerm++] = new WhereTerm();

pTerm = pWC.a[idx];

pTerm.pExpr = p;

pTerm.wtFlags = wtFlags;

pTerm.pWC = pWC;

pTerm.iParent = -1;

return idx;

}

/*

static void whereSplit(WhereClause pWC, Expr pExpr, int op)

{

pWC.op = (u8)op;

if (pExpr == null)

return;

if (pExpr.op != op)

{

whereClauseInsert(pWC, pExpr, 0);

}

else

{

whereSplit(pWC, pExpr.pLeft, op);

whereSplit(pWC, pExpr.pRight, op);

}

}

/*

//#define initMaskSet(P) memset(P, 0, sizeof(*P))

/*

static Bitmask getMask(WhereMaskSet pMaskSet, int iCursor)

{

int i;

Debug.Assert(pMaskSet.n <= (int)sizeof(Bitmask) * 8);

for (i = 0; i < pMaskSet.n; i++)

{

if (pMaskSet.ix[i] == iCursor)

{

return ((Bitmask)1) << i;

}

}

return 0;

}

/*

static void createMask(WhereMaskSet pMaskSet, int iCursor)

{

Debug.Assert(pMaskSet.n < ArraySize(pMaskSet.ix));

pMaskSet.ix[pMaskSet.n++] = iCursor;

}

/*

//static Bitmask exprListTableUsage(WhereMaskSet*, ExprList);

//static Bitmask exprSelectTableUsage(WhereMaskSet*, Select);

static Bitmask exprTableUsage(WhereMaskSet pMaskSet, Expr p)

{

Bitmask mask = 0;

if (p == null)

return 0;

if (p.op == TK_COLUMN)

{

mask = getMask(pMaskSet, p.iTable);

return mask;

}

mask = exprTableUsage(pMaskSet, p.pRight);

mask |= exprTableUsage(pMaskSet, p.pLeft);

if (ExprHasProperty(p, EP_xIsSelect))

{

mask |= exprSelectTableUsage(pMaskSet, p.x.pSelect);

}

else

{

mask |= exprListTableUsage(pMaskSet, p.x.pList);

}

return mask;

}

static Bitmask exprListTableUsage(WhereMaskSet pMaskSet, ExprList pList)

{

int i;

Bitmask mask = 0;

if (pList != null)

{

for (i = 0; i < pList.nExpr; i++)

{

mask |= exprTableUsage(pMaskSet, pList.a[i].pExpr);

}

}

return mask;

}

static Bitmask exprSelectTableUsage(WhereMaskSet pMaskSet, Select pS)

{

Bitmask mask = 0;

while (pS != null)

{

mask |= exprListTableUsage(pMaskSet, pS.pEList);

mask |= exprListTableUsage(pMaskSet, pS.pGroupBy);

mask |= exprListTableUsage(pMaskSet, pS.pOrderBy);

mask |= exprTableUsage(pMaskSet, pS.pWhere);

mask |= exprTableUsage(pMaskSet, pS.pHaving);

pS = pS.pPrior;

}

return mask;

}

/*

static bool allowedOp(int op)

{

Debug.Assert(TK_GT > TK_EQ && TK_GT < TK_GE);

Debug.Assert(TK_LT > TK_EQ && TK_LT < TK_GE);

Debug.Assert(TK_LE > TK_EQ && TK_LE < TK_GE);

Debug.Assert(TK_GE == TK_EQ + 4);

return op == TK_IN || (op >= TK_EQ && op <= TK_GE) || op == TK_ISNULL;

}

/*

//#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}

/*

static void exprCommute(Parse pParse, Expr pExpr)

{

u16 expRight = (u16)(pExpr.pRight.flags & EP_ExpCollate);

u16 expLeft = (u16)(pExpr.pLeft.flags & EP_ExpCollate);

Debug.Assert(allowedOp(pExpr.op) && pExpr.op != TK_IN);

pExpr.pRight.pColl = sqlite3ExprCollSeq(pParse, pExpr.pRight);

pExpr.pLeft.pColl = sqlite3ExprCollSeq(pParse, pExpr.pLeft);

SWAP(ref pExpr.pRight.pColl, ref pExpr.pLeft.pColl);

pExpr.pRight.flags = (u16)((pExpr.pRight.flags & ~EP_ExpCollate) | expLeft);

pExpr.pLeft.flags = (u16)((pExpr.pLeft.flags & ~EP_ExpCollate) | expRight);

SWAP(ref pExpr.pRight, ref pExpr.pLeft);

if (pExpr.op >= TK_GT)

{

Debug.Assert(TK_LT == TK_GT + 2);

Debug.Assert(TK_GE == TK_LE + 2);

Debug.Assert(TK_GT > TK_EQ);

Debug.Assert(TK_GT < TK_LE);

Debug.Assert(pExpr.op >= TK_GT && pExpr.op <= TK_GE);

pExpr.op = (u8)(((pExpr.op - TK_GT) ^ 2) + TK_GT);

}

}

/*

static u16 operatorMask(int op)

{

u16 c;

Debug.Assert(allowedOp(op));

if (op == TK_IN)

{

c = WO_IN;

}

else if (op == TK_ISNULL)

{

c = WO_ISNULL;

}

else

{

Debug.Assert((WO_EQ << (op - TK_EQ)) < 0x7fff);

c = (u16)(WO_EQ << (op - TK_EQ));

}

Debug.Assert(op != TK_ISNULL || c == WO_ISNULL);

Debug.Assert(op != TK_IN || c == WO_IN);

Debug.Assert(op != TK_EQ || c == WO_EQ);

Debug.Assert(op != TK_LT || c == WO_LT);

Debug.Assert(op != TK_LE || c == WO_LE);

Debug.Assert(op != TK_GT || c == WO_GT);

Debug.Assert(op != TK_GE || c == WO_GE);

return c;

}

/*

static WhereTerm findTerm(

WhereClause pWC, /* The WHERE clause to be searched */

int iCur, /* Cursor number of LHS */

int iColumn, /* Column number of LHS */

Bitmask notReady, /* RHS must not overlap with this mask */

u32 op, /* Mask of WO_xx values describing operator */

Index pIdx /* Must be compatible with this index, if not NULL */

)

{

WhereTerm pTerm;

int k;

Debug.Assert(iCur >= 0);

op &= WO_ALL;

for (k = pWC.nTerm; k != 0; k--)//, pTerm++)

{

pTerm = pWC.a[pWC.nTerm - k];

if (pTerm.leftCursor == iCur

&& (pTerm.prereqRight & notReady) == 0

&& pTerm.u.leftColumn == iColumn

&& (pTerm.eOperator & op) != 0

)

{

if (pIdx != null && pTerm.eOperator != WO_ISNULL)

{

Expr pX = pTerm.pExpr;

CollSeq pColl;

char idxaff;

int j;

Parse pParse = pWC.pParse;

idxaff = pIdx.pTable.aCol[iColumn].affinity;

if (!sqlite3IndexAffinityOk(pX, idxaff))

continue;

/* Figure out the collation sequence required from an index for

Debug.Assert(pX.pLeft != null);

pColl = sqlite3BinaryCompareCollSeq(pParse, pX.pLeft, pX.pRight);

Debug.Assert(pColl != null || pParse.nErr != 0);

for (j = 0; pIdx.aiColumn[j] != iColumn; j++)

{

if (NEVER(j >= pIdx.nColumn))

return null;

}

if (pColl != null && !pColl.zName.Equals(pIdx.azColl[j], StringComparison.InvariantCultureIgnoreCase))

continue;

}

return pTerm;

}

}

return null;

}

/* Forward reference */

//static void exprAnalyze(SrcList*, WhereClause*, int);

/*

static void exprAnalyzeAll(

SrcList pTabList, /* the FROM clause */

WhereClause pWC /* the WHERE clause to be analyzed */

)

{

int i;

for (i = pWC.nTerm - 1; i >= 0; i--)

{

exprAnalyze(pTabList, pWC, i);

}

}

#if !SQLITE_OMIT_LIKE_OPTIMIZATION

/*

static int isLikeOrGlob(

Parse pParse, /* Parsing and code generating context */

Expr pExpr, /* Test this expression */

ref Expr ppPrefix, /* Pointer to TK_STRING expression with pattern prefix */

ref bool pisComplete, /* True if the only wildcard is % in the last character */

ref bool pnoCase /* True if uppercase is equivalent to lowercase */

)

{

string z = null; /* String on RHS of LIKE operator */

Expr pRight, pLeft; /* Right and left size of LIKE operator */

ExprList pList; /* List of operands to the LIKE operator */

int c = 0; /* One character in z[] */

int cnt; /* Number of non-wildcard prefix characters */

char[] wc = new char[3]; /* Wildcard characters */

sqlite3 db = pParse.db; /* Data_base connection */

sqlite3_value pVal = null;

int op; /* Opcode of pRight */

if (!sqlite3IsLikeFunction(db, pExpr, ref pnoCase, wc))

{

return 0;

}

//#if SQLITE_EBCDIC

//if( pnoCase ) return 0;

//#endif

pList = pExpr.x.pList;

pLeft = pList.a[1].pExpr;

if (pLeft.op != TK_COLUMN || sqlite3ExprAffinity(pLeft) != SQLITE_AFF_TEXT)

{

/* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must

return 0;

}

Debug.Assert(pLeft.iColumn != (-1)); /* Because IPK never has AFF_TEXT */

pRight = pList.a[0].pExpr;

op = pRight.op;

if (op == TK_REGISTER)

{

op = pRight.op2;

}

if (op == TK_VARIABLE)

{

Vdbe pReprepare = pParse.pReprepare;

int iCol = pRight.iColumn;

pVal = sqlite3VdbeGetValue(pReprepare, iCol, (byte)SQLITE_AFF_NONE);

if (pVal != null && sqlite3_value_type(pVal) == SQLITE_TEXT)

{

z = sqlite3_value_text(pVal);

}

sqlite3VdbeSetVarmask(pParse.pVdbe, iCol); /* IMP: R-23257-02778 */

Debug.Assert(pRight.op == TK_VARIABLE || pRight.op == TK_REGISTER);

}

else if (op == TK_STRING)

{

z = pRight.u.zToken;

}

if (!String.IsNullOrEmpty(z))

{

cnt = 0;

while (cnt < z.Length && (c = z[cnt]) != 0 && c != wc[0] && c != wc[1] && c != wc[2])

{

cnt++;

}

if (cnt != 0 && 255 != (u8)z[cnt - 1])

{

Expr pPrefix;

pisComplete = c == wc[0] && cnt == z.Length - 1;

pPrefix = sqlite3Expr(db, TK_STRING, z);

if (pPrefix != null)

pPrefix.u.zToken = pPrefix.u.zToken.Substring(0, cnt);

ppPrefix = pPrefix;

if (op == TK_VARIABLE)

{

Vdbe v = pParse.pVdbe;

sqlite3VdbeSetVarmask(v, pRight.iColumn); /* IMP: R-23257-02778 */

if (pisComplete && pRight.u.zToken.Length > 1)

{

/* If the rhs of the LIKE expression is a variable, and the current

int r1 = sqlite3GetTempReg(pParse);

sqlite3ExprCodeTarget(pParse, pRight, r1);

sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v) - 1, 0);

sqlite3ReleaseTempReg(pParse, r1);

}

}

}

else

{

z = null;

}

}

sqlite3ValueFree(ref pVal);

return (z != null) ? 1 : 0;

}

#endif //* SQLITE_OMIT_LIKE_OPTIMIZATION */

#if !SQLITE_OMIT_VIRTUALTABLE

/*

static int isMatchOfColumn(

Expr pExpr /* Test this expression */

)

{

ExprList pList;

if (pExpr.op != TK_FUNCTION)

{

return 0;

}

if (!pExpr.u.zToken.Equals("match", StringComparison.InvariantCultureIgnoreCase))

{

return 0;

}

pList = pExpr.x.pList;

if (pList.nExpr != 2)

{

return 0;

}

if (pList.a[1].pExpr.op != TK_COLUMN)

{

return 0;

}

return 1;

}

#endif //* SQLITE_OMIT_VIRTUALTABLE */

/*

static void transferJoinMarkings(Expr pDerived, Expr pBase)

{

pDerived.flags = (u16)(pDerived.flags | pBase.flags & EP_FromJoin);

pDerived.iRightJoinTable = pBase.iRightJoinTable;

}

#if !(SQLITE_OMIT_OR_OPTIMIZATION) && !(SQLITE_OMIT_SUBQUERY)

/*