Annotation of embedaddon/sqlite3/src/expr.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2001 September 15
! 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 routines used for analyzing expressions and
! 13: ** for generating VDBE code that evaluates expressions in SQLite.
! 14: */
! 15: #include "sqliteInt.h"
! 16:
! 17: /*
! 18: ** Return the 'affinity' of the expression pExpr if any.
! 19: **
! 20: ** If pExpr is a column, a reference to a column via an 'AS' alias,
! 21: ** or a sub-select with a column as the return value, then the
! 22: ** affinity of that column is returned. Otherwise, 0x00 is returned,
! 23: ** indicating no affinity for the expression.
! 24: **
! 25: ** i.e. the WHERE clause expresssions in the following statements all
! 26: ** have an affinity:
! 27: **
! 28: ** CREATE TABLE t1(a);
! 29: ** SELECT * FROM t1 WHERE a;
! 30: ** SELECT a AS b FROM t1 WHERE b;
! 31: ** SELECT * FROM t1 WHERE (select a from t1);
! 32: */
! 33: char sqlite3ExprAffinity(Expr *pExpr){
! 34: int op = pExpr->op;
! 35: if( op==TK_SELECT ){
! 36: assert( pExpr->flags&EP_xIsSelect );
! 37: return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
! 38: }
! 39: #ifndef SQLITE_OMIT_CAST
! 40: if( op==TK_CAST ){
! 41: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 42: return sqlite3AffinityType(pExpr->u.zToken);
! 43: }
! 44: #endif
! 45: if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER)
! 46: && pExpr->pTab!=0
! 47: ){
! 48: /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
! 49: ** a TK_COLUMN but was previously evaluated and cached in a register */
! 50: int j = pExpr->iColumn;
! 51: if( j<0 ) return SQLITE_AFF_INTEGER;
! 52: assert( pExpr->pTab && j<pExpr->pTab->nCol );
! 53: return pExpr->pTab->aCol[j].affinity;
! 54: }
! 55: return pExpr->affinity;
! 56: }
! 57:
! 58: /*
! 59: ** Set the explicit collating sequence for an expression to the
! 60: ** collating sequence supplied in the second argument.
! 61: */
! 62: Expr *sqlite3ExprSetColl(Expr *pExpr, CollSeq *pColl){
! 63: if( pExpr && pColl ){
! 64: pExpr->pColl = pColl;
! 65: pExpr->flags |= EP_ExpCollate;
! 66: }
! 67: return pExpr;
! 68: }
! 69:
! 70: /*
! 71: ** Set the collating sequence for expression pExpr to be the collating
! 72: ** sequence named by pToken. Return a pointer to the revised expression.
! 73: ** The collating sequence is marked as "explicit" using the EP_ExpCollate
! 74: ** flag. An explicit collating sequence will override implicit
! 75: ** collating sequences.
! 76: */
! 77: Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
! 78: char *zColl = 0; /* Dequoted name of collation sequence */
! 79: CollSeq *pColl;
! 80: sqlite3 *db = pParse->db;
! 81: zColl = sqlite3NameFromToken(db, pCollName);
! 82: pColl = sqlite3LocateCollSeq(pParse, zColl);
! 83: sqlite3ExprSetColl(pExpr, pColl);
! 84: sqlite3DbFree(db, zColl);
! 85: return pExpr;
! 86: }
! 87:
! 88: /*
! 89: ** Return the default collation sequence for the expression pExpr. If
! 90: ** there is no default collation type, return 0.
! 91: */
! 92: CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
! 93: CollSeq *pColl = 0;
! 94: Expr *p = pExpr;
! 95: while( p ){
! 96: int op;
! 97: pColl = p->pColl;
! 98: if( pColl ) break;
! 99: op = p->op;
! 100: if( p->pTab!=0 && (
! 101: op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
! 102: )){
! 103: /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
! 104: ** a TK_COLUMN but was previously evaluated and cached in a register */
! 105: const char *zColl;
! 106: int j = p->iColumn;
! 107: if( j>=0 ){
! 108: sqlite3 *db = pParse->db;
! 109: zColl = p->pTab->aCol[j].zColl;
! 110: pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
! 111: pExpr->pColl = pColl;
! 112: }
! 113: break;
! 114: }
! 115: if( op!=TK_CAST && op!=TK_UPLUS ){
! 116: break;
! 117: }
! 118: p = p->pLeft;
! 119: }
! 120: if( sqlite3CheckCollSeq(pParse, pColl) ){
! 121: pColl = 0;
! 122: }
! 123: return pColl;
! 124: }
! 125:
! 126: /*
! 127: ** pExpr is an operand of a comparison operator. aff2 is the
! 128: ** type affinity of the other operand. This routine returns the
! 129: ** type affinity that should be used for the comparison operator.
! 130: */
! 131: char sqlite3CompareAffinity(Expr *pExpr, char aff2){
! 132: char aff1 = sqlite3ExprAffinity(pExpr);
! 133: if( aff1 && aff2 ){
! 134: /* Both sides of the comparison are columns. If one has numeric
! 135: ** affinity, use that. Otherwise use no affinity.
! 136: */
! 137: if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
! 138: return SQLITE_AFF_NUMERIC;
! 139: }else{
! 140: return SQLITE_AFF_NONE;
! 141: }
! 142: }else if( !aff1 && !aff2 ){
! 143: /* Neither side of the comparison is a column. Compare the
! 144: ** results directly.
! 145: */
! 146: return SQLITE_AFF_NONE;
! 147: }else{
! 148: /* One side is a column, the other is not. Use the columns affinity. */
! 149: assert( aff1==0 || aff2==0 );
! 150: return (aff1 + aff2);
! 151: }
! 152: }
! 153:
! 154: /*
! 155: ** pExpr is a comparison operator. Return the type affinity that should
! 156: ** be applied to both operands prior to doing the comparison.
! 157: */
! 158: static char comparisonAffinity(Expr *pExpr){
! 159: char aff;
! 160: assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
! 161: pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
! 162: pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
! 163: assert( pExpr->pLeft );
! 164: aff = sqlite3ExprAffinity(pExpr->pLeft);
! 165: if( pExpr->pRight ){
! 166: aff = sqlite3CompareAffinity(pExpr->pRight, aff);
! 167: }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
! 168: aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
! 169: }else if( !aff ){
! 170: aff = SQLITE_AFF_NONE;
! 171: }
! 172: return aff;
! 173: }
! 174:
! 175: /*
! 176: ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
! 177: ** idx_affinity is the affinity of an indexed column. Return true
! 178: ** if the index with affinity idx_affinity may be used to implement
! 179: ** the comparison in pExpr.
! 180: */
! 181: int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
! 182: char aff = comparisonAffinity(pExpr);
! 183: switch( aff ){
! 184: case SQLITE_AFF_NONE:
! 185: return 1;
! 186: case SQLITE_AFF_TEXT:
! 187: return idx_affinity==SQLITE_AFF_TEXT;
! 188: default:
! 189: return sqlite3IsNumericAffinity(idx_affinity);
! 190: }
! 191: }
! 192:
! 193: /*
! 194: ** Return the P5 value that should be used for a binary comparison
! 195: ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
! 196: */
! 197: static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
! 198: u8 aff = (char)sqlite3ExprAffinity(pExpr2);
! 199: aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
! 200: return aff;
! 201: }
! 202:
! 203: /*
! 204: ** Return a pointer to the collation sequence that should be used by
! 205: ** a binary comparison operator comparing pLeft and pRight.
! 206: **
! 207: ** If the left hand expression has a collating sequence type, then it is
! 208: ** used. Otherwise the collation sequence for the right hand expression
! 209: ** is used, or the default (BINARY) if neither expression has a collating
! 210: ** type.
! 211: **
! 212: ** Argument pRight (but not pLeft) may be a null pointer. In this case,
! 213: ** it is not considered.
! 214: */
! 215: CollSeq *sqlite3BinaryCompareCollSeq(
! 216: Parse *pParse,
! 217: Expr *pLeft,
! 218: Expr *pRight
! 219: ){
! 220: CollSeq *pColl;
! 221: assert( pLeft );
! 222: if( pLeft->flags & EP_ExpCollate ){
! 223: assert( pLeft->pColl );
! 224: pColl = pLeft->pColl;
! 225: }else if( pRight && pRight->flags & EP_ExpCollate ){
! 226: assert( pRight->pColl );
! 227: pColl = pRight->pColl;
! 228: }else{
! 229: pColl = sqlite3ExprCollSeq(pParse, pLeft);
! 230: if( !pColl ){
! 231: pColl = sqlite3ExprCollSeq(pParse, pRight);
! 232: }
! 233: }
! 234: return pColl;
! 235: }
! 236:
! 237: /*
! 238: ** Generate code for a comparison operator.
! 239: */
! 240: static int codeCompare(
! 241: Parse *pParse, /* The parsing (and code generating) context */
! 242: Expr *pLeft, /* The left operand */
! 243: Expr *pRight, /* The right operand */
! 244: int opcode, /* The comparison opcode */
! 245: int in1, int in2, /* Register holding operands */
! 246: int dest, /* Jump here if true. */
! 247: int jumpIfNull /* If true, jump if either operand is NULL */
! 248: ){
! 249: int p5;
! 250: int addr;
! 251: CollSeq *p4;
! 252:
! 253: p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
! 254: p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
! 255: addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
! 256: (void*)p4, P4_COLLSEQ);
! 257: sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
! 258: return addr;
! 259: }
! 260:
! 261: #if SQLITE_MAX_EXPR_DEPTH>0
! 262: /*
! 263: ** Check that argument nHeight is less than or equal to the maximum
! 264: ** expression depth allowed. If it is not, leave an error message in
! 265: ** pParse.
! 266: */
! 267: int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
! 268: int rc = SQLITE_OK;
! 269: int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
! 270: if( nHeight>mxHeight ){
! 271: sqlite3ErrorMsg(pParse,
! 272: "Expression tree is too large (maximum depth %d)", mxHeight
! 273: );
! 274: rc = SQLITE_ERROR;
! 275: }
! 276: return rc;
! 277: }
! 278:
! 279: /* The following three functions, heightOfExpr(), heightOfExprList()
! 280: ** and heightOfSelect(), are used to determine the maximum height
! 281: ** of any expression tree referenced by the structure passed as the
! 282: ** first argument.
! 283: **
! 284: ** If this maximum height is greater than the current value pointed
! 285: ** to by pnHeight, the second parameter, then set *pnHeight to that
! 286: ** value.
! 287: */
! 288: static void heightOfExpr(Expr *p, int *pnHeight){
! 289: if( p ){
! 290: if( p->nHeight>*pnHeight ){
! 291: *pnHeight = p->nHeight;
! 292: }
! 293: }
! 294: }
! 295: static void heightOfExprList(ExprList *p, int *pnHeight){
! 296: if( p ){
! 297: int i;
! 298: for(i=0; i<p->nExpr; i++){
! 299: heightOfExpr(p->a[i].pExpr, pnHeight);
! 300: }
! 301: }
! 302: }
! 303: static void heightOfSelect(Select *p, int *pnHeight){
! 304: if( p ){
! 305: heightOfExpr(p->pWhere, pnHeight);
! 306: heightOfExpr(p->pHaving, pnHeight);
! 307: heightOfExpr(p->pLimit, pnHeight);
! 308: heightOfExpr(p->pOffset, pnHeight);
! 309: heightOfExprList(p->pEList, pnHeight);
! 310: heightOfExprList(p->pGroupBy, pnHeight);
! 311: heightOfExprList(p->pOrderBy, pnHeight);
! 312: heightOfSelect(p->pPrior, pnHeight);
! 313: }
! 314: }
! 315:
! 316: /*
! 317: ** Set the Expr.nHeight variable in the structure passed as an
! 318: ** argument. An expression with no children, Expr.pList or
! 319: ** Expr.pSelect member has a height of 1. Any other expression
! 320: ** has a height equal to the maximum height of any other
! 321: ** referenced Expr plus one.
! 322: */
! 323: static void exprSetHeight(Expr *p){
! 324: int nHeight = 0;
! 325: heightOfExpr(p->pLeft, &nHeight);
! 326: heightOfExpr(p->pRight, &nHeight);
! 327: if( ExprHasProperty(p, EP_xIsSelect) ){
! 328: heightOfSelect(p->x.pSelect, &nHeight);
! 329: }else{
! 330: heightOfExprList(p->x.pList, &nHeight);
! 331: }
! 332: p->nHeight = nHeight + 1;
! 333: }
! 334:
! 335: /*
! 336: ** Set the Expr.nHeight variable using the exprSetHeight() function. If
! 337: ** the height is greater than the maximum allowed expression depth,
! 338: ** leave an error in pParse.
! 339: */
! 340: void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
! 341: exprSetHeight(p);
! 342: sqlite3ExprCheckHeight(pParse, p->nHeight);
! 343: }
! 344:
! 345: /*
! 346: ** Return the maximum height of any expression tree referenced
! 347: ** by the select statement passed as an argument.
! 348: */
! 349: int sqlite3SelectExprHeight(Select *p){
! 350: int nHeight = 0;
! 351: heightOfSelect(p, &nHeight);
! 352: return nHeight;
! 353: }
! 354: #else
! 355: #define exprSetHeight(y)
! 356: #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
! 357:
! 358: /*
! 359: ** This routine is the core allocator for Expr nodes.
! 360: **
! 361: ** Construct a new expression node and return a pointer to it. Memory
! 362: ** for this node and for the pToken argument is a single allocation
! 363: ** obtained from sqlite3DbMalloc(). The calling function
! 364: ** is responsible for making sure the node eventually gets freed.
! 365: **
! 366: ** If dequote is true, then the token (if it exists) is dequoted.
! 367: ** If dequote is false, no dequoting is performance. The deQuote
! 368: ** parameter is ignored if pToken is NULL or if the token does not
! 369: ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
! 370: ** then the EP_DblQuoted flag is set on the expression node.
! 371: **
! 372: ** Special case: If op==TK_INTEGER and pToken points to a string that
! 373: ** can be translated into a 32-bit integer, then the token is not
! 374: ** stored in u.zToken. Instead, the integer values is written
! 375: ** into u.iValue and the EP_IntValue flag is set. No extra storage
! 376: ** is allocated to hold the integer text and the dequote flag is ignored.
! 377: */
! 378: Expr *sqlite3ExprAlloc(
! 379: sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
! 380: int op, /* Expression opcode */
! 381: const Token *pToken, /* Token argument. Might be NULL */
! 382: int dequote /* True to dequote */
! 383: ){
! 384: Expr *pNew;
! 385: int nExtra = 0;
! 386: int iValue = 0;
! 387:
! 388: if( pToken ){
! 389: if( op!=TK_INTEGER || pToken->z==0
! 390: || sqlite3GetInt32(pToken->z, &iValue)==0 ){
! 391: nExtra = pToken->n+1;
! 392: assert( iValue>=0 );
! 393: }
! 394: }
! 395: pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
! 396: if( pNew ){
! 397: pNew->op = (u8)op;
! 398: pNew->iAgg = -1;
! 399: if( pToken ){
! 400: if( nExtra==0 ){
! 401: pNew->flags |= EP_IntValue;
! 402: pNew->u.iValue = iValue;
! 403: }else{
! 404: int c;
! 405: pNew->u.zToken = (char*)&pNew[1];
! 406: assert( pToken->z!=0 || pToken->n==0 );
! 407: if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
! 408: pNew->u.zToken[pToken->n] = 0;
! 409: if( dequote && nExtra>=3
! 410: && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
! 411: sqlite3Dequote(pNew->u.zToken);
! 412: if( c=='"' ) pNew->flags |= EP_DblQuoted;
! 413: }
! 414: }
! 415: }
! 416: #if SQLITE_MAX_EXPR_DEPTH>0
! 417: pNew->nHeight = 1;
! 418: #endif
! 419: }
! 420: return pNew;
! 421: }
! 422:
! 423: /*
! 424: ** Allocate a new expression node from a zero-terminated token that has
! 425: ** already been dequoted.
! 426: */
! 427: Expr *sqlite3Expr(
! 428: sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
! 429: int op, /* Expression opcode */
! 430: const char *zToken /* Token argument. Might be NULL */
! 431: ){
! 432: Token x;
! 433: x.z = zToken;
! 434: x.n = zToken ? sqlite3Strlen30(zToken) : 0;
! 435: return sqlite3ExprAlloc(db, op, &x, 0);
! 436: }
! 437:
! 438: /*
! 439: ** Attach subtrees pLeft and pRight to the Expr node pRoot.
! 440: **
! 441: ** If pRoot==NULL that means that a memory allocation error has occurred.
! 442: ** In that case, delete the subtrees pLeft and pRight.
! 443: */
! 444: void sqlite3ExprAttachSubtrees(
! 445: sqlite3 *db,
! 446: Expr *pRoot,
! 447: Expr *pLeft,
! 448: Expr *pRight
! 449: ){
! 450: if( pRoot==0 ){
! 451: assert( db->mallocFailed );
! 452: sqlite3ExprDelete(db, pLeft);
! 453: sqlite3ExprDelete(db, pRight);
! 454: }else{
! 455: if( pRight ){
! 456: pRoot->pRight = pRight;
! 457: if( pRight->flags & EP_ExpCollate ){
! 458: pRoot->flags |= EP_ExpCollate;
! 459: pRoot->pColl = pRight->pColl;
! 460: }
! 461: }
! 462: if( pLeft ){
! 463: pRoot->pLeft = pLeft;
! 464: if( pLeft->flags & EP_ExpCollate ){
! 465: pRoot->flags |= EP_ExpCollate;
! 466: pRoot->pColl = pLeft->pColl;
! 467: }
! 468: }
! 469: exprSetHeight(pRoot);
! 470: }
! 471: }
! 472:
! 473: /*
! 474: ** Allocate a Expr node which joins as many as two subtrees.
! 475: **
! 476: ** One or both of the subtrees can be NULL. Return a pointer to the new
! 477: ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
! 478: ** free the subtrees and return NULL.
! 479: */
! 480: Expr *sqlite3PExpr(
! 481: Parse *pParse, /* Parsing context */
! 482: int op, /* Expression opcode */
! 483: Expr *pLeft, /* Left operand */
! 484: Expr *pRight, /* Right operand */
! 485: const Token *pToken /* Argument token */
! 486: ){
! 487: Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
! 488: sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
! 489: if( p ) {
! 490: sqlite3ExprCheckHeight(pParse, p->nHeight);
! 491: }
! 492: return p;
! 493: }
! 494:
! 495: /*
! 496: ** Join two expressions using an AND operator. If either expression is
! 497: ** NULL, then just return the other expression.
! 498: */
! 499: Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
! 500: if( pLeft==0 ){
! 501: return pRight;
! 502: }else if( pRight==0 ){
! 503: return pLeft;
! 504: }else{
! 505: Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
! 506: sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
! 507: return pNew;
! 508: }
! 509: }
! 510:
! 511: /*
! 512: ** Construct a new expression node for a function with multiple
! 513: ** arguments.
! 514: */
! 515: Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
! 516: Expr *pNew;
! 517: sqlite3 *db = pParse->db;
! 518: assert( pToken );
! 519: pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
! 520: if( pNew==0 ){
! 521: sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
! 522: return 0;
! 523: }
! 524: pNew->x.pList = pList;
! 525: assert( !ExprHasProperty(pNew, EP_xIsSelect) );
! 526: sqlite3ExprSetHeight(pParse, pNew);
! 527: return pNew;
! 528: }
! 529:
! 530: /*
! 531: ** Assign a variable number to an expression that encodes a wildcard
! 532: ** in the original SQL statement.
! 533: **
! 534: ** Wildcards consisting of a single "?" are assigned the next sequential
! 535: ** variable number.
! 536: **
! 537: ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
! 538: ** sure "nnn" is not too be to avoid a denial of service attack when
! 539: ** the SQL statement comes from an external source.
! 540: **
! 541: ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
! 542: ** as the previous instance of the same wildcard. Or if this is the first
! 543: ** instance of the wildcard, the next sequenial variable number is
! 544: ** assigned.
! 545: */
! 546: void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
! 547: sqlite3 *db = pParse->db;
! 548: const char *z;
! 549:
! 550: if( pExpr==0 ) return;
! 551: assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
! 552: z = pExpr->u.zToken;
! 553: assert( z!=0 );
! 554: assert( z[0]!=0 );
! 555: if( z[1]==0 ){
! 556: /* Wildcard of the form "?". Assign the next variable number */
! 557: assert( z[0]=='?' );
! 558: pExpr->iColumn = (ynVar)(++pParse->nVar);
! 559: }else{
! 560: ynVar x = 0;
! 561: u32 n = sqlite3Strlen30(z);
! 562: if( z[0]=='?' ){
! 563: /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
! 564: ** use it as the variable number */
! 565: i64 i;
! 566: int bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
! 567: pExpr->iColumn = x = (ynVar)i;
! 568: testcase( i==0 );
! 569: testcase( i==1 );
! 570: testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
! 571: testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
! 572: if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
! 573: sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
! 574: db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
! 575: x = 0;
! 576: }
! 577: if( i>pParse->nVar ){
! 578: pParse->nVar = (int)i;
! 579: }
! 580: }else{
! 581: /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
! 582: ** number as the prior appearance of the same name, or if the name
! 583: ** has never appeared before, reuse the same variable number
! 584: */
! 585: ynVar i;
! 586: for(i=0; i<pParse->nzVar; i++){
! 587: if( pParse->azVar[i] && memcmp(pParse->azVar[i],z,n+1)==0 ){
! 588: pExpr->iColumn = x = (ynVar)i+1;
! 589: break;
! 590: }
! 591: }
! 592: if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
! 593: }
! 594: if( x>0 ){
! 595: if( x>pParse->nzVar ){
! 596: char **a;
! 597: a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
! 598: if( a==0 ) return; /* Error reported through db->mallocFailed */
! 599: pParse->azVar = a;
! 600: memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
! 601: pParse->nzVar = x;
! 602: }
! 603: if( z[0]!='?' || pParse->azVar[x-1]==0 ){
! 604: sqlite3DbFree(db, pParse->azVar[x-1]);
! 605: pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
! 606: }
! 607: }
! 608: }
! 609: if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
! 610: sqlite3ErrorMsg(pParse, "too many SQL variables");
! 611: }
! 612: }
! 613:
! 614: /*
! 615: ** Recursively delete an expression tree.
! 616: */
! 617: void sqlite3ExprDelete(sqlite3 *db, Expr *p){
! 618: if( p==0 ) return;
! 619: /* Sanity check: Assert that the IntValue is non-negative if it exists */
! 620: assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
! 621: if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
! 622: sqlite3ExprDelete(db, p->pLeft);
! 623: sqlite3ExprDelete(db, p->pRight);
! 624: if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
! 625: sqlite3DbFree(db, p->u.zToken);
! 626: }
! 627: if( ExprHasProperty(p, EP_xIsSelect) ){
! 628: sqlite3SelectDelete(db, p->x.pSelect);
! 629: }else{
! 630: sqlite3ExprListDelete(db, p->x.pList);
! 631: }
! 632: }
! 633: if( !ExprHasProperty(p, EP_Static) ){
! 634: sqlite3DbFree(db, p);
! 635: }
! 636: }
! 637:
! 638: /*
! 639: ** Return the number of bytes allocated for the expression structure
! 640: ** passed as the first argument. This is always one of EXPR_FULLSIZE,
! 641: ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
! 642: */
! 643: static int exprStructSize(Expr *p){
! 644: if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
! 645: if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
! 646: return EXPR_FULLSIZE;
! 647: }
! 648:
! 649: /*
! 650: ** The dupedExpr*Size() routines each return the number of bytes required
! 651: ** to store a copy of an expression or expression tree. They differ in
! 652: ** how much of the tree is measured.
! 653: **
! 654: ** dupedExprStructSize() Size of only the Expr structure
! 655: ** dupedExprNodeSize() Size of Expr + space for token
! 656: ** dupedExprSize() Expr + token + subtree components
! 657: **
! 658: ***************************************************************************
! 659: **
! 660: ** The dupedExprStructSize() function returns two values OR-ed together:
! 661: ** (1) the space required for a copy of the Expr structure only and
! 662: ** (2) the EP_xxx flags that indicate what the structure size should be.
! 663: ** The return values is always one of:
! 664: **
! 665: ** EXPR_FULLSIZE
! 666: ** EXPR_REDUCEDSIZE | EP_Reduced
! 667: ** EXPR_TOKENONLYSIZE | EP_TokenOnly
! 668: **
! 669: ** The size of the structure can be found by masking the return value
! 670: ** of this routine with 0xfff. The flags can be found by masking the
! 671: ** return value with EP_Reduced|EP_TokenOnly.
! 672: **
! 673: ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
! 674: ** (unreduced) Expr objects as they or originally constructed by the parser.
! 675: ** During expression analysis, extra information is computed and moved into
! 676: ** later parts of teh Expr object and that extra information might get chopped
! 677: ** off if the expression is reduced. Note also that it does not work to
! 678: ** make a EXPRDUP_REDUCE copy of a reduced expression. It is only legal
! 679: ** to reduce a pristine expression tree from the parser. The implementation
! 680: ** of dupedExprStructSize() contain multiple assert() statements that attempt
! 681: ** to enforce this constraint.
! 682: */
! 683: static int dupedExprStructSize(Expr *p, int flags){
! 684: int nSize;
! 685: assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
! 686: if( 0==(flags&EXPRDUP_REDUCE) ){
! 687: nSize = EXPR_FULLSIZE;
! 688: }else{
! 689: assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
! 690: assert( !ExprHasProperty(p, EP_FromJoin) );
! 691: assert( (p->flags2 & EP2_MallocedToken)==0 );
! 692: assert( (p->flags2 & EP2_Irreducible)==0 );
! 693: if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
! 694: nSize = EXPR_REDUCEDSIZE | EP_Reduced;
! 695: }else{
! 696: nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
! 697: }
! 698: }
! 699: return nSize;
! 700: }
! 701:
! 702: /*
! 703: ** This function returns the space in bytes required to store the copy
! 704: ** of the Expr structure and a copy of the Expr.u.zToken string (if that
! 705: ** string is defined.)
! 706: */
! 707: static int dupedExprNodeSize(Expr *p, int flags){
! 708: int nByte = dupedExprStructSize(p, flags) & 0xfff;
! 709: if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
! 710: nByte += sqlite3Strlen30(p->u.zToken)+1;
! 711: }
! 712: return ROUND8(nByte);
! 713: }
! 714:
! 715: /*
! 716: ** Return the number of bytes required to create a duplicate of the
! 717: ** expression passed as the first argument. The second argument is a
! 718: ** mask containing EXPRDUP_XXX flags.
! 719: **
! 720: ** The value returned includes space to create a copy of the Expr struct
! 721: ** itself and the buffer referred to by Expr.u.zToken, if any.
! 722: **
! 723: ** If the EXPRDUP_REDUCE flag is set, then the return value includes
! 724: ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
! 725: ** and Expr.pRight variables (but not for any structures pointed to or
! 726: ** descended from the Expr.x.pList or Expr.x.pSelect variables).
! 727: */
! 728: static int dupedExprSize(Expr *p, int flags){
! 729: int nByte = 0;
! 730: if( p ){
! 731: nByte = dupedExprNodeSize(p, flags);
! 732: if( flags&EXPRDUP_REDUCE ){
! 733: nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
! 734: }
! 735: }
! 736: return nByte;
! 737: }
! 738:
! 739: /*
! 740: ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
! 741: ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
! 742: ** to store the copy of expression p, the copies of p->u.zToken
! 743: ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
! 744: ** if any. Before returning, *pzBuffer is set to the first byte passed the
! 745: ** portion of the buffer copied into by this function.
! 746: */
! 747: static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
! 748: Expr *pNew = 0; /* Value to return */
! 749: if( p ){
! 750: const int isReduced = (flags&EXPRDUP_REDUCE);
! 751: u8 *zAlloc;
! 752: u32 staticFlag = 0;
! 753:
! 754: assert( pzBuffer==0 || isReduced );
! 755:
! 756: /* Figure out where to write the new Expr structure. */
! 757: if( pzBuffer ){
! 758: zAlloc = *pzBuffer;
! 759: staticFlag = EP_Static;
! 760: }else{
! 761: zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
! 762: }
! 763: pNew = (Expr *)zAlloc;
! 764:
! 765: if( pNew ){
! 766: /* Set nNewSize to the size allocated for the structure pointed to
! 767: ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
! 768: ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
! 769: ** by the copy of the p->u.zToken string (if any).
! 770: */
! 771: const unsigned nStructSize = dupedExprStructSize(p, flags);
! 772: const int nNewSize = nStructSize & 0xfff;
! 773: int nToken;
! 774: if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
! 775: nToken = sqlite3Strlen30(p->u.zToken) + 1;
! 776: }else{
! 777: nToken = 0;
! 778: }
! 779: if( isReduced ){
! 780: assert( ExprHasProperty(p, EP_Reduced)==0 );
! 781: memcpy(zAlloc, p, nNewSize);
! 782: }else{
! 783: int nSize = exprStructSize(p);
! 784: memcpy(zAlloc, p, nSize);
! 785: memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
! 786: }
! 787:
! 788: /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
! 789: pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
! 790: pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
! 791: pNew->flags |= staticFlag;
! 792:
! 793: /* Copy the p->u.zToken string, if any. */
! 794: if( nToken ){
! 795: char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
! 796: memcpy(zToken, p->u.zToken, nToken);
! 797: }
! 798:
! 799: if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
! 800: /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
! 801: if( ExprHasProperty(p, EP_xIsSelect) ){
! 802: pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
! 803: }else{
! 804: pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
! 805: }
! 806: }
! 807:
! 808: /* Fill in pNew->pLeft and pNew->pRight. */
! 809: if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
! 810: zAlloc += dupedExprNodeSize(p, flags);
! 811: if( ExprHasProperty(pNew, EP_Reduced) ){
! 812: pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
! 813: pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
! 814: }
! 815: if( pzBuffer ){
! 816: *pzBuffer = zAlloc;
! 817: }
! 818: }else{
! 819: pNew->flags2 = 0;
! 820: if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
! 821: pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
! 822: pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
! 823: }
! 824: }
! 825:
! 826: }
! 827: }
! 828: return pNew;
! 829: }
! 830:
! 831: /*
! 832: ** The following group of routines make deep copies of expressions,
! 833: ** expression lists, ID lists, and select statements. The copies can
! 834: ** be deleted (by being passed to their respective ...Delete() routines)
! 835: ** without effecting the originals.
! 836: **
! 837: ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
! 838: ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
! 839: ** by subsequent calls to sqlite*ListAppend() routines.
! 840: **
! 841: ** Any tables that the SrcList might point to are not duplicated.
! 842: **
! 843: ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
! 844: ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
! 845: ** truncated version of the usual Expr structure that will be stored as
! 846: ** part of the in-memory representation of the database schema.
! 847: */
! 848: Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
! 849: return exprDup(db, p, flags, 0);
! 850: }
! 851: ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
! 852: ExprList *pNew;
! 853: struct ExprList_item *pItem, *pOldItem;
! 854: int i;
! 855: if( p==0 ) return 0;
! 856: pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
! 857: if( pNew==0 ) return 0;
! 858: pNew->iECursor = 0;
! 859: pNew->nExpr = pNew->nAlloc = p->nExpr;
! 860: pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
! 861: if( pItem==0 ){
! 862: sqlite3DbFree(db, pNew);
! 863: return 0;
! 864: }
! 865: pOldItem = p->a;
! 866: for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
! 867: Expr *pOldExpr = pOldItem->pExpr;
! 868: pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
! 869: pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
! 870: pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
! 871: pItem->sortOrder = pOldItem->sortOrder;
! 872: pItem->done = 0;
! 873: pItem->iOrderByCol = pOldItem->iOrderByCol;
! 874: pItem->iAlias = pOldItem->iAlias;
! 875: }
! 876: return pNew;
! 877: }
! 878:
! 879: /*
! 880: ** If cursors, triggers, views and subqueries are all omitted from
! 881: ** the build, then none of the following routines, except for
! 882: ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
! 883: ** called with a NULL argument.
! 884: */
! 885: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
! 886: || !defined(SQLITE_OMIT_SUBQUERY)
! 887: SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
! 888: SrcList *pNew;
! 889: int i;
! 890: int nByte;
! 891: if( p==0 ) return 0;
! 892: nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
! 893: pNew = sqlite3DbMallocRaw(db, nByte );
! 894: if( pNew==0 ) return 0;
! 895: pNew->nSrc = pNew->nAlloc = p->nSrc;
! 896: for(i=0; i<p->nSrc; i++){
! 897: struct SrcList_item *pNewItem = &pNew->a[i];
! 898: struct SrcList_item *pOldItem = &p->a[i];
! 899: Table *pTab;
! 900: pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
! 901: pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
! 902: pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
! 903: pNewItem->jointype = pOldItem->jointype;
! 904: pNewItem->iCursor = pOldItem->iCursor;
! 905: pNewItem->addrFillSub = pOldItem->addrFillSub;
! 906: pNewItem->regReturn = pOldItem->regReturn;
! 907: pNewItem->isCorrelated = pOldItem->isCorrelated;
! 908: pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
! 909: pNewItem->notIndexed = pOldItem->notIndexed;
! 910: pNewItem->pIndex = pOldItem->pIndex;
! 911: pTab = pNewItem->pTab = pOldItem->pTab;
! 912: if( pTab ){
! 913: pTab->nRef++;
! 914: }
! 915: pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
! 916: pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
! 917: pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
! 918: pNewItem->colUsed = pOldItem->colUsed;
! 919: }
! 920: return pNew;
! 921: }
! 922: IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
! 923: IdList *pNew;
! 924: int i;
! 925: if( p==0 ) return 0;
! 926: pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
! 927: if( pNew==0 ) return 0;
! 928: pNew->nId = pNew->nAlloc = p->nId;
! 929: pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
! 930: if( pNew->a==0 ){
! 931: sqlite3DbFree(db, pNew);
! 932: return 0;
! 933: }
! 934: for(i=0; i<p->nId; i++){
! 935: struct IdList_item *pNewItem = &pNew->a[i];
! 936: struct IdList_item *pOldItem = &p->a[i];
! 937: pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
! 938: pNewItem->idx = pOldItem->idx;
! 939: }
! 940: return pNew;
! 941: }
! 942: Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
! 943: Select *pNew, *pPrior;
! 944: if( p==0 ) return 0;
! 945: pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
! 946: if( pNew==0 ) return 0;
! 947: pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
! 948: pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
! 949: pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
! 950: pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
! 951: pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
! 952: pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
! 953: pNew->op = p->op;
! 954: pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
! 955: if( pPrior ) pPrior->pNext = pNew;
! 956: pNew->pNext = 0;
! 957: pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
! 958: pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
! 959: pNew->iLimit = 0;
! 960: pNew->iOffset = 0;
! 961: pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
! 962: pNew->pRightmost = 0;
! 963: pNew->addrOpenEphm[0] = -1;
! 964: pNew->addrOpenEphm[1] = -1;
! 965: pNew->addrOpenEphm[2] = -1;
! 966: return pNew;
! 967: }
! 968: #else
! 969: Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
! 970: assert( p==0 );
! 971: return 0;
! 972: }
! 973: #endif
! 974:
! 975:
! 976: /*
! 977: ** Add a new element to the end of an expression list. If pList is
! 978: ** initially NULL, then create a new expression list.
! 979: **
! 980: ** If a memory allocation error occurs, the entire list is freed and
! 981: ** NULL is returned. If non-NULL is returned, then it is guaranteed
! 982: ** that the new entry was successfully appended.
! 983: */
! 984: ExprList *sqlite3ExprListAppend(
! 985: Parse *pParse, /* Parsing context */
! 986: ExprList *pList, /* List to which to append. Might be NULL */
! 987: Expr *pExpr /* Expression to be appended. Might be NULL */
! 988: ){
! 989: sqlite3 *db = pParse->db;
! 990: if( pList==0 ){
! 991: pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
! 992: if( pList==0 ){
! 993: goto no_mem;
! 994: }
! 995: assert( pList->nAlloc==0 );
! 996: }
! 997: if( pList->nAlloc<=pList->nExpr ){
! 998: struct ExprList_item *a;
! 999: int n = pList->nAlloc*2 + 4;
! 1000: a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
! 1001: if( a==0 ){
! 1002: goto no_mem;
! 1003: }
! 1004: pList->a = a;
! 1005: pList->nAlloc = sqlite3DbMallocSize(db, a)/sizeof(a[0]);
! 1006: }
! 1007: assert( pList->a!=0 );
! 1008: if( 1 ){
! 1009: struct ExprList_item *pItem = &pList->a[pList->nExpr++];
! 1010: memset(pItem, 0, sizeof(*pItem));
! 1011: pItem->pExpr = pExpr;
! 1012: }
! 1013: return pList;
! 1014:
! 1015: no_mem:
! 1016: /* Avoid leaking memory if malloc has failed. */
! 1017: sqlite3ExprDelete(db, pExpr);
! 1018: sqlite3ExprListDelete(db, pList);
! 1019: return 0;
! 1020: }
! 1021:
! 1022: /*
! 1023: ** Set the ExprList.a[].zName element of the most recently added item
! 1024: ** on the expression list.
! 1025: **
! 1026: ** pList might be NULL following an OOM error. But pName should never be
! 1027: ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
! 1028: ** is set.
! 1029: */
! 1030: void sqlite3ExprListSetName(
! 1031: Parse *pParse, /* Parsing context */
! 1032: ExprList *pList, /* List to which to add the span. */
! 1033: Token *pName, /* Name to be added */
! 1034: int dequote /* True to cause the name to be dequoted */
! 1035: ){
! 1036: assert( pList!=0 || pParse->db->mallocFailed!=0 );
! 1037: if( pList ){
! 1038: struct ExprList_item *pItem;
! 1039: assert( pList->nExpr>0 );
! 1040: pItem = &pList->a[pList->nExpr-1];
! 1041: assert( pItem->zName==0 );
! 1042: pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
! 1043: if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
! 1044: }
! 1045: }
! 1046:
! 1047: /*
! 1048: ** Set the ExprList.a[].zSpan element of the most recently added item
! 1049: ** on the expression list.
! 1050: **
! 1051: ** pList might be NULL following an OOM error. But pSpan should never be
! 1052: ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
! 1053: ** is set.
! 1054: */
! 1055: void sqlite3ExprListSetSpan(
! 1056: Parse *pParse, /* Parsing context */
! 1057: ExprList *pList, /* List to which to add the span. */
! 1058: ExprSpan *pSpan /* The span to be added */
! 1059: ){
! 1060: sqlite3 *db = pParse->db;
! 1061: assert( pList!=0 || db->mallocFailed!=0 );
! 1062: if( pList ){
! 1063: struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
! 1064: assert( pList->nExpr>0 );
! 1065: assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
! 1066: sqlite3DbFree(db, pItem->zSpan);
! 1067: pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
! 1068: (int)(pSpan->zEnd - pSpan->zStart));
! 1069: }
! 1070: }
! 1071:
! 1072: /*
! 1073: ** If the expression list pEList contains more than iLimit elements,
! 1074: ** leave an error message in pParse.
! 1075: */
! 1076: void sqlite3ExprListCheckLength(
! 1077: Parse *pParse,
! 1078: ExprList *pEList,
! 1079: const char *zObject
! 1080: ){
! 1081: int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
! 1082: testcase( pEList && pEList->nExpr==mx );
! 1083: testcase( pEList && pEList->nExpr==mx+1 );
! 1084: if( pEList && pEList->nExpr>mx ){
! 1085: sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
! 1086: }
! 1087: }
! 1088:
! 1089: /*
! 1090: ** Delete an entire expression list.
! 1091: */
! 1092: void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
! 1093: int i;
! 1094: struct ExprList_item *pItem;
! 1095: if( pList==0 ) return;
! 1096: assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
! 1097: assert( pList->nExpr<=pList->nAlloc );
! 1098: for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
! 1099: sqlite3ExprDelete(db, pItem->pExpr);
! 1100: sqlite3DbFree(db, pItem->zName);
! 1101: sqlite3DbFree(db, pItem->zSpan);
! 1102: }
! 1103: sqlite3DbFree(db, pList->a);
! 1104: sqlite3DbFree(db, pList);
! 1105: }
! 1106:
! 1107: /*
! 1108: ** These routines are Walker callbacks. Walker.u.pi is a pointer
! 1109: ** to an integer. These routines are checking an expression to see
! 1110: ** if it is a constant. Set *Walker.u.pi to 0 if the expression is
! 1111: ** not constant.
! 1112: **
! 1113: ** These callback routines are used to implement the following:
! 1114: **
! 1115: ** sqlite3ExprIsConstant()
! 1116: ** sqlite3ExprIsConstantNotJoin()
! 1117: ** sqlite3ExprIsConstantOrFunction()
! 1118: **
! 1119: */
! 1120: static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
! 1121:
! 1122: /* If pWalker->u.i is 3 then any term of the expression that comes from
! 1123: ** the ON or USING clauses of a join disqualifies the expression
! 1124: ** from being considered constant. */
! 1125: if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
! 1126: pWalker->u.i = 0;
! 1127: return WRC_Abort;
! 1128: }
! 1129:
! 1130: switch( pExpr->op ){
! 1131: /* Consider functions to be constant if all their arguments are constant
! 1132: ** and pWalker->u.i==2 */
! 1133: case TK_FUNCTION:
! 1134: if( pWalker->u.i==2 ) return 0;
! 1135: /* Fall through */
! 1136: case TK_ID:
! 1137: case TK_COLUMN:
! 1138: case TK_AGG_FUNCTION:
! 1139: case TK_AGG_COLUMN:
! 1140: testcase( pExpr->op==TK_ID );
! 1141: testcase( pExpr->op==TK_COLUMN );
! 1142: testcase( pExpr->op==TK_AGG_FUNCTION );
! 1143: testcase( pExpr->op==TK_AGG_COLUMN );
! 1144: pWalker->u.i = 0;
! 1145: return WRC_Abort;
! 1146: default:
! 1147: testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
! 1148: testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
! 1149: return WRC_Continue;
! 1150: }
! 1151: }
! 1152: static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
! 1153: UNUSED_PARAMETER(NotUsed);
! 1154: pWalker->u.i = 0;
! 1155: return WRC_Abort;
! 1156: }
! 1157: static int exprIsConst(Expr *p, int initFlag){
! 1158: Walker w;
! 1159: w.u.i = initFlag;
! 1160: w.xExprCallback = exprNodeIsConstant;
! 1161: w.xSelectCallback = selectNodeIsConstant;
! 1162: sqlite3WalkExpr(&w, p);
! 1163: return w.u.i;
! 1164: }
! 1165:
! 1166: /*
! 1167: ** Walk an expression tree. Return 1 if the expression is constant
! 1168: ** and 0 if it involves variables or function calls.
! 1169: **
! 1170: ** For the purposes of this function, a double-quoted string (ex: "abc")
! 1171: ** is considered a variable but a single-quoted string (ex: 'abc') is
! 1172: ** a constant.
! 1173: */
! 1174: int sqlite3ExprIsConstant(Expr *p){
! 1175: return exprIsConst(p, 1);
! 1176: }
! 1177:
! 1178: /*
! 1179: ** Walk an expression tree. Return 1 if the expression is constant
! 1180: ** that does no originate from the ON or USING clauses of a join.
! 1181: ** Return 0 if it involves variables or function calls or terms from
! 1182: ** an ON or USING clause.
! 1183: */
! 1184: int sqlite3ExprIsConstantNotJoin(Expr *p){
! 1185: return exprIsConst(p, 3);
! 1186: }
! 1187:
! 1188: /*
! 1189: ** Walk an expression tree. Return 1 if the expression is constant
! 1190: ** or a function call with constant arguments. Return and 0 if there
! 1191: ** are any variables.
! 1192: **
! 1193: ** For the purposes of this function, a double-quoted string (ex: "abc")
! 1194: ** is considered a variable but a single-quoted string (ex: 'abc') is
! 1195: ** a constant.
! 1196: */
! 1197: int sqlite3ExprIsConstantOrFunction(Expr *p){
! 1198: return exprIsConst(p, 2);
! 1199: }
! 1200:
! 1201: /*
! 1202: ** If the expression p codes a constant integer that is small enough
! 1203: ** to fit in a 32-bit integer, return 1 and put the value of the integer
! 1204: ** in *pValue. If the expression is not an integer or if it is too big
! 1205: ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
! 1206: */
! 1207: int sqlite3ExprIsInteger(Expr *p, int *pValue){
! 1208: int rc = 0;
! 1209:
! 1210: /* If an expression is an integer literal that fits in a signed 32-bit
! 1211: ** integer, then the EP_IntValue flag will have already been set */
! 1212: assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
! 1213: || sqlite3GetInt32(p->u.zToken, &rc)==0 );
! 1214:
! 1215: if( p->flags & EP_IntValue ){
! 1216: *pValue = p->u.iValue;
! 1217: return 1;
! 1218: }
! 1219: switch( p->op ){
! 1220: case TK_UPLUS: {
! 1221: rc = sqlite3ExprIsInteger(p->pLeft, pValue);
! 1222: break;
! 1223: }
! 1224: case TK_UMINUS: {
! 1225: int v;
! 1226: if( sqlite3ExprIsInteger(p->pLeft, &v) ){
! 1227: *pValue = -v;
! 1228: rc = 1;
! 1229: }
! 1230: break;
! 1231: }
! 1232: default: break;
! 1233: }
! 1234: return rc;
! 1235: }
! 1236:
! 1237: /*
! 1238: ** Return FALSE if there is no chance that the expression can be NULL.
! 1239: **
! 1240: ** If the expression might be NULL or if the expression is too complex
! 1241: ** to tell return TRUE.
! 1242: **
! 1243: ** This routine is used as an optimization, to skip OP_IsNull opcodes
! 1244: ** when we know that a value cannot be NULL. Hence, a false positive
! 1245: ** (returning TRUE when in fact the expression can never be NULL) might
! 1246: ** be a small performance hit but is otherwise harmless. On the other
! 1247: ** hand, a false negative (returning FALSE when the result could be NULL)
! 1248: ** will likely result in an incorrect answer. So when in doubt, return
! 1249: ** TRUE.
! 1250: */
! 1251: int sqlite3ExprCanBeNull(const Expr *p){
! 1252: u8 op;
! 1253: while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
! 1254: op = p->op;
! 1255: if( op==TK_REGISTER ) op = p->op2;
! 1256: switch( op ){
! 1257: case TK_INTEGER:
! 1258: case TK_STRING:
! 1259: case TK_FLOAT:
! 1260: case TK_BLOB:
! 1261: return 0;
! 1262: default:
! 1263: return 1;
! 1264: }
! 1265: }
! 1266:
! 1267: /*
! 1268: ** Generate an OP_IsNull instruction that tests register iReg and jumps
! 1269: ** to location iDest if the value in iReg is NULL. The value in iReg
! 1270: ** was computed by pExpr. If we can look at pExpr at compile-time and
! 1271: ** determine that it can never generate a NULL, then the OP_IsNull operation
! 1272: ** can be omitted.
! 1273: */
! 1274: void sqlite3ExprCodeIsNullJump(
! 1275: Vdbe *v, /* The VDBE under construction */
! 1276: const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
! 1277: int iReg, /* Test the value in this register for NULL */
! 1278: int iDest /* Jump here if the value is null */
! 1279: ){
! 1280: if( sqlite3ExprCanBeNull(pExpr) ){
! 1281: sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
! 1282: }
! 1283: }
! 1284:
! 1285: /*
! 1286: ** Return TRUE if the given expression is a constant which would be
! 1287: ** unchanged by OP_Affinity with the affinity given in the second
! 1288: ** argument.
! 1289: **
! 1290: ** This routine is used to determine if the OP_Affinity operation
! 1291: ** can be omitted. When in doubt return FALSE. A false negative
! 1292: ** is harmless. A false positive, however, can result in the wrong
! 1293: ** answer.
! 1294: */
! 1295: int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
! 1296: u8 op;
! 1297: if( aff==SQLITE_AFF_NONE ) return 1;
! 1298: while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
! 1299: op = p->op;
! 1300: if( op==TK_REGISTER ) op = p->op2;
! 1301: switch( op ){
! 1302: case TK_INTEGER: {
! 1303: return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
! 1304: }
! 1305: case TK_FLOAT: {
! 1306: return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
! 1307: }
! 1308: case TK_STRING: {
! 1309: return aff==SQLITE_AFF_TEXT;
! 1310: }
! 1311: case TK_BLOB: {
! 1312: return 1;
! 1313: }
! 1314: case TK_COLUMN: {
! 1315: assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
! 1316: return p->iColumn<0
! 1317: && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
! 1318: }
! 1319: default: {
! 1320: return 0;
! 1321: }
! 1322: }
! 1323: }
! 1324:
! 1325: /*
! 1326: ** Return TRUE if the given string is a row-id column name.
! 1327: */
! 1328: int sqlite3IsRowid(const char *z){
! 1329: if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
! 1330: if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
! 1331: if( sqlite3StrICmp(z, "OID")==0 ) return 1;
! 1332: return 0;
! 1333: }
! 1334:
! 1335: /*
! 1336: ** Return true if we are able to the IN operator optimization on a
! 1337: ** query of the form
! 1338: **
! 1339: ** x IN (SELECT ...)
! 1340: **
! 1341: ** Where the SELECT... clause is as specified by the parameter to this
! 1342: ** routine.
! 1343: **
! 1344: ** The Select object passed in has already been preprocessed and no
! 1345: ** errors have been found.
! 1346: */
! 1347: #ifndef SQLITE_OMIT_SUBQUERY
! 1348: static int isCandidateForInOpt(Select *p){
! 1349: SrcList *pSrc;
! 1350: ExprList *pEList;
! 1351: Table *pTab;
! 1352: if( p==0 ) return 0; /* right-hand side of IN is SELECT */
! 1353: if( p->pPrior ) return 0; /* Not a compound SELECT */
! 1354: if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
! 1355: testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
! 1356: testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
! 1357: return 0; /* No DISTINCT keyword and no aggregate functions */
! 1358: }
! 1359: assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
! 1360: if( p->pLimit ) return 0; /* Has no LIMIT clause */
! 1361: assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
! 1362: if( p->pWhere ) return 0; /* Has no WHERE clause */
! 1363: pSrc = p->pSrc;
! 1364: assert( pSrc!=0 );
! 1365: if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
! 1366: if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
! 1367: pTab = pSrc->a[0].pTab;
! 1368: if( NEVER(pTab==0) ) return 0;
! 1369: assert( pTab->pSelect==0 ); /* FROM clause is not a view */
! 1370: if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
! 1371: pEList = p->pEList;
! 1372: if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
! 1373: if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
! 1374: return 1;
! 1375: }
! 1376: #endif /* SQLITE_OMIT_SUBQUERY */
! 1377:
! 1378: /*
! 1379: ** Code an OP_Once instruction and allocate space for its flag. Return the
! 1380: ** address of the new instruction.
! 1381: */
! 1382: int sqlite3CodeOnce(Parse *pParse){
! 1383: Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
! 1384: return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++);
! 1385: }
! 1386:
! 1387: /*
! 1388: ** This function is used by the implementation of the IN (...) operator.
! 1389: ** It's job is to find or create a b-tree structure that may be used
! 1390: ** either to test for membership of the (...) set or to iterate through
! 1391: ** its members, skipping duplicates.
! 1392: **
! 1393: ** The index of the cursor opened on the b-tree (database table, database index
! 1394: ** or ephermal table) is stored in pX->iTable before this function returns.
! 1395: ** The returned value of this function indicates the b-tree type, as follows:
! 1396: **
! 1397: ** IN_INDEX_ROWID - The cursor was opened on a database table.
! 1398: ** IN_INDEX_INDEX - The cursor was opened on a database index.
! 1399: ** IN_INDEX_EPH - The cursor was opened on a specially created and
! 1400: ** populated epheremal table.
! 1401: **
! 1402: ** An existing b-tree may only be used if the SELECT is of the simple
! 1403: ** form:
! 1404: **
! 1405: ** SELECT <column> FROM <table>
! 1406: **
! 1407: ** If the prNotFound parameter is 0, then the b-tree will be used to iterate
! 1408: ** through the set members, skipping any duplicates. In this case an
! 1409: ** epheremal table must be used unless the selected <column> is guaranteed
! 1410: ** to be unique - either because it is an INTEGER PRIMARY KEY or it
! 1411: ** has a UNIQUE constraint or UNIQUE index.
! 1412: **
! 1413: ** If the prNotFound parameter is not 0, then the b-tree will be used
! 1414: ** for fast set membership tests. In this case an epheremal table must
! 1415: ** be used unless <column> is an INTEGER PRIMARY KEY or an index can
! 1416: ** be found with <column> as its left-most column.
! 1417: **
! 1418: ** When the b-tree is being used for membership tests, the calling function
! 1419: ** needs to know whether or not the structure contains an SQL NULL
! 1420: ** value in order to correctly evaluate expressions like "X IN (Y, Z)".
! 1421: ** If there is any chance that the (...) might contain a NULL value at
! 1422: ** runtime, then a register is allocated and the register number written
! 1423: ** to *prNotFound. If there is no chance that the (...) contains a
! 1424: ** NULL value, then *prNotFound is left unchanged.
! 1425: **
! 1426: ** If a register is allocated and its location stored in *prNotFound, then
! 1427: ** its initial value is NULL. If the (...) does not remain constant
! 1428: ** for the duration of the query (i.e. the SELECT within the (...)
! 1429: ** is a correlated subquery) then the value of the allocated register is
! 1430: ** reset to NULL each time the subquery is rerun. This allows the
! 1431: ** caller to use vdbe code equivalent to the following:
! 1432: **
! 1433: ** if( register==NULL ){
! 1434: ** has_null = <test if data structure contains null>
! 1435: ** register = 1
! 1436: ** }
! 1437: **
! 1438: ** in order to avoid running the <test if data structure contains null>
! 1439: ** test more often than is necessary.
! 1440: */
! 1441: #ifndef SQLITE_OMIT_SUBQUERY
! 1442: int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
! 1443: Select *p; /* SELECT to the right of IN operator */
! 1444: int eType = 0; /* Type of RHS table. IN_INDEX_* */
! 1445: int iTab = pParse->nTab++; /* Cursor of the RHS table */
! 1446: int mustBeUnique = (prNotFound==0); /* True if RHS must be unique */
! 1447: Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
! 1448:
! 1449: assert( pX->op==TK_IN );
! 1450:
! 1451: /* Check to see if an existing table or index can be used to
! 1452: ** satisfy the query. This is preferable to generating a new
! 1453: ** ephemeral table.
! 1454: */
! 1455: p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
! 1456: if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
! 1457: sqlite3 *db = pParse->db; /* Database connection */
! 1458: Table *pTab; /* Table <table>. */
! 1459: Expr *pExpr; /* Expression <column> */
! 1460: int iCol; /* Index of column <column> */
! 1461: int iDb; /* Database idx for pTab */
! 1462:
! 1463: assert( p ); /* Because of isCandidateForInOpt(p) */
! 1464: assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
! 1465: assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
! 1466: assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
! 1467: pTab = p->pSrc->a[0].pTab;
! 1468: pExpr = p->pEList->a[0].pExpr;
! 1469: iCol = pExpr->iColumn;
! 1470:
! 1471: /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
! 1472: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
! 1473: sqlite3CodeVerifySchema(pParse, iDb);
! 1474: sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
! 1475:
! 1476: /* This function is only called from two places. In both cases the vdbe
! 1477: ** has already been allocated. So assume sqlite3GetVdbe() is always
! 1478: ** successful here.
! 1479: */
! 1480: assert(v);
! 1481: if( iCol<0 ){
! 1482: int iAddr;
! 1483:
! 1484: iAddr = sqlite3CodeOnce(pParse);
! 1485:
! 1486: sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
! 1487: eType = IN_INDEX_ROWID;
! 1488:
! 1489: sqlite3VdbeJumpHere(v, iAddr);
! 1490: }else{
! 1491: Index *pIdx; /* Iterator variable */
! 1492:
! 1493: /* The collation sequence used by the comparison. If an index is to
! 1494: ** be used in place of a temp-table, it must be ordered according
! 1495: ** to this collation sequence. */
! 1496: CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
! 1497:
! 1498: /* Check that the affinity that will be used to perform the
! 1499: ** comparison is the same as the affinity of the column. If
! 1500: ** it is not, it is not possible to use any index.
! 1501: */
! 1502: char aff = comparisonAffinity(pX);
! 1503: int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
! 1504:
! 1505: for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
! 1506: if( (pIdx->aiColumn[0]==iCol)
! 1507: && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
! 1508: && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
! 1509: ){
! 1510: int iAddr;
! 1511: char *pKey;
! 1512:
! 1513: pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
! 1514: iAddr = sqlite3CodeOnce(pParse);
! 1515:
! 1516: sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
! 1517: pKey,P4_KEYINFO_HANDOFF);
! 1518: VdbeComment((v, "%s", pIdx->zName));
! 1519: eType = IN_INDEX_INDEX;
! 1520:
! 1521: sqlite3VdbeJumpHere(v, iAddr);
! 1522: if( prNotFound && !pTab->aCol[iCol].notNull ){
! 1523: *prNotFound = ++pParse->nMem;
! 1524: sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
! 1525: }
! 1526: }
! 1527: }
! 1528: }
! 1529: }
! 1530:
! 1531: if( eType==0 ){
! 1532: /* Could not found an existing table or index to use as the RHS b-tree.
! 1533: ** We will have to generate an ephemeral table to do the job.
! 1534: */
! 1535: double savedNQueryLoop = pParse->nQueryLoop;
! 1536: int rMayHaveNull = 0;
! 1537: eType = IN_INDEX_EPH;
! 1538: if( prNotFound ){
! 1539: *prNotFound = rMayHaveNull = ++pParse->nMem;
! 1540: sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
! 1541: }else{
! 1542: testcase( pParse->nQueryLoop>(double)1 );
! 1543: pParse->nQueryLoop = (double)1;
! 1544: if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
! 1545: eType = IN_INDEX_ROWID;
! 1546: }
! 1547: }
! 1548: sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
! 1549: pParse->nQueryLoop = savedNQueryLoop;
! 1550: }else{
! 1551: pX->iTable = iTab;
! 1552: }
! 1553: return eType;
! 1554: }
! 1555: #endif
! 1556:
! 1557: /*
! 1558: ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
! 1559: ** or IN operators. Examples:
! 1560: **
! 1561: ** (SELECT a FROM b) -- subquery
! 1562: ** EXISTS (SELECT a FROM b) -- EXISTS subquery
! 1563: ** x IN (4,5,11) -- IN operator with list on right-hand side
! 1564: ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
! 1565: **
! 1566: ** The pExpr parameter describes the expression that contains the IN
! 1567: ** operator or subquery.
! 1568: **
! 1569: ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
! 1570: ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
! 1571: ** to some integer key column of a table B-Tree. In this case, use an
! 1572: ** intkey B-Tree to store the set of IN(...) values instead of the usual
! 1573: ** (slower) variable length keys B-Tree.
! 1574: **
! 1575: ** If rMayHaveNull is non-zero, that means that the operation is an IN
! 1576: ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
! 1577: ** Furthermore, the IN is in a WHERE clause and that we really want
! 1578: ** to iterate over the RHS of the IN operator in order to quickly locate
! 1579: ** all corresponding LHS elements. All this routine does is initialize
! 1580: ** the register given by rMayHaveNull to NULL. Calling routines will take
! 1581: ** care of changing this register value to non-NULL if the RHS is NULL-free.
! 1582: **
! 1583: ** If rMayHaveNull is zero, that means that the subquery is being used
! 1584: ** for membership testing only. There is no need to initialize any
! 1585: ** registers to indicate the presense or absence of NULLs on the RHS.
! 1586: **
! 1587: ** For a SELECT or EXISTS operator, return the register that holds the
! 1588: ** result. For IN operators or if an error occurs, the return value is 0.
! 1589: */
! 1590: #ifndef SQLITE_OMIT_SUBQUERY
! 1591: int sqlite3CodeSubselect(
! 1592: Parse *pParse, /* Parsing context */
! 1593: Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
! 1594: int rMayHaveNull, /* Register that records whether NULLs exist in RHS */
! 1595: int isRowid /* If true, LHS of IN operator is a rowid */
! 1596: ){
! 1597: int testAddr = -1; /* One-time test address */
! 1598: int rReg = 0; /* Register storing resulting */
! 1599: Vdbe *v = sqlite3GetVdbe(pParse);
! 1600: if( NEVER(v==0) ) return 0;
! 1601: sqlite3ExprCachePush(pParse);
! 1602:
! 1603: /* This code must be run in its entirety every time it is encountered
! 1604: ** if any of the following is true:
! 1605: **
! 1606: ** * The right-hand side is a correlated subquery
! 1607: ** * The right-hand side is an expression list containing variables
! 1608: ** * We are inside a trigger
! 1609: **
! 1610: ** If all of the above are false, then we can run this code just once
! 1611: ** save the results, and reuse the same result on subsequent invocations.
! 1612: */
! 1613: if( !ExprHasAnyProperty(pExpr, EP_VarSelect) ){
! 1614: testAddr = sqlite3CodeOnce(pParse);
! 1615: }
! 1616:
! 1617: #ifndef SQLITE_OMIT_EXPLAIN
! 1618: if( pParse->explain==2 ){
! 1619: char *zMsg = sqlite3MPrintf(
! 1620: pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
! 1621: pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
! 1622: );
! 1623: sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
! 1624: }
! 1625: #endif
! 1626:
! 1627: switch( pExpr->op ){
! 1628: case TK_IN: {
! 1629: char affinity; /* Affinity of the LHS of the IN */
! 1630: KeyInfo keyInfo; /* Keyinfo for the generated table */
! 1631: int addr; /* Address of OP_OpenEphemeral instruction */
! 1632: Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
! 1633:
! 1634: if( rMayHaveNull ){
! 1635: sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
! 1636: }
! 1637:
! 1638: affinity = sqlite3ExprAffinity(pLeft);
! 1639:
! 1640: /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
! 1641: ** expression it is handled the same way. An ephemeral table is
! 1642: ** filled with single-field index keys representing the results
! 1643: ** from the SELECT or the <exprlist>.
! 1644: **
! 1645: ** If the 'x' expression is a column value, or the SELECT...
! 1646: ** statement returns a column value, then the affinity of that
! 1647: ** column is used to build the index keys. If both 'x' and the
! 1648: ** SELECT... statement are columns, then numeric affinity is used
! 1649: ** if either column has NUMERIC or INTEGER affinity. If neither
! 1650: ** 'x' nor the SELECT... statement are columns, then numeric affinity
! 1651: ** is used.
! 1652: */
! 1653: pExpr->iTable = pParse->nTab++;
! 1654: addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
! 1655: if( rMayHaveNull==0 ) sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
! 1656: memset(&keyInfo, 0, sizeof(keyInfo));
! 1657: keyInfo.nField = 1;
! 1658:
! 1659: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
! 1660: /* Case 1: expr IN (SELECT ...)
! 1661: **
! 1662: ** Generate code to write the results of the select into the temporary
! 1663: ** table allocated and opened above.
! 1664: */
! 1665: SelectDest dest;
! 1666: ExprList *pEList;
! 1667:
! 1668: assert( !isRowid );
! 1669: sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
! 1670: dest.affinity = (u8)affinity;
! 1671: assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
! 1672: pExpr->x.pSelect->iLimit = 0;
! 1673: if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
! 1674: return 0;
! 1675: }
! 1676: pEList = pExpr->x.pSelect->pEList;
! 1677: if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
! 1678: keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
! 1679: pEList->a[0].pExpr);
! 1680: }
! 1681: }else if( ALWAYS(pExpr->x.pList!=0) ){
! 1682: /* Case 2: expr IN (exprlist)
! 1683: **
! 1684: ** For each expression, build an index key from the evaluation and
! 1685: ** store it in the temporary table. If <expr> is a column, then use
! 1686: ** that columns affinity when building index keys. If <expr> is not
! 1687: ** a column, use numeric affinity.
! 1688: */
! 1689: int i;
! 1690: ExprList *pList = pExpr->x.pList;
! 1691: struct ExprList_item *pItem;
! 1692: int r1, r2, r3;
! 1693:
! 1694: if( !affinity ){
! 1695: affinity = SQLITE_AFF_NONE;
! 1696: }
! 1697: keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
! 1698:
! 1699: /* Loop through each expression in <exprlist>. */
! 1700: r1 = sqlite3GetTempReg(pParse);
! 1701: r2 = sqlite3GetTempReg(pParse);
! 1702: sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
! 1703: for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
! 1704: Expr *pE2 = pItem->pExpr;
! 1705: int iValToIns;
! 1706:
! 1707: /* If the expression is not constant then we will need to
! 1708: ** disable the test that was generated above that makes sure
! 1709: ** this code only executes once. Because for a non-constant
! 1710: ** expression we need to rerun this code each time.
! 1711: */
! 1712: if( testAddr>=0 && !sqlite3ExprIsConstant(pE2) ){
! 1713: sqlite3VdbeChangeToNoop(v, testAddr);
! 1714: testAddr = -1;
! 1715: }
! 1716:
! 1717: /* Evaluate the expression and insert it into the temp table */
! 1718: if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
! 1719: sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
! 1720: }else{
! 1721: r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
! 1722: if( isRowid ){
! 1723: sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
! 1724: sqlite3VdbeCurrentAddr(v)+2);
! 1725: sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
! 1726: }else{
! 1727: sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
! 1728: sqlite3ExprCacheAffinityChange(pParse, r3, 1);
! 1729: sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
! 1730: }
! 1731: }
! 1732: }
! 1733: sqlite3ReleaseTempReg(pParse, r1);
! 1734: sqlite3ReleaseTempReg(pParse, r2);
! 1735: }
! 1736: if( !isRowid ){
! 1737: sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
! 1738: }
! 1739: break;
! 1740: }
! 1741:
! 1742: case TK_EXISTS:
! 1743: case TK_SELECT:
! 1744: default: {
! 1745: /* If this has to be a scalar SELECT. Generate code to put the
! 1746: ** value of this select in a memory cell and record the number
! 1747: ** of the memory cell in iColumn. If this is an EXISTS, write
! 1748: ** an integer 0 (not exists) or 1 (exists) into a memory cell
! 1749: ** and record that memory cell in iColumn.
! 1750: */
! 1751: Select *pSel; /* SELECT statement to encode */
! 1752: SelectDest dest; /* How to deal with SELECt result */
! 1753:
! 1754: testcase( pExpr->op==TK_EXISTS );
! 1755: testcase( pExpr->op==TK_SELECT );
! 1756: assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
! 1757:
! 1758: assert( ExprHasProperty(pExpr, EP_xIsSelect) );
! 1759: pSel = pExpr->x.pSelect;
! 1760: sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
! 1761: if( pExpr->op==TK_SELECT ){
! 1762: dest.eDest = SRT_Mem;
! 1763: sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
! 1764: VdbeComment((v, "Init subquery result"));
! 1765: }else{
! 1766: dest.eDest = SRT_Exists;
! 1767: sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
! 1768: VdbeComment((v, "Init EXISTS result"));
! 1769: }
! 1770: sqlite3ExprDelete(pParse->db, pSel->pLimit);
! 1771: pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
! 1772: &sqlite3IntTokens[1]);
! 1773: pSel->iLimit = 0;
! 1774: if( sqlite3Select(pParse, pSel, &dest) ){
! 1775: return 0;
! 1776: }
! 1777: rReg = dest.iParm;
! 1778: ExprSetIrreducible(pExpr);
! 1779: break;
! 1780: }
! 1781: }
! 1782:
! 1783: if( testAddr>=0 ){
! 1784: sqlite3VdbeJumpHere(v, testAddr);
! 1785: }
! 1786: sqlite3ExprCachePop(pParse, 1);
! 1787:
! 1788: return rReg;
! 1789: }
! 1790: #endif /* SQLITE_OMIT_SUBQUERY */
! 1791:
! 1792: #ifndef SQLITE_OMIT_SUBQUERY
! 1793: /*
! 1794: ** Generate code for an IN expression.
! 1795: **
! 1796: ** x IN (SELECT ...)
! 1797: ** x IN (value, value, ...)
! 1798: **
! 1799: ** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS)
! 1800: ** is an array of zero or more values. The expression is true if the LHS is
! 1801: ** contained within the RHS. The value of the expression is unknown (NULL)
! 1802: ** if the LHS is NULL or if the LHS is not contained within the RHS and the
! 1803: ** RHS contains one or more NULL values.
! 1804: **
! 1805: ** This routine generates code will jump to destIfFalse if the LHS is not
! 1806: ** contained within the RHS. If due to NULLs we cannot determine if the LHS
! 1807: ** is contained in the RHS then jump to destIfNull. If the LHS is contained
! 1808: ** within the RHS then fall through.
! 1809: */
! 1810: static void sqlite3ExprCodeIN(
! 1811: Parse *pParse, /* Parsing and code generating context */
! 1812: Expr *pExpr, /* The IN expression */
! 1813: int destIfFalse, /* Jump here if LHS is not contained in the RHS */
! 1814: int destIfNull /* Jump here if the results are unknown due to NULLs */
! 1815: ){
! 1816: int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */
! 1817: char affinity; /* Comparison affinity to use */
! 1818: int eType; /* Type of the RHS */
! 1819: int r1; /* Temporary use register */
! 1820: Vdbe *v; /* Statement under construction */
! 1821:
! 1822: /* Compute the RHS. After this step, the table with cursor
! 1823: ** pExpr->iTable will contains the values that make up the RHS.
! 1824: */
! 1825: v = pParse->pVdbe;
! 1826: assert( v!=0 ); /* OOM detected prior to this routine */
! 1827: VdbeNoopComment((v, "begin IN expr"));
! 1828: eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
! 1829:
! 1830: /* Figure out the affinity to use to create a key from the results
! 1831: ** of the expression. affinityStr stores a static string suitable for
! 1832: ** P4 of OP_MakeRecord.
! 1833: */
! 1834: affinity = comparisonAffinity(pExpr);
! 1835:
! 1836: /* Code the LHS, the <expr> from "<expr> IN (...)".
! 1837: */
! 1838: sqlite3ExprCachePush(pParse);
! 1839: r1 = sqlite3GetTempReg(pParse);
! 1840: sqlite3ExprCode(pParse, pExpr->pLeft, r1);
! 1841:
! 1842: /* If the LHS is NULL, then the result is either false or NULL depending
! 1843: ** on whether the RHS is empty or not, respectively.
! 1844: */
! 1845: if( destIfNull==destIfFalse ){
! 1846: /* Shortcut for the common case where the false and NULL outcomes are
! 1847: ** the same. */
! 1848: sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
! 1849: }else{
! 1850: int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
! 1851: sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
! 1852: sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
! 1853: sqlite3VdbeJumpHere(v, addr1);
! 1854: }
! 1855:
! 1856: if( eType==IN_INDEX_ROWID ){
! 1857: /* In this case, the RHS is the ROWID of table b-tree
! 1858: */
! 1859: sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
! 1860: sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
! 1861: }else{
! 1862: /* In this case, the RHS is an index b-tree.
! 1863: */
! 1864: sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
! 1865:
! 1866: /* If the set membership test fails, then the result of the
! 1867: ** "x IN (...)" expression must be either 0 or NULL. If the set
! 1868: ** contains no NULL values, then the result is 0. If the set
! 1869: ** contains one or more NULL values, then the result of the
! 1870: ** expression is also NULL.
! 1871: */
! 1872: if( rRhsHasNull==0 || destIfFalse==destIfNull ){
! 1873: /* This branch runs if it is known at compile time that the RHS
! 1874: ** cannot contain NULL values. This happens as the result
! 1875: ** of a "NOT NULL" constraint in the database schema.
! 1876: **
! 1877: ** Also run this branch if NULL is equivalent to FALSE
! 1878: ** for this particular IN operator.
! 1879: */
! 1880: sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
! 1881:
! 1882: }else{
! 1883: /* In this branch, the RHS of the IN might contain a NULL and
! 1884: ** the presence of a NULL on the RHS makes a difference in the
! 1885: ** outcome.
! 1886: */
! 1887: int j1, j2, j3;
! 1888:
! 1889: /* First check to see if the LHS is contained in the RHS. If so,
! 1890: ** then the presence of NULLs in the RHS does not matter, so jump
! 1891: ** over all of the code that follows.
! 1892: */
! 1893: j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
! 1894:
! 1895: /* Here we begin generating code that runs if the LHS is not
! 1896: ** contained within the RHS. Generate additional code that
! 1897: ** tests the RHS for NULLs. If the RHS contains a NULL then
! 1898: ** jump to destIfNull. If there are no NULLs in the RHS then
! 1899: ** jump to destIfFalse.
! 1900: */
! 1901: j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
! 1902: j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
! 1903: sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
! 1904: sqlite3VdbeJumpHere(v, j3);
! 1905: sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
! 1906: sqlite3VdbeJumpHere(v, j2);
! 1907:
! 1908: /* Jump to the appropriate target depending on whether or not
! 1909: ** the RHS contains a NULL
! 1910: */
! 1911: sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
! 1912: sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
! 1913:
! 1914: /* The OP_Found at the top of this branch jumps here when true,
! 1915: ** causing the overall IN expression evaluation to fall through.
! 1916: */
! 1917: sqlite3VdbeJumpHere(v, j1);
! 1918: }
! 1919: }
! 1920: sqlite3ReleaseTempReg(pParse, r1);
! 1921: sqlite3ExprCachePop(pParse, 1);
! 1922: VdbeComment((v, "end IN expr"));
! 1923: }
! 1924: #endif /* SQLITE_OMIT_SUBQUERY */
! 1925:
! 1926: /*
! 1927: ** Duplicate an 8-byte value
! 1928: */
! 1929: static char *dup8bytes(Vdbe *v, const char *in){
! 1930: char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
! 1931: if( out ){
! 1932: memcpy(out, in, 8);
! 1933: }
! 1934: return out;
! 1935: }
! 1936:
! 1937: #ifndef SQLITE_OMIT_FLOATING_POINT
! 1938: /*
! 1939: ** Generate an instruction that will put the floating point
! 1940: ** value described by z[0..n-1] into register iMem.
! 1941: **
! 1942: ** The z[] string will probably not be zero-terminated. But the
! 1943: ** z[n] character is guaranteed to be something that does not look
! 1944: ** like the continuation of the number.
! 1945: */
! 1946: static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
! 1947: if( ALWAYS(z!=0) ){
! 1948: double value;
! 1949: char *zV;
! 1950: sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
! 1951: assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
! 1952: if( negateFlag ) value = -value;
! 1953: zV = dup8bytes(v, (char*)&value);
! 1954: sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
! 1955: }
! 1956: }
! 1957: #endif
! 1958:
! 1959:
! 1960: /*
! 1961: ** Generate an instruction that will put the integer describe by
! 1962: ** text z[0..n-1] into register iMem.
! 1963: **
! 1964: ** Expr.u.zToken is always UTF8 and zero-terminated.
! 1965: */
! 1966: static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
! 1967: Vdbe *v = pParse->pVdbe;
! 1968: if( pExpr->flags & EP_IntValue ){
! 1969: int i = pExpr->u.iValue;
! 1970: assert( i>=0 );
! 1971: if( negFlag ) i = -i;
! 1972: sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
! 1973: }else{
! 1974: int c;
! 1975: i64 value;
! 1976: const char *z = pExpr->u.zToken;
! 1977: assert( z!=0 );
! 1978: c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
! 1979: if( c==0 || (c==2 && negFlag) ){
! 1980: char *zV;
! 1981: if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
! 1982: zV = dup8bytes(v, (char*)&value);
! 1983: sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
! 1984: }else{
! 1985: #ifdef SQLITE_OMIT_FLOATING_POINT
! 1986: sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
! 1987: #else
! 1988: codeReal(v, z, negFlag, iMem);
! 1989: #endif
! 1990: }
! 1991: }
! 1992: }
! 1993:
! 1994: /*
! 1995: ** Clear a cache entry.
! 1996: */
! 1997: static void cacheEntryClear(Parse *pParse, struct yColCache *p){
! 1998: if( p->tempReg ){
! 1999: if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
! 2000: pParse->aTempReg[pParse->nTempReg++] = p->iReg;
! 2001: }
! 2002: p->tempReg = 0;
! 2003: }
! 2004: }
! 2005:
! 2006:
! 2007: /*
! 2008: ** Record in the column cache that a particular column from a
! 2009: ** particular table is stored in a particular register.
! 2010: */
! 2011: void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
! 2012: int i;
! 2013: int minLru;
! 2014: int idxLru;
! 2015: struct yColCache *p;
! 2016:
! 2017: assert( iReg>0 ); /* Register numbers are always positive */
! 2018: assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
! 2019:
! 2020: /* The SQLITE_ColumnCache flag disables the column cache. This is used
! 2021: ** for testing only - to verify that SQLite always gets the same answer
! 2022: ** with and without the column cache.
! 2023: */
! 2024: if( pParse->db->flags & SQLITE_ColumnCache ) return;
! 2025:
! 2026: /* First replace any existing entry.
! 2027: **
! 2028: ** Actually, the way the column cache is currently used, we are guaranteed
! 2029: ** that the object will never already be in cache. Verify this guarantee.
! 2030: */
! 2031: #ifndef NDEBUG
! 2032: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2033: #if 0 /* This code wold remove the entry from the cache if it existed */
! 2034: if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
! 2035: cacheEntryClear(pParse, p);
! 2036: p->iLevel = pParse->iCacheLevel;
! 2037: p->iReg = iReg;
! 2038: p->lru = pParse->iCacheCnt++;
! 2039: return;
! 2040: }
! 2041: #endif
! 2042: assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
! 2043: }
! 2044: #endif
! 2045:
! 2046: /* Find an empty slot and replace it */
! 2047: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2048: if( p->iReg==0 ){
! 2049: p->iLevel = pParse->iCacheLevel;
! 2050: p->iTable = iTab;
! 2051: p->iColumn = iCol;
! 2052: p->iReg = iReg;
! 2053: p->tempReg = 0;
! 2054: p->lru = pParse->iCacheCnt++;
! 2055: return;
! 2056: }
! 2057: }
! 2058:
! 2059: /* Replace the last recently used */
! 2060: minLru = 0x7fffffff;
! 2061: idxLru = -1;
! 2062: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2063: if( p->lru<minLru ){
! 2064: idxLru = i;
! 2065: minLru = p->lru;
! 2066: }
! 2067: }
! 2068: if( ALWAYS(idxLru>=0) ){
! 2069: p = &pParse->aColCache[idxLru];
! 2070: p->iLevel = pParse->iCacheLevel;
! 2071: p->iTable = iTab;
! 2072: p->iColumn = iCol;
! 2073: p->iReg = iReg;
! 2074: p->tempReg = 0;
! 2075: p->lru = pParse->iCacheCnt++;
! 2076: return;
! 2077: }
! 2078: }
! 2079:
! 2080: /*
! 2081: ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
! 2082: ** Purge the range of registers from the column cache.
! 2083: */
! 2084: void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
! 2085: int i;
! 2086: int iLast = iReg + nReg - 1;
! 2087: struct yColCache *p;
! 2088: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2089: int r = p->iReg;
! 2090: if( r>=iReg && r<=iLast ){
! 2091: cacheEntryClear(pParse, p);
! 2092: p->iReg = 0;
! 2093: }
! 2094: }
! 2095: }
! 2096:
! 2097: /*
! 2098: ** Remember the current column cache context. Any new entries added
! 2099: ** added to the column cache after this call are removed when the
! 2100: ** corresponding pop occurs.
! 2101: */
! 2102: void sqlite3ExprCachePush(Parse *pParse){
! 2103: pParse->iCacheLevel++;
! 2104: }
! 2105:
! 2106: /*
! 2107: ** Remove from the column cache any entries that were added since the
! 2108: ** the previous N Push operations. In other words, restore the cache
! 2109: ** to the state it was in N Pushes ago.
! 2110: */
! 2111: void sqlite3ExprCachePop(Parse *pParse, int N){
! 2112: int i;
! 2113: struct yColCache *p;
! 2114: assert( N>0 );
! 2115: assert( pParse->iCacheLevel>=N );
! 2116: pParse->iCacheLevel -= N;
! 2117: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2118: if( p->iReg && p->iLevel>pParse->iCacheLevel ){
! 2119: cacheEntryClear(pParse, p);
! 2120: p->iReg = 0;
! 2121: }
! 2122: }
! 2123: }
! 2124:
! 2125: /*
! 2126: ** When a cached column is reused, make sure that its register is
! 2127: ** no longer available as a temp register. ticket #3879: that same
! 2128: ** register might be in the cache in multiple places, so be sure to
! 2129: ** get them all.
! 2130: */
! 2131: static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
! 2132: int i;
! 2133: struct yColCache *p;
! 2134: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2135: if( p->iReg==iReg ){
! 2136: p->tempReg = 0;
! 2137: }
! 2138: }
! 2139: }
! 2140:
! 2141: /*
! 2142: ** Generate code to extract the value of the iCol-th column of a table.
! 2143: */
! 2144: void sqlite3ExprCodeGetColumnOfTable(
! 2145: Vdbe *v, /* The VDBE under construction */
! 2146: Table *pTab, /* The table containing the value */
! 2147: int iTabCur, /* The cursor for this table */
! 2148: int iCol, /* Index of the column to extract */
! 2149: int regOut /* Extract the valud into this register */
! 2150: ){
! 2151: if( iCol<0 || iCol==pTab->iPKey ){
! 2152: sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
! 2153: }else{
! 2154: int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
! 2155: sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
! 2156: }
! 2157: if( iCol>=0 ){
! 2158: sqlite3ColumnDefault(v, pTab, iCol, regOut);
! 2159: }
! 2160: }
! 2161:
! 2162: /*
! 2163: ** Generate code that will extract the iColumn-th column from
! 2164: ** table pTab and store the column value in a register. An effort
! 2165: ** is made to store the column value in register iReg, but this is
! 2166: ** not guaranteed. The location of the column value is returned.
! 2167: **
! 2168: ** There must be an open cursor to pTab in iTable when this routine
! 2169: ** is called. If iColumn<0 then code is generated that extracts the rowid.
! 2170: */
! 2171: int sqlite3ExprCodeGetColumn(
! 2172: Parse *pParse, /* Parsing and code generating context */
! 2173: Table *pTab, /* Description of the table we are reading from */
! 2174: int iColumn, /* Index of the table column */
! 2175: int iTable, /* The cursor pointing to the table */
! 2176: int iReg /* Store results here */
! 2177: ){
! 2178: Vdbe *v = pParse->pVdbe;
! 2179: int i;
! 2180: struct yColCache *p;
! 2181:
! 2182: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2183: if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
! 2184: p->lru = pParse->iCacheCnt++;
! 2185: sqlite3ExprCachePinRegister(pParse, p->iReg);
! 2186: return p->iReg;
! 2187: }
! 2188: }
! 2189: assert( v!=0 );
! 2190: sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
! 2191: sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
! 2192: return iReg;
! 2193: }
! 2194:
! 2195: /*
! 2196: ** Clear all column cache entries.
! 2197: */
! 2198: void sqlite3ExprCacheClear(Parse *pParse){
! 2199: int i;
! 2200: struct yColCache *p;
! 2201:
! 2202: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2203: if( p->iReg ){
! 2204: cacheEntryClear(pParse, p);
! 2205: p->iReg = 0;
! 2206: }
! 2207: }
! 2208: }
! 2209:
! 2210: /*
! 2211: ** Record the fact that an affinity change has occurred on iCount
! 2212: ** registers starting with iStart.
! 2213: */
! 2214: void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
! 2215: sqlite3ExprCacheRemove(pParse, iStart, iCount);
! 2216: }
! 2217:
! 2218: /*
! 2219: ** Generate code to move content from registers iFrom...iFrom+nReg-1
! 2220: ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
! 2221: */
! 2222: void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
! 2223: int i;
! 2224: struct yColCache *p;
! 2225: if( NEVER(iFrom==iTo) ) return;
! 2226: sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
! 2227: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2228: int x = p->iReg;
! 2229: if( x>=iFrom && x<iFrom+nReg ){
! 2230: p->iReg += iTo-iFrom;
! 2231: }
! 2232: }
! 2233: }
! 2234:
! 2235: /*
! 2236: ** Generate code to copy content from registers iFrom...iFrom+nReg-1
! 2237: ** over to iTo..iTo+nReg-1.
! 2238: */
! 2239: void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
! 2240: int i;
! 2241: if( NEVER(iFrom==iTo) ) return;
! 2242: for(i=0; i<nReg; i++){
! 2243: sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
! 2244: }
! 2245: }
! 2246:
! 2247: #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
! 2248: /*
! 2249: ** Return true if any register in the range iFrom..iTo (inclusive)
! 2250: ** is used as part of the column cache.
! 2251: **
! 2252: ** This routine is used within assert() and testcase() macros only
! 2253: ** and does not appear in a normal build.
! 2254: */
! 2255: static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
! 2256: int i;
! 2257: struct yColCache *p;
! 2258: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 2259: int r = p->iReg;
! 2260: if( r>=iFrom && r<=iTo ) return 1; /*NO_TEST*/
! 2261: }
! 2262: return 0;
! 2263: }
! 2264: #endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
! 2265:
! 2266: /*
! 2267: ** Generate code into the current Vdbe to evaluate the given
! 2268: ** expression. Attempt to store the results in register "target".
! 2269: ** Return the register where results are stored.
! 2270: **
! 2271: ** With this routine, there is no guarantee that results will
! 2272: ** be stored in target. The result might be stored in some other
! 2273: ** register if it is convenient to do so. The calling function
! 2274: ** must check the return code and move the results to the desired
! 2275: ** register.
! 2276: */
! 2277: int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
! 2278: Vdbe *v = pParse->pVdbe; /* The VM under construction */
! 2279: int op; /* The opcode being coded */
! 2280: int inReg = target; /* Results stored in register inReg */
! 2281: int regFree1 = 0; /* If non-zero free this temporary register */
! 2282: int regFree2 = 0; /* If non-zero free this temporary register */
! 2283: int r1, r2, r3, r4; /* Various register numbers */
! 2284: sqlite3 *db = pParse->db; /* The database connection */
! 2285:
! 2286: assert( target>0 && target<=pParse->nMem );
! 2287: if( v==0 ){
! 2288: assert( pParse->db->mallocFailed );
! 2289: return 0;
! 2290: }
! 2291:
! 2292: if( pExpr==0 ){
! 2293: op = TK_NULL;
! 2294: }else{
! 2295: op = pExpr->op;
! 2296: }
! 2297: switch( op ){
! 2298: case TK_AGG_COLUMN: {
! 2299: AggInfo *pAggInfo = pExpr->pAggInfo;
! 2300: struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
! 2301: if( !pAggInfo->directMode ){
! 2302: assert( pCol->iMem>0 );
! 2303: inReg = pCol->iMem;
! 2304: break;
! 2305: }else if( pAggInfo->useSortingIdx ){
! 2306: sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
! 2307: pCol->iSorterColumn, target);
! 2308: break;
! 2309: }
! 2310: /* Otherwise, fall thru into the TK_COLUMN case */
! 2311: }
! 2312: case TK_COLUMN: {
! 2313: if( pExpr->iTable<0 ){
! 2314: /* This only happens when coding check constraints */
! 2315: assert( pParse->ckBase>0 );
! 2316: inReg = pExpr->iColumn + pParse->ckBase;
! 2317: }else{
! 2318: inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
! 2319: pExpr->iColumn, pExpr->iTable, target);
! 2320: }
! 2321: break;
! 2322: }
! 2323: case TK_INTEGER: {
! 2324: codeInteger(pParse, pExpr, 0, target);
! 2325: break;
! 2326: }
! 2327: #ifndef SQLITE_OMIT_FLOATING_POINT
! 2328: case TK_FLOAT: {
! 2329: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2330: codeReal(v, pExpr->u.zToken, 0, target);
! 2331: break;
! 2332: }
! 2333: #endif
! 2334: case TK_STRING: {
! 2335: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2336: sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
! 2337: break;
! 2338: }
! 2339: case TK_NULL: {
! 2340: sqlite3VdbeAddOp2(v, OP_Null, 0, target);
! 2341: break;
! 2342: }
! 2343: #ifndef SQLITE_OMIT_BLOB_LITERAL
! 2344: case TK_BLOB: {
! 2345: int n;
! 2346: const char *z;
! 2347: char *zBlob;
! 2348: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2349: assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
! 2350: assert( pExpr->u.zToken[1]=='\'' );
! 2351: z = &pExpr->u.zToken[2];
! 2352: n = sqlite3Strlen30(z) - 1;
! 2353: assert( z[n]=='\'' );
! 2354: zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
! 2355: sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
! 2356: break;
! 2357: }
! 2358: #endif
! 2359: case TK_VARIABLE: {
! 2360: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2361: assert( pExpr->u.zToken!=0 );
! 2362: assert( pExpr->u.zToken[0]!=0 );
! 2363: sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
! 2364: if( pExpr->u.zToken[1]!=0 ){
! 2365: assert( pExpr->u.zToken[0]=='?'
! 2366: || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
! 2367: sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
! 2368: }
! 2369: break;
! 2370: }
! 2371: case TK_REGISTER: {
! 2372: inReg = pExpr->iTable;
! 2373: break;
! 2374: }
! 2375: case TK_AS: {
! 2376: inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
! 2377: break;
! 2378: }
! 2379: #ifndef SQLITE_OMIT_CAST
! 2380: case TK_CAST: {
! 2381: /* Expressions of the form: CAST(pLeft AS token) */
! 2382: int aff, to_op;
! 2383: inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
! 2384: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2385: aff = sqlite3AffinityType(pExpr->u.zToken);
! 2386: to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
! 2387: assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
! 2388: assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
! 2389: assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
! 2390: assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
! 2391: assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
! 2392: testcase( to_op==OP_ToText );
! 2393: testcase( to_op==OP_ToBlob );
! 2394: testcase( to_op==OP_ToNumeric );
! 2395: testcase( to_op==OP_ToInt );
! 2396: testcase( to_op==OP_ToReal );
! 2397: if( inReg!=target ){
! 2398: sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
! 2399: inReg = target;
! 2400: }
! 2401: sqlite3VdbeAddOp1(v, to_op, inReg);
! 2402: testcase( usedAsColumnCache(pParse, inReg, inReg) );
! 2403: sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
! 2404: break;
! 2405: }
! 2406: #endif /* SQLITE_OMIT_CAST */
! 2407: case TK_LT:
! 2408: case TK_LE:
! 2409: case TK_GT:
! 2410: case TK_GE:
! 2411: case TK_NE:
! 2412: case TK_EQ: {
! 2413: assert( TK_LT==OP_Lt );
! 2414: assert( TK_LE==OP_Le );
! 2415: assert( TK_GT==OP_Gt );
! 2416: assert( TK_GE==OP_Ge );
! 2417: assert( TK_EQ==OP_Eq );
! 2418: assert( TK_NE==OP_Ne );
! 2419: testcase( op==TK_LT );
! 2420: testcase( op==TK_LE );
! 2421: testcase( op==TK_GT );
! 2422: testcase( op==TK_GE );
! 2423: testcase( op==TK_EQ );
! 2424: testcase( op==TK_NE );
! 2425: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 2426: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 2427: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
! 2428: r1, r2, inReg, SQLITE_STOREP2);
! 2429: testcase( regFree1==0 );
! 2430: testcase( regFree2==0 );
! 2431: break;
! 2432: }
! 2433: case TK_IS:
! 2434: case TK_ISNOT: {
! 2435: testcase( op==TK_IS );
! 2436: testcase( op==TK_ISNOT );
! 2437: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 2438: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 2439: op = (op==TK_IS) ? TK_EQ : TK_NE;
! 2440: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
! 2441: r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
! 2442: testcase( regFree1==0 );
! 2443: testcase( regFree2==0 );
! 2444: break;
! 2445: }
! 2446: case TK_AND:
! 2447: case TK_OR:
! 2448: case TK_PLUS:
! 2449: case TK_STAR:
! 2450: case TK_MINUS:
! 2451: case TK_REM:
! 2452: case TK_BITAND:
! 2453: case TK_BITOR:
! 2454: case TK_SLASH:
! 2455: case TK_LSHIFT:
! 2456: case TK_RSHIFT:
! 2457: case TK_CONCAT: {
! 2458: assert( TK_AND==OP_And );
! 2459: assert( TK_OR==OP_Or );
! 2460: assert( TK_PLUS==OP_Add );
! 2461: assert( TK_MINUS==OP_Subtract );
! 2462: assert( TK_REM==OP_Remainder );
! 2463: assert( TK_BITAND==OP_BitAnd );
! 2464: assert( TK_BITOR==OP_BitOr );
! 2465: assert( TK_SLASH==OP_Divide );
! 2466: assert( TK_LSHIFT==OP_ShiftLeft );
! 2467: assert( TK_RSHIFT==OP_ShiftRight );
! 2468: assert( TK_CONCAT==OP_Concat );
! 2469: testcase( op==TK_AND );
! 2470: testcase( op==TK_OR );
! 2471: testcase( op==TK_PLUS );
! 2472: testcase( op==TK_MINUS );
! 2473: testcase( op==TK_REM );
! 2474: testcase( op==TK_BITAND );
! 2475: testcase( op==TK_BITOR );
! 2476: testcase( op==TK_SLASH );
! 2477: testcase( op==TK_LSHIFT );
! 2478: testcase( op==TK_RSHIFT );
! 2479: testcase( op==TK_CONCAT );
! 2480: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 2481: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 2482: sqlite3VdbeAddOp3(v, op, r2, r1, target);
! 2483: testcase( regFree1==0 );
! 2484: testcase( regFree2==0 );
! 2485: break;
! 2486: }
! 2487: case TK_UMINUS: {
! 2488: Expr *pLeft = pExpr->pLeft;
! 2489: assert( pLeft );
! 2490: if( pLeft->op==TK_INTEGER ){
! 2491: codeInteger(pParse, pLeft, 1, target);
! 2492: #ifndef SQLITE_OMIT_FLOATING_POINT
! 2493: }else if( pLeft->op==TK_FLOAT ){
! 2494: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2495: codeReal(v, pLeft->u.zToken, 1, target);
! 2496: #endif
! 2497: }else{
! 2498: regFree1 = r1 = sqlite3GetTempReg(pParse);
! 2499: sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
! 2500: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
! 2501: sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
! 2502: testcase( regFree2==0 );
! 2503: }
! 2504: inReg = target;
! 2505: break;
! 2506: }
! 2507: case TK_BITNOT:
! 2508: case TK_NOT: {
! 2509: assert( TK_BITNOT==OP_BitNot );
! 2510: assert( TK_NOT==OP_Not );
! 2511: testcase( op==TK_BITNOT );
! 2512: testcase( op==TK_NOT );
! 2513: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 2514: testcase( regFree1==0 );
! 2515: inReg = target;
! 2516: sqlite3VdbeAddOp2(v, op, r1, inReg);
! 2517: break;
! 2518: }
! 2519: case TK_ISNULL:
! 2520: case TK_NOTNULL: {
! 2521: int addr;
! 2522: assert( TK_ISNULL==OP_IsNull );
! 2523: assert( TK_NOTNULL==OP_NotNull );
! 2524: testcase( op==TK_ISNULL );
! 2525: testcase( op==TK_NOTNULL );
! 2526: sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
! 2527: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 2528: testcase( regFree1==0 );
! 2529: addr = sqlite3VdbeAddOp1(v, op, r1);
! 2530: sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
! 2531: sqlite3VdbeJumpHere(v, addr);
! 2532: break;
! 2533: }
! 2534: case TK_AGG_FUNCTION: {
! 2535: AggInfo *pInfo = pExpr->pAggInfo;
! 2536: if( pInfo==0 ){
! 2537: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2538: sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
! 2539: }else{
! 2540: inReg = pInfo->aFunc[pExpr->iAgg].iMem;
! 2541: }
! 2542: break;
! 2543: }
! 2544: case TK_CONST_FUNC:
! 2545: case TK_FUNCTION: {
! 2546: ExprList *pFarg; /* List of function arguments */
! 2547: int nFarg; /* Number of function arguments */
! 2548: FuncDef *pDef; /* The function definition object */
! 2549: int nId; /* Length of the function name in bytes */
! 2550: const char *zId; /* The function name */
! 2551: int constMask = 0; /* Mask of function arguments that are constant */
! 2552: int i; /* Loop counter */
! 2553: u8 enc = ENC(db); /* The text encoding used by this database */
! 2554: CollSeq *pColl = 0; /* A collating sequence */
! 2555:
! 2556: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
! 2557: testcase( op==TK_CONST_FUNC );
! 2558: testcase( op==TK_FUNCTION );
! 2559: if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
! 2560: pFarg = 0;
! 2561: }else{
! 2562: pFarg = pExpr->x.pList;
! 2563: }
! 2564: nFarg = pFarg ? pFarg->nExpr : 0;
! 2565: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2566: zId = pExpr->u.zToken;
! 2567: nId = sqlite3Strlen30(zId);
! 2568: pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
! 2569: if( pDef==0 ){
! 2570: sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
! 2571: break;
! 2572: }
! 2573:
! 2574: /* Attempt a direct implementation of the built-in COALESCE() and
! 2575: ** IFNULL() functions. This avoids unnecessary evalation of
! 2576: ** arguments past the first non-NULL argument.
! 2577: */
! 2578: if( pDef->flags & SQLITE_FUNC_COALESCE ){
! 2579: int endCoalesce = sqlite3VdbeMakeLabel(v);
! 2580: assert( nFarg>=2 );
! 2581: sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
! 2582: for(i=1; i<nFarg; i++){
! 2583: sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
! 2584: sqlite3ExprCacheRemove(pParse, target, 1);
! 2585: sqlite3ExprCachePush(pParse);
! 2586: sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
! 2587: sqlite3ExprCachePop(pParse, 1);
! 2588: }
! 2589: sqlite3VdbeResolveLabel(v, endCoalesce);
! 2590: break;
! 2591: }
! 2592:
! 2593:
! 2594: if( pFarg ){
! 2595: r1 = sqlite3GetTempRange(pParse, nFarg);
! 2596: sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
! 2597: sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
! 2598: sqlite3ExprCachePop(pParse, 1); /* Ticket 2ea2425d34be */
! 2599: }else{
! 2600: r1 = 0;
! 2601: }
! 2602: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 2603: /* Possibly overload the function if the first argument is
! 2604: ** a virtual table column.
! 2605: **
! 2606: ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
! 2607: ** second argument, not the first, as the argument to test to
! 2608: ** see if it is a column in a virtual table. This is done because
! 2609: ** the left operand of infix functions (the operand we want to
! 2610: ** control overloading) ends up as the second argument to the
! 2611: ** function. The expression "A glob B" is equivalent to
! 2612: ** "glob(B,A). We want to use the A in "A glob B" to test
! 2613: ** for function overloading. But we use the B term in "glob(B,A)".
! 2614: */
! 2615: if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
! 2616: pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
! 2617: }else if( nFarg>0 ){
! 2618: pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
! 2619: }
! 2620: #endif
! 2621: for(i=0; i<nFarg; i++){
! 2622: if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
! 2623: constMask |= (1<<i);
! 2624: }
! 2625: if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
! 2626: pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
! 2627: }
! 2628: }
! 2629: if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
! 2630: if( !pColl ) pColl = db->pDfltColl;
! 2631: sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
! 2632: }
! 2633: sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
! 2634: (char*)pDef, P4_FUNCDEF);
! 2635: sqlite3VdbeChangeP5(v, (u8)nFarg);
! 2636: if( nFarg ){
! 2637: sqlite3ReleaseTempRange(pParse, r1, nFarg);
! 2638: }
! 2639: break;
! 2640: }
! 2641: #ifndef SQLITE_OMIT_SUBQUERY
! 2642: case TK_EXISTS:
! 2643: case TK_SELECT: {
! 2644: testcase( op==TK_EXISTS );
! 2645: testcase( op==TK_SELECT );
! 2646: inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
! 2647: break;
! 2648: }
! 2649: case TK_IN: {
! 2650: int destIfFalse = sqlite3VdbeMakeLabel(v);
! 2651: int destIfNull = sqlite3VdbeMakeLabel(v);
! 2652: sqlite3VdbeAddOp2(v, OP_Null, 0, target);
! 2653: sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
! 2654: sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
! 2655: sqlite3VdbeResolveLabel(v, destIfFalse);
! 2656: sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
! 2657: sqlite3VdbeResolveLabel(v, destIfNull);
! 2658: break;
! 2659: }
! 2660: #endif /* SQLITE_OMIT_SUBQUERY */
! 2661:
! 2662:
! 2663: /*
! 2664: ** x BETWEEN y AND z
! 2665: **
! 2666: ** This is equivalent to
! 2667: **
! 2668: ** x>=y AND x<=z
! 2669: **
! 2670: ** X is stored in pExpr->pLeft.
! 2671: ** Y is stored in pExpr->pList->a[0].pExpr.
! 2672: ** Z is stored in pExpr->pList->a[1].pExpr.
! 2673: */
! 2674: case TK_BETWEEN: {
! 2675: Expr *pLeft = pExpr->pLeft;
! 2676: struct ExprList_item *pLItem = pExpr->x.pList->a;
! 2677: Expr *pRight = pLItem->pExpr;
! 2678:
! 2679: r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1);
! 2680: r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
! 2681: testcase( regFree1==0 );
! 2682: testcase( regFree2==0 );
! 2683: r3 = sqlite3GetTempReg(pParse);
! 2684: r4 = sqlite3GetTempReg(pParse);
! 2685: codeCompare(pParse, pLeft, pRight, OP_Ge,
! 2686: r1, r2, r3, SQLITE_STOREP2);
! 2687: pLItem++;
! 2688: pRight = pLItem->pExpr;
! 2689: sqlite3ReleaseTempReg(pParse, regFree2);
! 2690: r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
! 2691: testcase( regFree2==0 );
! 2692: codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
! 2693: sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
! 2694: sqlite3ReleaseTempReg(pParse, r3);
! 2695: sqlite3ReleaseTempReg(pParse, r4);
! 2696: break;
! 2697: }
! 2698: case TK_UPLUS: {
! 2699: inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
! 2700: break;
! 2701: }
! 2702:
! 2703: case TK_TRIGGER: {
! 2704: /* If the opcode is TK_TRIGGER, then the expression is a reference
! 2705: ** to a column in the new.* or old.* pseudo-tables available to
! 2706: ** trigger programs. In this case Expr.iTable is set to 1 for the
! 2707: ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
! 2708: ** is set to the column of the pseudo-table to read, or to -1 to
! 2709: ** read the rowid field.
! 2710: **
! 2711: ** The expression is implemented using an OP_Param opcode. The p1
! 2712: ** parameter is set to 0 for an old.rowid reference, or to (i+1)
! 2713: ** to reference another column of the old.* pseudo-table, where
! 2714: ** i is the index of the column. For a new.rowid reference, p1 is
! 2715: ** set to (n+1), where n is the number of columns in each pseudo-table.
! 2716: ** For a reference to any other column in the new.* pseudo-table, p1
! 2717: ** is set to (n+2+i), where n and i are as defined previously. For
! 2718: ** example, if the table on which triggers are being fired is
! 2719: ** declared as:
! 2720: **
! 2721: ** CREATE TABLE t1(a, b);
! 2722: **
! 2723: ** Then p1 is interpreted as follows:
! 2724: **
! 2725: ** p1==0 -> old.rowid p1==3 -> new.rowid
! 2726: ** p1==1 -> old.a p1==4 -> new.a
! 2727: ** p1==2 -> old.b p1==5 -> new.b
! 2728: */
! 2729: Table *pTab = pExpr->pTab;
! 2730: int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
! 2731:
! 2732: assert( pExpr->iTable==0 || pExpr->iTable==1 );
! 2733: assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
! 2734: assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
! 2735: assert( p1>=0 && p1<(pTab->nCol*2+2) );
! 2736:
! 2737: sqlite3VdbeAddOp2(v, OP_Param, p1, target);
! 2738: VdbeComment((v, "%s.%s -> $%d",
! 2739: (pExpr->iTable ? "new" : "old"),
! 2740: (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
! 2741: target
! 2742: ));
! 2743:
! 2744: #ifndef SQLITE_OMIT_FLOATING_POINT
! 2745: /* If the column has REAL affinity, it may currently be stored as an
! 2746: ** integer. Use OP_RealAffinity to make sure it is really real. */
! 2747: if( pExpr->iColumn>=0
! 2748: && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
! 2749: ){
! 2750: sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
! 2751: }
! 2752: #endif
! 2753: break;
! 2754: }
! 2755:
! 2756:
! 2757: /*
! 2758: ** Form A:
! 2759: ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
! 2760: **
! 2761: ** Form B:
! 2762: ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
! 2763: **
! 2764: ** Form A is can be transformed into the equivalent form B as follows:
! 2765: ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
! 2766: ** WHEN x=eN THEN rN ELSE y END
! 2767: **
! 2768: ** X (if it exists) is in pExpr->pLeft.
! 2769: ** Y is in pExpr->pRight. The Y is also optional. If there is no
! 2770: ** ELSE clause and no other term matches, then the result of the
! 2771: ** exprssion is NULL.
! 2772: ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
! 2773: **
! 2774: ** The result of the expression is the Ri for the first matching Ei,
! 2775: ** or if there is no matching Ei, the ELSE term Y, or if there is
! 2776: ** no ELSE term, NULL.
! 2777: */
! 2778: default: assert( op==TK_CASE ); {
! 2779: int endLabel; /* GOTO label for end of CASE stmt */
! 2780: int nextCase; /* GOTO label for next WHEN clause */
! 2781: int nExpr; /* 2x number of WHEN terms */
! 2782: int i; /* Loop counter */
! 2783: ExprList *pEList; /* List of WHEN terms */
! 2784: struct ExprList_item *aListelem; /* Array of WHEN terms */
! 2785: Expr opCompare; /* The X==Ei expression */
! 2786: Expr cacheX; /* Cached expression X */
! 2787: Expr *pX; /* The X expression */
! 2788: Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */
! 2789: VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
! 2790:
! 2791: assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
! 2792: assert((pExpr->x.pList->nExpr % 2) == 0);
! 2793: assert(pExpr->x.pList->nExpr > 0);
! 2794: pEList = pExpr->x.pList;
! 2795: aListelem = pEList->a;
! 2796: nExpr = pEList->nExpr;
! 2797: endLabel = sqlite3VdbeMakeLabel(v);
! 2798: if( (pX = pExpr->pLeft)!=0 ){
! 2799: cacheX = *pX;
! 2800: testcase( pX->op==TK_COLUMN );
! 2801: testcase( pX->op==TK_REGISTER );
! 2802: cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, ®Free1);
! 2803: testcase( regFree1==0 );
! 2804: cacheX.op = TK_REGISTER;
! 2805: opCompare.op = TK_EQ;
! 2806: opCompare.pLeft = &cacheX;
! 2807: pTest = &opCompare;
! 2808: /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
! 2809: ** The value in regFree1 might get SCopy-ed into the file result.
! 2810: ** So make sure that the regFree1 register is not reused for other
! 2811: ** purposes and possibly overwritten. */
! 2812: regFree1 = 0;
! 2813: }
! 2814: for(i=0; i<nExpr; i=i+2){
! 2815: sqlite3ExprCachePush(pParse);
! 2816: if( pX ){
! 2817: assert( pTest!=0 );
! 2818: opCompare.pRight = aListelem[i].pExpr;
! 2819: }else{
! 2820: pTest = aListelem[i].pExpr;
! 2821: }
! 2822: nextCase = sqlite3VdbeMakeLabel(v);
! 2823: testcase( pTest->op==TK_COLUMN );
! 2824: sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
! 2825: testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
! 2826: testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
! 2827: sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
! 2828: sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
! 2829: sqlite3ExprCachePop(pParse, 1);
! 2830: sqlite3VdbeResolveLabel(v, nextCase);
! 2831: }
! 2832: if( pExpr->pRight ){
! 2833: sqlite3ExprCachePush(pParse);
! 2834: sqlite3ExprCode(pParse, pExpr->pRight, target);
! 2835: sqlite3ExprCachePop(pParse, 1);
! 2836: }else{
! 2837: sqlite3VdbeAddOp2(v, OP_Null, 0, target);
! 2838: }
! 2839: assert( db->mallocFailed || pParse->nErr>0
! 2840: || pParse->iCacheLevel==iCacheLevel );
! 2841: sqlite3VdbeResolveLabel(v, endLabel);
! 2842: break;
! 2843: }
! 2844: #ifndef SQLITE_OMIT_TRIGGER
! 2845: case TK_RAISE: {
! 2846: assert( pExpr->affinity==OE_Rollback
! 2847: || pExpr->affinity==OE_Abort
! 2848: || pExpr->affinity==OE_Fail
! 2849: || pExpr->affinity==OE_Ignore
! 2850: );
! 2851: if( !pParse->pTriggerTab ){
! 2852: sqlite3ErrorMsg(pParse,
! 2853: "RAISE() may only be used within a trigger-program");
! 2854: return 0;
! 2855: }
! 2856: if( pExpr->affinity==OE_Abort ){
! 2857: sqlite3MayAbort(pParse);
! 2858: }
! 2859: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 2860: if( pExpr->affinity==OE_Ignore ){
! 2861: sqlite3VdbeAddOp4(
! 2862: v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
! 2863: }else{
! 2864: sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
! 2865: }
! 2866:
! 2867: break;
! 2868: }
! 2869: #endif
! 2870: }
! 2871: sqlite3ReleaseTempReg(pParse, regFree1);
! 2872: sqlite3ReleaseTempReg(pParse, regFree2);
! 2873: return inReg;
! 2874: }
! 2875:
! 2876: /*
! 2877: ** Generate code to evaluate an expression and store the results
! 2878: ** into a register. Return the register number where the results
! 2879: ** are stored.
! 2880: **
! 2881: ** If the register is a temporary register that can be deallocated,
! 2882: ** then write its number into *pReg. If the result register is not
! 2883: ** a temporary, then set *pReg to zero.
! 2884: */
! 2885: int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
! 2886: int r1 = sqlite3GetTempReg(pParse);
! 2887: int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
! 2888: if( r2==r1 ){
! 2889: *pReg = r1;
! 2890: }else{
! 2891: sqlite3ReleaseTempReg(pParse, r1);
! 2892: *pReg = 0;
! 2893: }
! 2894: return r2;
! 2895: }
! 2896:
! 2897: /*
! 2898: ** Generate code that will evaluate expression pExpr and store the
! 2899: ** results in register target. The results are guaranteed to appear
! 2900: ** in register target.
! 2901: */
! 2902: int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
! 2903: int inReg;
! 2904:
! 2905: assert( target>0 && target<=pParse->nMem );
! 2906: if( pExpr && pExpr->op==TK_REGISTER ){
! 2907: sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
! 2908: }else{
! 2909: inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
! 2910: assert( pParse->pVdbe || pParse->db->mallocFailed );
! 2911: if( inReg!=target && pParse->pVdbe ){
! 2912: sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
! 2913: }
! 2914: }
! 2915: return target;
! 2916: }
! 2917:
! 2918: /*
! 2919: ** Generate code that evalutes the given expression and puts the result
! 2920: ** in register target.
! 2921: **
! 2922: ** Also make a copy of the expression results into another "cache" register
! 2923: ** and modify the expression so that the next time it is evaluated,
! 2924: ** the result is a copy of the cache register.
! 2925: **
! 2926: ** This routine is used for expressions that are used multiple
! 2927: ** times. They are evaluated once and the results of the expression
! 2928: ** are reused.
! 2929: */
! 2930: int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
! 2931: Vdbe *v = pParse->pVdbe;
! 2932: int inReg;
! 2933: inReg = sqlite3ExprCode(pParse, pExpr, target);
! 2934: assert( target>0 );
! 2935: /* This routine is called for terms to INSERT or UPDATE. And the only
! 2936: ** other place where expressions can be converted into TK_REGISTER is
! 2937: ** in WHERE clause processing. So as currently implemented, there is
! 2938: ** no way for a TK_REGISTER to exist here. But it seems prudent to
! 2939: ** keep the ALWAYS() in case the conditions above change with future
! 2940: ** modifications or enhancements. */
! 2941: if( ALWAYS(pExpr->op!=TK_REGISTER) ){
! 2942: int iMem;
! 2943: iMem = ++pParse->nMem;
! 2944: sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
! 2945: pExpr->iTable = iMem;
! 2946: pExpr->op2 = pExpr->op;
! 2947: pExpr->op = TK_REGISTER;
! 2948: }
! 2949: return inReg;
! 2950: }
! 2951:
! 2952: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
! 2953: /*
! 2954: ** Generate a human-readable explanation of an expression tree.
! 2955: */
! 2956: void sqlite3ExplainExpr(Vdbe *pOut, Expr *pExpr){
! 2957: int op; /* The opcode being coded */
! 2958: const char *zBinOp = 0; /* Binary operator */
! 2959: const char *zUniOp = 0; /* Unary operator */
! 2960: if( pExpr==0 ){
! 2961: op = TK_NULL;
! 2962: }else{
! 2963: op = pExpr->op;
! 2964: }
! 2965: switch( op ){
! 2966: case TK_AGG_COLUMN: {
! 2967: sqlite3ExplainPrintf(pOut, "AGG{%d:%d}",
! 2968: pExpr->iTable, pExpr->iColumn);
! 2969: break;
! 2970: }
! 2971: case TK_COLUMN: {
! 2972: if( pExpr->iTable<0 ){
! 2973: /* This only happens when coding check constraints */
! 2974: sqlite3ExplainPrintf(pOut, "COLUMN(%d)", pExpr->iColumn);
! 2975: }else{
! 2976: sqlite3ExplainPrintf(pOut, "{%d:%d}",
! 2977: pExpr->iTable, pExpr->iColumn);
! 2978: }
! 2979: break;
! 2980: }
! 2981: case TK_INTEGER: {
! 2982: if( pExpr->flags & EP_IntValue ){
! 2983: sqlite3ExplainPrintf(pOut, "%d", pExpr->u.iValue);
! 2984: }else{
! 2985: sqlite3ExplainPrintf(pOut, "%s", pExpr->u.zToken);
! 2986: }
! 2987: break;
! 2988: }
! 2989: #ifndef SQLITE_OMIT_FLOATING_POINT
! 2990: case TK_FLOAT: {
! 2991: sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
! 2992: break;
! 2993: }
! 2994: #endif
! 2995: case TK_STRING: {
! 2996: sqlite3ExplainPrintf(pOut,"%Q", pExpr->u.zToken);
! 2997: break;
! 2998: }
! 2999: case TK_NULL: {
! 3000: sqlite3ExplainPrintf(pOut,"NULL");
! 3001: break;
! 3002: }
! 3003: #ifndef SQLITE_OMIT_BLOB_LITERAL
! 3004: case TK_BLOB: {
! 3005: sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
! 3006: break;
! 3007: }
! 3008: #endif
! 3009: case TK_VARIABLE: {
! 3010: sqlite3ExplainPrintf(pOut,"VARIABLE(%s,%d)",
! 3011: pExpr->u.zToken, pExpr->iColumn);
! 3012: break;
! 3013: }
! 3014: case TK_REGISTER: {
! 3015: sqlite3ExplainPrintf(pOut,"REGISTER(%d)", pExpr->iTable);
! 3016: break;
! 3017: }
! 3018: case TK_AS: {
! 3019: sqlite3ExplainExpr(pOut, pExpr->pLeft);
! 3020: break;
! 3021: }
! 3022: #ifndef SQLITE_OMIT_CAST
! 3023: case TK_CAST: {
! 3024: /* Expressions of the form: CAST(pLeft AS token) */
! 3025: const char *zAff = "unk";
! 3026: switch( sqlite3AffinityType(pExpr->u.zToken) ){
! 3027: case SQLITE_AFF_TEXT: zAff = "TEXT"; break;
! 3028: case SQLITE_AFF_NONE: zAff = "NONE"; break;
! 3029: case SQLITE_AFF_NUMERIC: zAff = "NUMERIC"; break;
! 3030: case SQLITE_AFF_INTEGER: zAff = "INTEGER"; break;
! 3031: case SQLITE_AFF_REAL: zAff = "REAL"; break;
! 3032: }
! 3033: sqlite3ExplainPrintf(pOut, "CAST-%s(", zAff);
! 3034: sqlite3ExplainExpr(pOut, pExpr->pLeft);
! 3035: sqlite3ExplainPrintf(pOut, ")");
! 3036: break;
! 3037: }
! 3038: #endif /* SQLITE_OMIT_CAST */
! 3039: case TK_LT: zBinOp = "LT"; break;
! 3040: case TK_LE: zBinOp = "LE"; break;
! 3041: case TK_GT: zBinOp = "GT"; break;
! 3042: case TK_GE: zBinOp = "GE"; break;
! 3043: case TK_NE: zBinOp = "NE"; break;
! 3044: case TK_EQ: zBinOp = "EQ"; break;
! 3045: case TK_IS: zBinOp = "IS"; break;
! 3046: case TK_ISNOT: zBinOp = "ISNOT"; break;
! 3047: case TK_AND: zBinOp = "AND"; break;
! 3048: case TK_OR: zBinOp = "OR"; break;
! 3049: case TK_PLUS: zBinOp = "ADD"; break;
! 3050: case TK_STAR: zBinOp = "MUL"; break;
! 3051: case TK_MINUS: zBinOp = "SUB"; break;
! 3052: case TK_REM: zBinOp = "REM"; break;
! 3053: case TK_BITAND: zBinOp = "BITAND"; break;
! 3054: case TK_BITOR: zBinOp = "BITOR"; break;
! 3055: case TK_SLASH: zBinOp = "DIV"; break;
! 3056: case TK_LSHIFT: zBinOp = "LSHIFT"; break;
! 3057: case TK_RSHIFT: zBinOp = "RSHIFT"; break;
! 3058: case TK_CONCAT: zBinOp = "CONCAT"; break;
! 3059:
! 3060: case TK_UMINUS: zUniOp = "UMINUS"; break;
! 3061: case TK_UPLUS: zUniOp = "UPLUS"; break;
! 3062: case TK_BITNOT: zUniOp = "BITNOT"; break;
! 3063: case TK_NOT: zUniOp = "NOT"; break;
! 3064: case TK_ISNULL: zUniOp = "ISNULL"; break;
! 3065: case TK_NOTNULL: zUniOp = "NOTNULL"; break;
! 3066:
! 3067: case TK_AGG_FUNCTION:
! 3068: case TK_CONST_FUNC:
! 3069: case TK_FUNCTION: {
! 3070: ExprList *pFarg; /* List of function arguments */
! 3071: if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
! 3072: pFarg = 0;
! 3073: }else{
! 3074: pFarg = pExpr->x.pList;
! 3075: }
! 3076: sqlite3ExplainPrintf(pOut, "%sFUNCTION:%s(",
! 3077: op==TK_AGG_FUNCTION ? "AGG_" : "",
! 3078: pExpr->u.zToken);
! 3079: if( pFarg ){
! 3080: sqlite3ExplainExprList(pOut, pFarg);
! 3081: }
! 3082: sqlite3ExplainPrintf(pOut, ")");
! 3083: break;
! 3084: }
! 3085: #ifndef SQLITE_OMIT_SUBQUERY
! 3086: case TK_EXISTS: {
! 3087: sqlite3ExplainPrintf(pOut, "EXISTS(");
! 3088: sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
! 3089: sqlite3ExplainPrintf(pOut,")");
! 3090: break;
! 3091: }
! 3092: case TK_SELECT: {
! 3093: sqlite3ExplainPrintf(pOut, "(");
! 3094: sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
! 3095: sqlite3ExplainPrintf(pOut, ")");
! 3096: break;
! 3097: }
! 3098: case TK_IN: {
! 3099: sqlite3ExplainPrintf(pOut, "IN(");
! 3100: sqlite3ExplainExpr(pOut, pExpr->pLeft);
! 3101: sqlite3ExplainPrintf(pOut, ",");
! 3102: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
! 3103: sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
! 3104: }else{
! 3105: sqlite3ExplainExprList(pOut, pExpr->x.pList);
! 3106: }
! 3107: sqlite3ExplainPrintf(pOut, ")");
! 3108: break;
! 3109: }
! 3110: #endif /* SQLITE_OMIT_SUBQUERY */
! 3111:
! 3112: /*
! 3113: ** x BETWEEN y AND z
! 3114: **
! 3115: ** This is equivalent to
! 3116: **
! 3117: ** x>=y AND x<=z
! 3118: **
! 3119: ** X is stored in pExpr->pLeft.
! 3120: ** Y is stored in pExpr->pList->a[0].pExpr.
! 3121: ** Z is stored in pExpr->pList->a[1].pExpr.
! 3122: */
! 3123: case TK_BETWEEN: {
! 3124: Expr *pX = pExpr->pLeft;
! 3125: Expr *pY = pExpr->x.pList->a[0].pExpr;
! 3126: Expr *pZ = pExpr->x.pList->a[1].pExpr;
! 3127: sqlite3ExplainPrintf(pOut, "BETWEEN(");
! 3128: sqlite3ExplainExpr(pOut, pX);
! 3129: sqlite3ExplainPrintf(pOut, ",");
! 3130: sqlite3ExplainExpr(pOut, pY);
! 3131: sqlite3ExplainPrintf(pOut, ",");
! 3132: sqlite3ExplainExpr(pOut, pZ);
! 3133: sqlite3ExplainPrintf(pOut, ")");
! 3134: break;
! 3135: }
! 3136: case TK_TRIGGER: {
! 3137: /* If the opcode is TK_TRIGGER, then the expression is a reference
! 3138: ** to a column in the new.* or old.* pseudo-tables available to
! 3139: ** trigger programs. In this case Expr.iTable is set to 1 for the
! 3140: ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
! 3141: ** is set to the column of the pseudo-table to read, or to -1 to
! 3142: ** read the rowid field.
! 3143: */
! 3144: sqlite3ExplainPrintf(pOut, "%s(%d)",
! 3145: pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
! 3146: break;
! 3147: }
! 3148: case TK_CASE: {
! 3149: sqlite3ExplainPrintf(pOut, "CASE(");
! 3150: sqlite3ExplainExpr(pOut, pExpr->pLeft);
! 3151: sqlite3ExplainPrintf(pOut, ",");
! 3152: sqlite3ExplainExprList(pOut, pExpr->x.pList);
! 3153: break;
! 3154: }
! 3155: #ifndef SQLITE_OMIT_TRIGGER
! 3156: case TK_RAISE: {
! 3157: const char *zType = "unk";
! 3158: switch( pExpr->affinity ){
! 3159: case OE_Rollback: zType = "rollback"; break;
! 3160: case OE_Abort: zType = "abort"; break;
! 3161: case OE_Fail: zType = "fail"; break;
! 3162: case OE_Ignore: zType = "ignore"; break;
! 3163: }
! 3164: sqlite3ExplainPrintf(pOut, "RAISE-%s(%s)", zType, pExpr->u.zToken);
! 3165: break;
! 3166: }
! 3167: #endif
! 3168: }
! 3169: if( zBinOp ){
! 3170: sqlite3ExplainPrintf(pOut,"%s(", zBinOp);
! 3171: sqlite3ExplainExpr(pOut, pExpr->pLeft);
! 3172: sqlite3ExplainPrintf(pOut,",");
! 3173: sqlite3ExplainExpr(pOut, pExpr->pRight);
! 3174: sqlite3ExplainPrintf(pOut,")");
! 3175: }else if( zUniOp ){
! 3176: sqlite3ExplainPrintf(pOut,"%s(", zUniOp);
! 3177: sqlite3ExplainExpr(pOut, pExpr->pLeft);
! 3178: sqlite3ExplainPrintf(pOut,")");
! 3179: }
! 3180: }
! 3181: #endif /* defined(SQLITE_ENABLE_TREE_EXPLAIN) */
! 3182:
! 3183: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
! 3184: /*
! 3185: ** Generate a human-readable explanation of an expression list.
! 3186: */
! 3187: void sqlite3ExplainExprList(Vdbe *pOut, ExprList *pList){
! 3188: int i;
! 3189: if( pList==0 || pList->nExpr==0 ){
! 3190: sqlite3ExplainPrintf(pOut, "(empty-list)");
! 3191: return;
! 3192: }else if( pList->nExpr==1 ){
! 3193: sqlite3ExplainExpr(pOut, pList->a[0].pExpr);
! 3194: }else{
! 3195: sqlite3ExplainPush(pOut);
! 3196: for(i=0; i<pList->nExpr; i++){
! 3197: sqlite3ExplainPrintf(pOut, "item[%d] = ", i);
! 3198: sqlite3ExplainPush(pOut);
! 3199: sqlite3ExplainExpr(pOut, pList->a[i].pExpr);
! 3200: sqlite3ExplainPop(pOut);
! 3201: if( i<pList->nExpr-1 ){
! 3202: sqlite3ExplainNL(pOut);
! 3203: }
! 3204: }
! 3205: sqlite3ExplainPop(pOut);
! 3206: }
! 3207: }
! 3208: #endif /* SQLITE_DEBUG */
! 3209:
! 3210: /*
! 3211: ** Return TRUE if pExpr is an constant expression that is appropriate
! 3212: ** for factoring out of a loop. Appropriate expressions are:
! 3213: **
! 3214: ** * Any expression that evaluates to two or more opcodes.
! 3215: **
! 3216: ** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
! 3217: ** or OP_Variable that does not need to be placed in a
! 3218: ** specific register.
! 3219: **
! 3220: ** There is no point in factoring out single-instruction constant
! 3221: ** expressions that need to be placed in a particular register.
! 3222: ** We could factor them out, but then we would end up adding an
! 3223: ** OP_SCopy instruction to move the value into the correct register
! 3224: ** later. We might as well just use the original instruction and
! 3225: ** avoid the OP_SCopy.
! 3226: */
! 3227: static int isAppropriateForFactoring(Expr *p){
! 3228: if( !sqlite3ExprIsConstantNotJoin(p) ){
! 3229: return 0; /* Only constant expressions are appropriate for factoring */
! 3230: }
! 3231: if( (p->flags & EP_FixedDest)==0 ){
! 3232: return 1; /* Any constant without a fixed destination is appropriate */
! 3233: }
! 3234: while( p->op==TK_UPLUS ) p = p->pLeft;
! 3235: switch( p->op ){
! 3236: #ifndef SQLITE_OMIT_BLOB_LITERAL
! 3237: case TK_BLOB:
! 3238: #endif
! 3239: case TK_VARIABLE:
! 3240: case TK_INTEGER:
! 3241: case TK_FLOAT:
! 3242: case TK_NULL:
! 3243: case TK_STRING: {
! 3244: testcase( p->op==TK_BLOB );
! 3245: testcase( p->op==TK_VARIABLE );
! 3246: testcase( p->op==TK_INTEGER );
! 3247: testcase( p->op==TK_FLOAT );
! 3248: testcase( p->op==TK_NULL );
! 3249: testcase( p->op==TK_STRING );
! 3250: /* Single-instruction constants with a fixed destination are
! 3251: ** better done in-line. If we factor them, they will just end
! 3252: ** up generating an OP_SCopy to move the value to the destination
! 3253: ** register. */
! 3254: return 0;
! 3255: }
! 3256: case TK_UMINUS: {
! 3257: if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
! 3258: return 0;
! 3259: }
! 3260: break;
! 3261: }
! 3262: default: {
! 3263: break;
! 3264: }
! 3265: }
! 3266: return 1;
! 3267: }
! 3268:
! 3269: /*
! 3270: ** If pExpr is a constant expression that is appropriate for
! 3271: ** factoring out of a loop, then evaluate the expression
! 3272: ** into a register and convert the expression into a TK_REGISTER
! 3273: ** expression.
! 3274: */
! 3275: static int evalConstExpr(Walker *pWalker, Expr *pExpr){
! 3276: Parse *pParse = pWalker->pParse;
! 3277: switch( pExpr->op ){
! 3278: case TK_IN:
! 3279: case TK_REGISTER: {
! 3280: return WRC_Prune;
! 3281: }
! 3282: case TK_FUNCTION:
! 3283: case TK_AGG_FUNCTION:
! 3284: case TK_CONST_FUNC: {
! 3285: /* The arguments to a function have a fixed destination.
! 3286: ** Mark them this way to avoid generated unneeded OP_SCopy
! 3287: ** instructions.
! 3288: */
! 3289: ExprList *pList = pExpr->x.pList;
! 3290: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
! 3291: if( pList ){
! 3292: int i = pList->nExpr;
! 3293: struct ExprList_item *pItem = pList->a;
! 3294: for(; i>0; i--, pItem++){
! 3295: if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
! 3296: }
! 3297: }
! 3298: break;
! 3299: }
! 3300: }
! 3301: if( isAppropriateForFactoring(pExpr) ){
! 3302: int r1 = ++pParse->nMem;
! 3303: int r2;
! 3304: r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
! 3305: if( NEVER(r1!=r2) ) sqlite3ReleaseTempReg(pParse, r1);
! 3306: pExpr->op2 = pExpr->op;
! 3307: pExpr->op = TK_REGISTER;
! 3308: pExpr->iTable = r2;
! 3309: return WRC_Prune;
! 3310: }
! 3311: return WRC_Continue;
! 3312: }
! 3313:
! 3314: /*
! 3315: ** Preevaluate constant subexpressions within pExpr and store the
! 3316: ** results in registers. Modify pExpr so that the constant subexpresions
! 3317: ** are TK_REGISTER opcodes that refer to the precomputed values.
! 3318: **
! 3319: ** This routine is a no-op if the jump to the cookie-check code has
! 3320: ** already occur. Since the cookie-check jump is generated prior to
! 3321: ** any other serious processing, this check ensures that there is no
! 3322: ** way to accidently bypass the constant initializations.
! 3323: **
! 3324: ** This routine is also a no-op if the SQLITE_FactorOutConst optimization
! 3325: ** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
! 3326: ** interface. This allows test logic to verify that the same answer is
! 3327: ** obtained for queries regardless of whether or not constants are
! 3328: ** precomputed into registers or if they are inserted in-line.
! 3329: */
! 3330: void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
! 3331: Walker w;
! 3332: if( pParse->cookieGoto ) return;
! 3333: if( (pParse->db->flags & SQLITE_FactorOutConst)!=0 ) return;
! 3334: w.xExprCallback = evalConstExpr;
! 3335: w.xSelectCallback = 0;
! 3336: w.pParse = pParse;
! 3337: sqlite3WalkExpr(&w, pExpr);
! 3338: }
! 3339:
! 3340:
! 3341: /*
! 3342: ** Generate code that pushes the value of every element of the given
! 3343: ** expression list into a sequence of registers beginning at target.
! 3344: **
! 3345: ** Return the number of elements evaluated.
! 3346: */
! 3347: int sqlite3ExprCodeExprList(
! 3348: Parse *pParse, /* Parsing context */
! 3349: ExprList *pList, /* The expression list to be coded */
! 3350: int target, /* Where to write results */
! 3351: int doHardCopy /* Make a hard copy of every element */
! 3352: ){
! 3353: struct ExprList_item *pItem;
! 3354: int i, n;
! 3355: assert( pList!=0 );
! 3356: assert( target>0 );
! 3357: assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
! 3358: n = pList->nExpr;
! 3359: for(pItem=pList->a, i=0; i<n; i++, pItem++){
! 3360: Expr *pExpr = pItem->pExpr;
! 3361: int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
! 3362: if( inReg!=target+i ){
! 3363: sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
! 3364: inReg, target+i);
! 3365: }
! 3366: }
! 3367: return n;
! 3368: }
! 3369:
! 3370: /*
! 3371: ** Generate code for a BETWEEN operator.
! 3372: **
! 3373: ** x BETWEEN y AND z
! 3374: **
! 3375: ** The above is equivalent to
! 3376: **
! 3377: ** x>=y AND x<=z
! 3378: **
! 3379: ** Code it as such, taking care to do the common subexpression
! 3380: ** elementation of x.
! 3381: */
! 3382: static void exprCodeBetween(
! 3383: Parse *pParse, /* Parsing and code generating context */
! 3384: Expr *pExpr, /* The BETWEEN expression */
! 3385: int dest, /* Jump here if the jump is taken */
! 3386: int jumpIfTrue, /* Take the jump if the BETWEEN is true */
! 3387: int jumpIfNull /* Take the jump if the BETWEEN is NULL */
! 3388: ){
! 3389: Expr exprAnd; /* The AND operator in x>=y AND x<=z */
! 3390: Expr compLeft; /* The x>=y term */
! 3391: Expr compRight; /* The x<=z term */
! 3392: Expr exprX; /* The x subexpression */
! 3393: int regFree1 = 0; /* Temporary use register */
! 3394:
! 3395: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
! 3396: exprX = *pExpr->pLeft;
! 3397: exprAnd.op = TK_AND;
! 3398: exprAnd.pLeft = &compLeft;
! 3399: exprAnd.pRight = &compRight;
! 3400: compLeft.op = TK_GE;
! 3401: compLeft.pLeft = &exprX;
! 3402: compLeft.pRight = pExpr->x.pList->a[0].pExpr;
! 3403: compRight.op = TK_LE;
! 3404: compRight.pLeft = &exprX;
! 3405: compRight.pRight = pExpr->x.pList->a[1].pExpr;
! 3406: exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, ®Free1);
! 3407: exprX.op = TK_REGISTER;
! 3408: if( jumpIfTrue ){
! 3409: sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
! 3410: }else{
! 3411: sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
! 3412: }
! 3413: sqlite3ReleaseTempReg(pParse, regFree1);
! 3414:
! 3415: /* Ensure adequate test coverage */
! 3416: testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
! 3417: testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
! 3418: testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
! 3419: testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
! 3420: testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
! 3421: testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
! 3422: testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
! 3423: testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
! 3424: }
! 3425:
! 3426: /*
! 3427: ** Generate code for a boolean expression such that a jump is made
! 3428: ** to the label "dest" if the expression is true but execution
! 3429: ** continues straight thru if the expression is false.
! 3430: **
! 3431: ** If the expression evaluates to NULL (neither true nor false), then
! 3432: ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
! 3433: **
! 3434: ** This code depends on the fact that certain token values (ex: TK_EQ)
! 3435: ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
! 3436: ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
! 3437: ** the make process cause these values to align. Assert()s in the code
! 3438: ** below verify that the numbers are aligned correctly.
! 3439: */
! 3440: void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
! 3441: Vdbe *v = pParse->pVdbe;
! 3442: int op = 0;
! 3443: int regFree1 = 0;
! 3444: int regFree2 = 0;
! 3445: int r1, r2;
! 3446:
! 3447: assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
! 3448: if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
! 3449: if( NEVER(pExpr==0) ) return; /* No way this can happen */
! 3450: op = pExpr->op;
! 3451: switch( op ){
! 3452: case TK_AND: {
! 3453: int d2 = sqlite3VdbeMakeLabel(v);
! 3454: testcase( jumpIfNull==0 );
! 3455: sqlite3ExprCachePush(pParse);
! 3456: sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
! 3457: sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
! 3458: sqlite3VdbeResolveLabel(v, d2);
! 3459: sqlite3ExprCachePop(pParse, 1);
! 3460: break;
! 3461: }
! 3462: case TK_OR: {
! 3463: testcase( jumpIfNull==0 );
! 3464: sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
! 3465: sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
! 3466: break;
! 3467: }
! 3468: case TK_NOT: {
! 3469: testcase( jumpIfNull==0 );
! 3470: sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
! 3471: break;
! 3472: }
! 3473: case TK_LT:
! 3474: case TK_LE:
! 3475: case TK_GT:
! 3476: case TK_GE:
! 3477: case TK_NE:
! 3478: case TK_EQ: {
! 3479: assert( TK_LT==OP_Lt );
! 3480: assert( TK_LE==OP_Le );
! 3481: assert( TK_GT==OP_Gt );
! 3482: assert( TK_GE==OP_Ge );
! 3483: assert( TK_EQ==OP_Eq );
! 3484: assert( TK_NE==OP_Ne );
! 3485: testcase( op==TK_LT );
! 3486: testcase( op==TK_LE );
! 3487: testcase( op==TK_GT );
! 3488: testcase( op==TK_GE );
! 3489: testcase( op==TK_EQ );
! 3490: testcase( op==TK_NE );
! 3491: testcase( jumpIfNull==0 );
! 3492: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 3493: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 3494: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
! 3495: r1, r2, dest, jumpIfNull);
! 3496: testcase( regFree1==0 );
! 3497: testcase( regFree2==0 );
! 3498: break;
! 3499: }
! 3500: case TK_IS:
! 3501: case TK_ISNOT: {
! 3502: testcase( op==TK_IS );
! 3503: testcase( op==TK_ISNOT );
! 3504: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 3505: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 3506: op = (op==TK_IS) ? TK_EQ : TK_NE;
! 3507: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
! 3508: r1, r2, dest, SQLITE_NULLEQ);
! 3509: testcase( regFree1==0 );
! 3510: testcase( regFree2==0 );
! 3511: break;
! 3512: }
! 3513: case TK_ISNULL:
! 3514: case TK_NOTNULL: {
! 3515: assert( TK_ISNULL==OP_IsNull );
! 3516: assert( TK_NOTNULL==OP_NotNull );
! 3517: testcase( op==TK_ISNULL );
! 3518: testcase( op==TK_NOTNULL );
! 3519: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 3520: sqlite3VdbeAddOp2(v, op, r1, dest);
! 3521: testcase( regFree1==0 );
! 3522: break;
! 3523: }
! 3524: case TK_BETWEEN: {
! 3525: testcase( jumpIfNull==0 );
! 3526: exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
! 3527: break;
! 3528: }
! 3529: #ifndef SQLITE_OMIT_SUBQUERY
! 3530: case TK_IN: {
! 3531: int destIfFalse = sqlite3VdbeMakeLabel(v);
! 3532: int destIfNull = jumpIfNull ? dest : destIfFalse;
! 3533: sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
! 3534: sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
! 3535: sqlite3VdbeResolveLabel(v, destIfFalse);
! 3536: break;
! 3537: }
! 3538: #endif
! 3539: default: {
! 3540: r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
! 3541: sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
! 3542: testcase( regFree1==0 );
! 3543: testcase( jumpIfNull==0 );
! 3544: break;
! 3545: }
! 3546: }
! 3547: sqlite3ReleaseTempReg(pParse, regFree1);
! 3548: sqlite3ReleaseTempReg(pParse, regFree2);
! 3549: }
! 3550:
! 3551: /*
! 3552: ** Generate code for a boolean expression such that a jump is made
! 3553: ** to the label "dest" if the expression is false but execution
! 3554: ** continues straight thru if the expression is true.
! 3555: **
! 3556: ** If the expression evaluates to NULL (neither true nor false) then
! 3557: ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
! 3558: ** is 0.
! 3559: */
! 3560: void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
! 3561: Vdbe *v = pParse->pVdbe;
! 3562: int op = 0;
! 3563: int regFree1 = 0;
! 3564: int regFree2 = 0;
! 3565: int r1, r2;
! 3566:
! 3567: assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
! 3568: if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
! 3569: if( pExpr==0 ) return;
! 3570:
! 3571: /* The value of pExpr->op and op are related as follows:
! 3572: **
! 3573: ** pExpr->op op
! 3574: ** --------- ----------
! 3575: ** TK_ISNULL OP_NotNull
! 3576: ** TK_NOTNULL OP_IsNull
! 3577: ** TK_NE OP_Eq
! 3578: ** TK_EQ OP_Ne
! 3579: ** TK_GT OP_Le
! 3580: ** TK_LE OP_Gt
! 3581: ** TK_GE OP_Lt
! 3582: ** TK_LT OP_Ge
! 3583: **
! 3584: ** For other values of pExpr->op, op is undefined and unused.
! 3585: ** The value of TK_ and OP_ constants are arranged such that we
! 3586: ** can compute the mapping above using the following expression.
! 3587: ** Assert()s verify that the computation is correct.
! 3588: */
! 3589: op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
! 3590:
! 3591: /* Verify correct alignment of TK_ and OP_ constants
! 3592: */
! 3593: assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
! 3594: assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
! 3595: assert( pExpr->op!=TK_NE || op==OP_Eq );
! 3596: assert( pExpr->op!=TK_EQ || op==OP_Ne );
! 3597: assert( pExpr->op!=TK_LT || op==OP_Ge );
! 3598: assert( pExpr->op!=TK_LE || op==OP_Gt );
! 3599: assert( pExpr->op!=TK_GT || op==OP_Le );
! 3600: assert( pExpr->op!=TK_GE || op==OP_Lt );
! 3601:
! 3602: switch( pExpr->op ){
! 3603: case TK_AND: {
! 3604: testcase( jumpIfNull==0 );
! 3605: sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
! 3606: sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
! 3607: break;
! 3608: }
! 3609: case TK_OR: {
! 3610: int d2 = sqlite3VdbeMakeLabel(v);
! 3611: testcase( jumpIfNull==0 );
! 3612: sqlite3ExprCachePush(pParse);
! 3613: sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
! 3614: sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
! 3615: sqlite3VdbeResolveLabel(v, d2);
! 3616: sqlite3ExprCachePop(pParse, 1);
! 3617: break;
! 3618: }
! 3619: case TK_NOT: {
! 3620: testcase( jumpIfNull==0 );
! 3621: sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
! 3622: break;
! 3623: }
! 3624: case TK_LT:
! 3625: case TK_LE:
! 3626: case TK_GT:
! 3627: case TK_GE:
! 3628: case TK_NE:
! 3629: case TK_EQ: {
! 3630: testcase( op==TK_LT );
! 3631: testcase( op==TK_LE );
! 3632: testcase( op==TK_GT );
! 3633: testcase( op==TK_GE );
! 3634: testcase( op==TK_EQ );
! 3635: testcase( op==TK_NE );
! 3636: testcase( jumpIfNull==0 );
! 3637: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 3638: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 3639: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
! 3640: r1, r2, dest, jumpIfNull);
! 3641: testcase( regFree1==0 );
! 3642: testcase( regFree2==0 );
! 3643: break;
! 3644: }
! 3645: case TK_IS:
! 3646: case TK_ISNOT: {
! 3647: testcase( pExpr->op==TK_IS );
! 3648: testcase( pExpr->op==TK_ISNOT );
! 3649: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 3650: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
! 3651: op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
! 3652: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
! 3653: r1, r2, dest, SQLITE_NULLEQ);
! 3654: testcase( regFree1==0 );
! 3655: testcase( regFree2==0 );
! 3656: break;
! 3657: }
! 3658: case TK_ISNULL:
! 3659: case TK_NOTNULL: {
! 3660: testcase( op==TK_ISNULL );
! 3661: testcase( op==TK_NOTNULL );
! 3662: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
! 3663: sqlite3VdbeAddOp2(v, op, r1, dest);
! 3664: testcase( regFree1==0 );
! 3665: break;
! 3666: }
! 3667: case TK_BETWEEN: {
! 3668: testcase( jumpIfNull==0 );
! 3669: exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
! 3670: break;
! 3671: }
! 3672: #ifndef SQLITE_OMIT_SUBQUERY
! 3673: case TK_IN: {
! 3674: if( jumpIfNull ){
! 3675: sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
! 3676: }else{
! 3677: int destIfNull = sqlite3VdbeMakeLabel(v);
! 3678: sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
! 3679: sqlite3VdbeResolveLabel(v, destIfNull);
! 3680: }
! 3681: break;
! 3682: }
! 3683: #endif
! 3684: default: {
! 3685: r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
! 3686: sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
! 3687: testcase( regFree1==0 );
! 3688: testcase( jumpIfNull==0 );
! 3689: break;
! 3690: }
! 3691: }
! 3692: sqlite3ReleaseTempReg(pParse, regFree1);
! 3693: sqlite3ReleaseTempReg(pParse, regFree2);
! 3694: }
! 3695:
! 3696: /*
! 3697: ** Do a deep comparison of two expression trees. Return 0 if the two
! 3698: ** expressions are completely identical. Return 1 if they differ only
! 3699: ** by a COLLATE operator at the top level. Return 2 if there are differences
! 3700: ** other than the top-level COLLATE operator.
! 3701: **
! 3702: ** Sometimes this routine will return 2 even if the two expressions
! 3703: ** really are equivalent. If we cannot prove that the expressions are
! 3704: ** identical, we return 2 just to be safe. So if this routine
! 3705: ** returns 2, then you do not really know for certain if the two
! 3706: ** expressions are the same. But if you get a 0 or 1 return, then you
! 3707: ** can be sure the expressions are the same. In the places where
! 3708: ** this routine is used, it does not hurt to get an extra 2 - that
! 3709: ** just might result in some slightly slower code. But returning
! 3710: ** an incorrect 0 or 1 could lead to a malfunction.
! 3711: */
! 3712: int sqlite3ExprCompare(Expr *pA, Expr *pB){
! 3713: if( pA==0||pB==0 ){
! 3714: return pB==pA ? 0 : 2;
! 3715: }
! 3716: assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
! 3717: assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
! 3718: if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
! 3719: return 2;
! 3720: }
! 3721: if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
! 3722: if( pA->op!=pB->op ) return 2;
! 3723: if( sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 2;
! 3724: if( sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 2;
! 3725: if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList) ) return 2;
! 3726: if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 2;
! 3727: if( ExprHasProperty(pA, EP_IntValue) ){
! 3728: if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
! 3729: return 2;
! 3730: }
! 3731: }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
! 3732: if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
! 3733: if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
! 3734: return 2;
! 3735: }
! 3736: }
! 3737: if( (pA->flags & EP_ExpCollate)!=(pB->flags & EP_ExpCollate) ) return 1;
! 3738: if( (pA->flags & EP_ExpCollate)!=0 && pA->pColl!=pB->pColl ) return 2;
! 3739: return 0;
! 3740: }
! 3741:
! 3742: /*
! 3743: ** Compare two ExprList objects. Return 0 if they are identical and
! 3744: ** non-zero if they differ in any way.
! 3745: **
! 3746: ** This routine might return non-zero for equivalent ExprLists. The
! 3747: ** only consequence will be disabled optimizations. But this routine
! 3748: ** must never return 0 if the two ExprList objects are different, or
! 3749: ** a malfunction will result.
! 3750: **
! 3751: ** Two NULL pointers are considered to be the same. But a NULL pointer
! 3752: ** always differs from a non-NULL pointer.
! 3753: */
! 3754: int sqlite3ExprListCompare(ExprList *pA, ExprList *pB){
! 3755: int i;
! 3756: if( pA==0 && pB==0 ) return 0;
! 3757: if( pA==0 || pB==0 ) return 1;
! 3758: if( pA->nExpr!=pB->nExpr ) return 1;
! 3759: for(i=0; i<pA->nExpr; i++){
! 3760: Expr *pExprA = pA->a[i].pExpr;
! 3761: Expr *pExprB = pB->a[i].pExpr;
! 3762: if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
! 3763: if( sqlite3ExprCompare(pExprA, pExprB) ) return 1;
! 3764: }
! 3765: return 0;
! 3766: }
! 3767:
! 3768: /*
! 3769: ** Add a new element to the pAggInfo->aCol[] array. Return the index of
! 3770: ** the new element. Return a negative number if malloc fails.
! 3771: */
! 3772: static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
! 3773: int i;
! 3774: pInfo->aCol = sqlite3ArrayAllocate(
! 3775: db,
! 3776: pInfo->aCol,
! 3777: sizeof(pInfo->aCol[0]),
! 3778: 3,
! 3779: &pInfo->nColumn,
! 3780: &pInfo->nColumnAlloc,
! 3781: &i
! 3782: );
! 3783: return i;
! 3784: }
! 3785:
! 3786: /*
! 3787: ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
! 3788: ** the new element. Return a negative number if malloc fails.
! 3789: */
! 3790: static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
! 3791: int i;
! 3792: pInfo->aFunc = sqlite3ArrayAllocate(
! 3793: db,
! 3794: pInfo->aFunc,
! 3795: sizeof(pInfo->aFunc[0]),
! 3796: 3,
! 3797: &pInfo->nFunc,
! 3798: &pInfo->nFuncAlloc,
! 3799: &i
! 3800: );
! 3801: return i;
! 3802: }
! 3803:
! 3804: /*
! 3805: ** This is the xExprCallback for a tree walker. It is used to
! 3806: ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
! 3807: ** for additional information.
! 3808: */
! 3809: static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
! 3810: int i;
! 3811: NameContext *pNC = pWalker->u.pNC;
! 3812: Parse *pParse = pNC->pParse;
! 3813: SrcList *pSrcList = pNC->pSrcList;
! 3814: AggInfo *pAggInfo = pNC->pAggInfo;
! 3815:
! 3816: switch( pExpr->op ){
! 3817: case TK_AGG_COLUMN:
! 3818: case TK_COLUMN: {
! 3819: testcase( pExpr->op==TK_AGG_COLUMN );
! 3820: testcase( pExpr->op==TK_COLUMN );
! 3821: /* Check to see if the column is in one of the tables in the FROM
! 3822: ** clause of the aggregate query */
! 3823: if( ALWAYS(pSrcList!=0) ){
! 3824: struct SrcList_item *pItem = pSrcList->a;
! 3825: for(i=0; i<pSrcList->nSrc; i++, pItem++){
! 3826: struct AggInfo_col *pCol;
! 3827: assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
! 3828: if( pExpr->iTable==pItem->iCursor ){
! 3829: /* If we reach this point, it means that pExpr refers to a table
! 3830: ** that is in the FROM clause of the aggregate query.
! 3831: **
! 3832: ** Make an entry for the column in pAggInfo->aCol[] if there
! 3833: ** is not an entry there already.
! 3834: */
! 3835: int k;
! 3836: pCol = pAggInfo->aCol;
! 3837: for(k=0; k<pAggInfo->nColumn; k++, pCol++){
! 3838: if( pCol->iTable==pExpr->iTable &&
! 3839: pCol->iColumn==pExpr->iColumn ){
! 3840: break;
! 3841: }
! 3842: }
! 3843: if( (k>=pAggInfo->nColumn)
! 3844: && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
! 3845: ){
! 3846: pCol = &pAggInfo->aCol[k];
! 3847: pCol->pTab = pExpr->pTab;
! 3848: pCol->iTable = pExpr->iTable;
! 3849: pCol->iColumn = pExpr->iColumn;
! 3850: pCol->iMem = ++pParse->nMem;
! 3851: pCol->iSorterColumn = -1;
! 3852: pCol->pExpr = pExpr;
! 3853: if( pAggInfo->pGroupBy ){
! 3854: int j, n;
! 3855: ExprList *pGB = pAggInfo->pGroupBy;
! 3856: struct ExprList_item *pTerm = pGB->a;
! 3857: n = pGB->nExpr;
! 3858: for(j=0; j<n; j++, pTerm++){
! 3859: Expr *pE = pTerm->pExpr;
! 3860: if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
! 3861: pE->iColumn==pExpr->iColumn ){
! 3862: pCol->iSorterColumn = j;
! 3863: break;
! 3864: }
! 3865: }
! 3866: }
! 3867: if( pCol->iSorterColumn<0 ){
! 3868: pCol->iSorterColumn = pAggInfo->nSortingColumn++;
! 3869: }
! 3870: }
! 3871: /* There is now an entry for pExpr in pAggInfo->aCol[] (either
! 3872: ** because it was there before or because we just created it).
! 3873: ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
! 3874: ** pAggInfo->aCol[] entry.
! 3875: */
! 3876: ExprSetIrreducible(pExpr);
! 3877: pExpr->pAggInfo = pAggInfo;
! 3878: pExpr->op = TK_AGG_COLUMN;
! 3879: pExpr->iAgg = (i16)k;
! 3880: break;
! 3881: } /* endif pExpr->iTable==pItem->iCursor */
! 3882: } /* end loop over pSrcList */
! 3883: }
! 3884: return WRC_Prune;
! 3885: }
! 3886: case TK_AGG_FUNCTION: {
! 3887: /* The pNC->nDepth==0 test causes aggregate functions in subqueries
! 3888: ** to be ignored */
! 3889: if( pNC->nDepth==0 ){
! 3890: /* Check to see if pExpr is a duplicate of another aggregate
! 3891: ** function that is already in the pAggInfo structure
! 3892: */
! 3893: struct AggInfo_func *pItem = pAggInfo->aFunc;
! 3894: for(i=0; i<pAggInfo->nFunc; i++, pItem++){
! 3895: if( sqlite3ExprCompare(pItem->pExpr, pExpr)==0 ){
! 3896: break;
! 3897: }
! 3898: }
! 3899: if( i>=pAggInfo->nFunc ){
! 3900: /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
! 3901: */
! 3902: u8 enc = ENC(pParse->db);
! 3903: i = addAggInfoFunc(pParse->db, pAggInfo);
! 3904: if( i>=0 ){
! 3905: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
! 3906: pItem = &pAggInfo->aFunc[i];
! 3907: pItem->pExpr = pExpr;
! 3908: pItem->iMem = ++pParse->nMem;
! 3909: assert( !ExprHasProperty(pExpr, EP_IntValue) );
! 3910: pItem->pFunc = sqlite3FindFunction(pParse->db,
! 3911: pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
! 3912: pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
! 3913: if( pExpr->flags & EP_Distinct ){
! 3914: pItem->iDistinct = pParse->nTab++;
! 3915: }else{
! 3916: pItem->iDistinct = -1;
! 3917: }
! 3918: }
! 3919: }
! 3920: /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
! 3921: */
! 3922: assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
! 3923: ExprSetIrreducible(pExpr);
! 3924: pExpr->iAgg = (i16)i;
! 3925: pExpr->pAggInfo = pAggInfo;
! 3926: return WRC_Prune;
! 3927: }
! 3928: }
! 3929: }
! 3930: return WRC_Continue;
! 3931: }
! 3932: static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
! 3933: NameContext *pNC = pWalker->u.pNC;
! 3934: if( pNC->nDepth==0 ){
! 3935: pNC->nDepth++;
! 3936: sqlite3WalkSelect(pWalker, pSelect);
! 3937: pNC->nDepth--;
! 3938: return WRC_Prune;
! 3939: }else{
! 3940: return WRC_Continue;
! 3941: }
! 3942: }
! 3943:
! 3944: /*
! 3945: ** Analyze the given expression looking for aggregate functions and
! 3946: ** for variables that need to be added to the pParse->aAgg[] array.
! 3947: ** Make additional entries to the pParse->aAgg[] array as necessary.
! 3948: **
! 3949: ** This routine should only be called after the expression has been
! 3950: ** analyzed by sqlite3ResolveExprNames().
! 3951: */
! 3952: void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
! 3953: Walker w;
! 3954: w.xExprCallback = analyzeAggregate;
! 3955: w.xSelectCallback = analyzeAggregatesInSelect;
! 3956: w.u.pNC = pNC;
! 3957: assert( pNC->pSrcList!=0 );
! 3958: sqlite3WalkExpr(&w, pExpr);
! 3959: }
! 3960:
! 3961: /*
! 3962: ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
! 3963: ** expression list. Return the number of errors.
! 3964: **
! 3965: ** If an error is found, the analysis is cut short.
! 3966: */
! 3967: void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
! 3968: struct ExprList_item *pItem;
! 3969: int i;
! 3970: if( pList ){
! 3971: for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
! 3972: sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
! 3973: }
! 3974: }
! 3975: }
! 3976:
! 3977: /*
! 3978: ** Allocate a single new register for use to hold some intermediate result.
! 3979: */
! 3980: int sqlite3GetTempReg(Parse *pParse){
! 3981: if( pParse->nTempReg==0 ){
! 3982: return ++pParse->nMem;
! 3983: }
! 3984: return pParse->aTempReg[--pParse->nTempReg];
! 3985: }
! 3986:
! 3987: /*
! 3988: ** Deallocate a register, making available for reuse for some other
! 3989: ** purpose.
! 3990: **
! 3991: ** If a register is currently being used by the column cache, then
! 3992: ** the dallocation is deferred until the column cache line that uses
! 3993: ** the register becomes stale.
! 3994: */
! 3995: void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
! 3996: if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
! 3997: int i;
! 3998: struct yColCache *p;
! 3999: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
! 4000: if( p->iReg==iReg ){
! 4001: p->tempReg = 1;
! 4002: return;
! 4003: }
! 4004: }
! 4005: pParse->aTempReg[pParse->nTempReg++] = iReg;
! 4006: }
! 4007: }
! 4008:
! 4009: /*
! 4010: ** Allocate or deallocate a block of nReg consecutive registers
! 4011: */
! 4012: int sqlite3GetTempRange(Parse *pParse, int nReg){
! 4013: int i, n;
! 4014: i = pParse->iRangeReg;
! 4015: n = pParse->nRangeReg;
! 4016: if( nReg<=n ){
! 4017: assert( !usedAsColumnCache(pParse, i, i+n-1) );
! 4018: pParse->iRangeReg += nReg;
! 4019: pParse->nRangeReg -= nReg;
! 4020: }else{
! 4021: i = pParse->nMem+1;
! 4022: pParse->nMem += nReg;
! 4023: }
! 4024: return i;
! 4025: }
! 4026: void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
! 4027: sqlite3ExprCacheRemove(pParse, iReg, nReg);
! 4028: if( nReg>pParse->nRangeReg ){
! 4029: pParse->nRangeReg = nReg;
! 4030: pParse->iRangeReg = iReg;
! 4031: }
! 4032: }
! 4033:
! 4034: /*
! 4035: ** Mark all temporary registers as being unavailable for reuse.
! 4036: */
! 4037: void sqlite3ClearTempRegCache(Parse *pParse){
! 4038: pParse->nTempReg = 0;
! 4039: pParse->nRangeReg = 0;
! 4040: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src