Index: src/expr.c ================================================================== --- src/expr.c +++ src/expr.c @@ -407,98 +407,98 @@ return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree); } /* ** Expression pExpr is a comparison between two vector values. Compute -** the result of the comparison and write it to register dest. +** the result of the comparison (1, 0, or NULL) and write that +** result into register dest. +** +** The caller must satisfy the following preconditions: +** +** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ +** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ +** otherwise: op==pExpr->op and p5==0 */ -static void codeVectorCompare(Parse *pParse, Expr *pExpr, int dest){ +static void codeVectorCompare( + Parse *pParse, /* Code generator context */ + Expr *pExpr, /* The comparison operation */ + int dest, /* Write results into this register */ + u8 op, /* Comparison operator */ + u8 p5 /* SQLITE_NULLEQ or zero */ +){ Vdbe *v = pParse->pVdbe; Expr *pLeft = pExpr->pLeft; Expr *pRight = pExpr->pRight; int nLeft = sqlite3ExprVectorSize(pLeft); int nRight = sqlite3ExprVectorSize(pRight); - int addr = sqlite3VdbeMakeLabel(v); /* Check that both sides of the comparison are vectors, and that ** both are the same length. */ if( nLeft!=nRight ){ sqlite3ErrorMsg(pParse, "invalid use of row value"); }else{ - int p5 = (pExpr->op==TK_IS || pExpr->op==TK_ISNOT) ? SQLITE_NULLEQ : 0; int i; int regLeft = 0; int regRight = 0; - int regTmp = 0; + u8 opx = op; + int addrDone = sqlite3VdbeMakeLabel(v); assert( pExpr->op==TK_EQ || pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT || pExpr->op==TK_LT || pExpr->op==TK_GT || pExpr->op==TK_LE || pExpr->op==TK_GE ); + assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ) + || (pExpr->op==TK_ISNOT && op==TK_NE) ); + assert( p5==0 || pExpr->op!=op ); + assert( p5==SQLITE_NULLEQ || pExpr->op==op ); - if( pExpr->op==TK_EQ || pExpr->op==TK_NE ){ - regTmp = sqlite3GetTempReg(pParse); - sqlite3VdbeAddOp2(v, OP_Integer, (pExpr->op==TK_EQ), dest); - } + p5 |= SQLITE_STOREP2; + if( opx==TK_LE ) opx = TK_LT; + if( opx==TK_GE ) opx = TK_GT; regLeft = exprCodeSubselect(pParse, pLeft); regRight = exprCodeSubselect(pParse, pRight); for(i=0; i0 ) sqlite3ExprCachePush(pParse); r1 = exprVectorRegister(pParse, pLeft, i, regLeft, &pL, ®Free1); r2 = exprVectorRegister(pParse, pRight, i, regRight, &pR, ®Free2); - - switch( pExpr->op ){ - case TK_IS: - codeCompare( - pParse, pL, pR, OP_Eq, r1, r2, dest, SQLITE_STOREP2|SQLITE_NULLEQ - ); - sqlite3VdbeAddOp3(v, OP_IfNot, dest, addr, 1); - VdbeCoverage(v); - break; - - case TK_ISNOT: - codeCompare( - pParse, pL, pR, OP_Ne, r1, r2, dest, SQLITE_STOREP2|SQLITE_NULLEQ - ); - sqlite3VdbeAddOp3(v, OP_If, dest, addr, 1); - VdbeCoverage(v); - break; - - case TK_EQ: - case TK_NE: - codeCompare(pParse, pL, pR, OP_Cmp, r1, r2, regTmp,SQLITE_STOREP2|p5); - sqlite3VdbeAddOp4Int( - v, OP_CmpTest, regTmp, addr, dest, pExpr->op==TK_NE - ); - VdbeCoverage(v); - break; - - case TK_LT: - case TK_LE: - case TK_GT: - case TK_GE: - codeCompare(pParse, pL, pR, OP_Cmp, r1, r2, dest, SQLITE_STOREP2|p5); - sqlite3VdbeAddOp4Int(v, OP_CmpTest, dest, addr, 0, pExpr->op); - VdbeCoverage(v); - break; - } - + codeCompare(pParse, pL, pR, opx, r1, r2, dest, p5); + testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); + testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); sqlite3ReleaseTempReg(pParse, regFree1); sqlite3ReleaseTempReg(pParse, regFree2); - if( i ) sqlite3ExprCachePop(pParse); + if( i>0 ) sqlite3ExprCachePop(pParse); + if( i==nLeft-1 ){ + break; + } + if( opx==TK_EQ ){ + sqlite3VdbeAddOp2(v, OP_IfNot, dest, addrDone); VdbeCoverage(v); + p5 |= SQLITE_KEEPNULL; + }else if( opx==TK_NE ){ + sqlite3VdbeAddOp2(v, OP_If, dest, addrDone); VdbeCoverage(v); + p5 |= SQLITE_KEEPNULL; + }else{ + assert( op==TK_LT || op==TK_GT || op==TK_LE || op==TK_GE ); + sqlite3VdbeAddOp2(v, OP_ElseNotEq, 0, addrDone); + VdbeCoverageIf(v, op==TK_LT); + VdbeCoverageIf(v, op==TK_GT); + VdbeCoverageIf(v, op==TK_LE); + VdbeCoverageIf(v, op==TK_GE); + if( i==nLeft-2 ) opx = op; + } } - - sqlite3ReleaseTempReg(pParse, regTmp); + sqlite3VdbeResolveLabel(v, addrDone); } - - sqlite3VdbeResolveLabel(v, addr); } #if SQLITE_MAX_EXPR_DEPTH>0 /* ** Check that argument nHeight is less than or equal to the maximum @@ -3249,11 +3249,11 @@ case TK_GE: case TK_NE: case TK_EQ: { Expr *pLeft = pExpr->pLeft; if( sqlite3ExprIsVector(pLeft) ){ - codeVectorCompare(pParse, pExpr, target); + codeVectorCompare(pParse, pExpr, target, op, p5); }else{ r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1); r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2, inReg, SQLITE_STOREP2 | p5); Index: src/sqliteInt.h ================================================================== --- src/sqliteInt.h +++ src/sqliteInt.h @@ -1731,10 +1731,11 @@ ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL. ** It causes an assert() to fire if either operand to a comparison ** operator is NULL. It is added to certain comparison operators to ** prove that the operands are always NOT NULL. */ +#define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */ #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */ #define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */ #define SQLITE_NULLEQ 0x80 /* NULL=NULL */ #define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */ Index: src/vdbe.c ================================================================== --- src/vdbe.c +++ src/vdbe.c @@ -571,11 +571,11 @@ #endif int rc = SQLITE_OK; /* Value to return */ sqlite3 *db = p->db; /* The database */ u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */ u8 encoding = ENC(db); /* The database encoding */ - int iCompare = 0; /* Result of last OP_Compare operation */ + int iCompare = 0; /* Result of last comparison */ unsigned nVmStep = 0; /* Number of virtual machine steps */ #ifndef SQLITE_OMIT_PROGRESS_CALLBACK unsigned nProgressLimit = 0;/* Invoke xProgress() when nVmStep reaches this */ #endif Mem *aMem = p->aMem; /* Copy of p->aMem */ @@ -1878,18 +1878,63 @@ if( rc ) goto abort_due_to_error; break; } #endif /* SQLITE_OMIT_CAST */ +/* Opcode: Eq P1 P2 P3 P4 P5 +** Synopsis: if r[P1]==r[P3] goto P2 +** +** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then +** jump to address P2. Or if the SQLITE_STOREP2 flag is set in P5, then +** store the result of comparison in register P2. +** +** The SQLITE_AFF_MASK portion of P5 must be an affinity character - +** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made +** to coerce both inputs according to this affinity before the +** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric +** affinity is used. Note that the affinity conversions are stored +** back into the input registers P1 and P3. So this opcode can cause +** persistent changes to registers P1 and P3. +** +** Once any conversions have taken place, and neither value is NULL, +** the values are compared. If both values are blobs then memcmp() is +** used to determine the results of the comparison. If both values +** are text, then the appropriate collating function specified in +** P4 is used to do the comparison. If P4 is not specified then +** memcmp() is used to compare text string. If both values are +** numeric, then a numeric comparison is used. If the two values +** are of different types, then numbers are considered less than +** strings and strings are considered less than blobs. +** +** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either +** true or false and is never NULL. If both operands are NULL then the result +** of comparison is true. If either operand is NULL then the result is false. +** If neither operand is NULL the result is the same as it would be if +** the SQLITE_NULLEQ flag were omitted from P5. +** +** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the +** content of r[P2] is only set to 1 (true) if it was not previously NULL. +*/ +/* Opcode: Ne P1 P2 P3 P4 P5 +** Synopsis: if r[P1]!=r[P3] goto P2 +** +** This works just like the Eq opcode except that the jump is taken if +** the operands in registers P1 and P3 are not equal. See the Eq opcode for +** additional information. +** +** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the +** content of r[P2] is only set to 0 (false) if it was not previously NULL. +*/ /* Opcode: Lt P1 P2 P3 P4 P5 ** Synopsis: if r[P1]=r[P3] goto P2 ** ** This works just like the Lt opcode except that the jump is taken if ** the content of register P3 is greater than or equal to the content of ** register P1. See the Lt opcode for additional information. -** -** Opcode: Cmp P1 P2 P3 P4 P5 -** Synopsis: P2 = cmp(P1, P3) -** -** The SQLITE_STOREP2 flag must be set for this opcode. It compares the -** values in registers P1 and P3 and stores the result of the comparison -** in register P2. The results is NULL if either of the two operands are -** NULL. Otherwise, it is an integer value less than zero, zero or greater -** than zero if P3 is less than, equal to or greater than P1, respectively. */ -case OP_Cmp: /* in1, in3 */ case OP_Eq: /* same as TK_EQ, jump, in1, in3 */ case OP_Ne: /* same as TK_NE, jump, in1, in3 */ case OP_Lt: /* same as TK_LT, jump, in1, in3 */ case OP_Le: /* same as TK_LE, jump, in1, in3 */ case OP_Gt: /* same as TK_GT, jump, in1, in3 */ @@ -1981,11 +1983,10 @@ int res; /* Result of the comparison of pIn1 against pIn3 */ char affinity; /* Affinity to use for comparison */ u16 flags1; /* Copy of initial value of pIn1->flags */ u16 flags3; /* Copy of initial value of pIn3->flags */ - assert( pOp->opcode!=OP_Cmp || (pOp->p5 & SQLITE_STOREP2) ); pIn1 = &aMem[pOp->p1]; pIn3 = &aMem[pOp->p3]; flags1 = pIn1->flags; flags3 = pIn3->flags; if( (flags1 | flags3)&MEM_Null ){ @@ -2000,19 +2001,20 @@ assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 ); if( (flags1&MEM_Null)!=0 && (flags3&MEM_Null)!=0 && (flags3&MEM_Cleared)==0 ){ - res = 0; /* Results are equal */ + iCompare = 0; /* Operands are equal */ }else{ - res = 1; /* Results are not equal */ + iCompare = 1; /* Operands are not equal */ } }else{ /* SQLITE_NULLEQ is clear and at least one operand is NULL, ** then the result is always NULL. ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. */ + iCompare = 1; /* Operands are not equal */ if( pOp->p5 & SQLITE_STOREP2 ){ pOut = &aMem[pOp->p2]; memAboutToChange(p, pOut); MemSetTypeFlag(pOut, MEM_Null); REGISTER_TRACE(pOp->p2, pOut); @@ -2061,20 +2063,19 @@ } if( flags3 & MEM_Zero ){ sqlite3VdbeMemExpandBlob(pIn3); flags3 &= ~MEM_Zero; } - res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); + iCompare = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); } switch( pOp->opcode ){ - case OP_Eq: res = res==0; break; - case OP_Ne: res = res!=0; break; - case OP_Lt: res = res<0; break; - case OP_Le: res = res<=0; break; - case OP_Gt: res = res>0; break; - case OP_Ge: res = res>=0; break; - default: assert( pOp->opcode==OP_Cmp ); break; + case OP_Eq: res = iCompare==0; break; + case OP_Ne: res = iCompare!=0; break; + case OP_Lt: res = iCompare<0; break; + case OP_Le: res = iCompare<=0; break; + case OP_Gt: res = iCompare>0; break; + default: res = iCompare>=0; break; } /* Undo any changes made by applyAffinity() to the input registers. */ assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); pIn1->flags = flags1; @@ -2081,23 +2082,46 @@ assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); pIn3->flags = flags3; if( pOp->p5 & SQLITE_STOREP2 ){ pOut = &aMem[pOp->p2]; + if( (pOp->p5 & SQLITE_KEEPNULL)!=0 && (pOut->flags & MEM_Null)!=0 ){ + /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1 + ** and prevents OP_Ne from overwriting NULL with 0. */ + assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq ); + assert( res==0 || res==1 ); + if( (pOp->opcode==OP_Eq)==res ) break; + } memAboutToChange(p, pOut); MemSetTypeFlag(pOut, MEM_Int); pOut->u.i = res; REGISTER_TRACE(pOp->p2, pOut); }else{ - assert( pOp->opcode!=OP_Cmp ); VdbeBranchTaken(res!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); if( res ){ goto jump_to_p2; } } break; } + +/* Opcode: ElseNotEq * P2 * * * +** +** This opcode must immediately follow an Lt or Gt comparison operator. +** If the operands in that previous comparison had been used with an Eq +** operator and if the result of that Eq would be NULL or false (0), then +** then jump to P2. If the result of comparing the two previous operands +** using Eq would have been true (1), then fall through. +*/ +case OP_ElseNotEq: { /* same as TK_ESCAPE, jump */ + assert( pOp>aOp ); + assert( pOp[-1].opcode==OP_Lt || pOp[-1].opcode==OP_Gt ); + VdbeBranchTaken(iCompare!=0, 2); + if( iCompare!=0 ) goto jump_to_p2; + break; +} + /* Opcode: Permutation * * * P4 * ** ** Set the permutation used by the OP_Compare operator to be the array ** of integers in P4. @@ -3883,67 +3907,10 @@ pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */ } break; } -/* Opcode: CmpTest P1 P2 P3 P4 * -** -** P2 is a jump destination. Register P1 is guaranteed to contain either -** an integer value or a NULL. -** -** If P3 is non-zero, it identifies an output register. In this case, if -** P1 is NULL, P3 is also set to NULL. Or, if P1 is any integer value -** other than 0, P3 is set to the value of P4 and a jump to P2 is taken. -** -** If P3 is 0, the jump is taken if P1 contains any value other than 0 (i.e. -** NULL does cause a jump). Additionally, if P1 is not NULL, its value is -** modified to integer value 0 or 1 according to the value of the P4 integer -** operand: -** -** P4 modification -** -------------------------- -** OP_Lt (P1 = (P1 < 0)) -** OP_Le (P1 = (P1 <= 0)) -** OP_Gt (P1 = (P1 > 0)) -** OP_Ge (P1 = (P1 >= 0)) -*/ -case OP_CmpTest: { /* in1, jump */ - int bJump; - pIn1 = &aMem[pOp->p1]; - - if( pOp->p3 ){ - bJump = 0; - if( pIn1->flags & MEM_Null ){ - memAboutToChange(p, &aMem[pOp->p3]); - MemSetTypeFlag(&aMem[pOp->p3], MEM_Null); - }else if( pIn1->u.i!=0 ){ - memAboutToChange(p, &aMem[pOp->p3]); - MemSetTypeFlag(&aMem[pOp->p3], MEM_Int); - aMem[pOp->p3].u.i = pOp->p4.i; - bJump = 1; - } - }else{ - if( (pIn1->flags & MEM_Int) ){ - bJump = (pIn1->u.i!=0); - switch( pOp->p4.i ){ - case OP_Lt: pIn1->u.i = (pIn1->u.i < 0); break; - case OP_Le: pIn1->u.i = (pIn1->u.i <= 0); break; - case OP_Gt: pIn1->u.i = (pIn1->u.i > 0); break; - default: - assert( pOp->p4.i==OP_Ge ); - pIn1->u.i = (pIn1->u.i >= 0); - break; - } - }else{ - bJump = 1; - } - } - - if( bJump ) goto jump_to_p2; - break; -} - /* Opcode: Found P1 P2 P3 P4 * ** Synopsis: key=r[P3@P4] ** ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If ** P4>0 then register P3 is the first of P4 registers that form an unpacked Index: test/rowvalue2.test ================================================================== --- test/rowvalue2.test +++ test/rowvalue2.test @@ -247,6 +247,5 @@ } } finish_test -