-C Add\sthe\s"#/value-list/"\sstyle\sof\sresults\sfor\sapproximate\svalue\smatching\nin\sthe\sdo_test\scommand\sof\sthe\stest\sinfrastructure.\s\sUse\sthis\snew\sresult\sstyle\nto\smake\sthe\sSQLITE_DBSTATUS_CACHE_SIZE_SHARED\stests\scross-platform.
-D 2016-07-09T17:47:01.013
+C Add\ssome\ssupport\sfor\susing\srow\svalue\sconstructors\sin\scertain\sparts\sof\sSQL\sexpressions.\sThere\sare\smany\sbugs\son\sthis\sbranch.
+D 2016-07-09T20:23:55.716
F Makefile.in 6c20d44f72d4564f11652b26291a214c8367e5db
F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
F Makefile.msc d66d0395c38571aab3804f8db0fa20707ae4609a
F src/date.c 1cc9fb516ec9932c6fd4d2a0d2f8bc4480145c39
F src/dbstat.c 4f6f7f52b49beb9636ffbd517cfe44a402ba4ad0
F src/delete.c 4aba4214a377ce8ddde2d2e609777bcc8235200f
-F src/expr.c 523a5b1db2b6d88c6eefb224877bf635a3bcfc92
+F src/expr.c 330854fe9fdea1d244abaef6d680f6b91df07cb4
F src/fault.c 160a0c015b6c2629d3899ed2daf63d75754a32bb
F src/fkey.c bc4145347595b7770f9a598cff1c848302cf5413
F src/func.c 61a4114cf7004f10c542cfabbab9f2bcb9033045
F src/os_win.h 7b073010f1451abe501be30d12f6bc599824944a
F src/pager.c c368634b888b1c8740aea83b36bfd266f2443e60
F src/pager.h 031a87445e5e0afc85312d1c380e123ad6c7aeaf
-F src/parse.y f374ab20106362eb3f5c01b3e6a002f0bbead7ff
+F src/parse.y fa040d742fe4922b219143fe2e04f74061daabcb
F src/pcache.c 5583c8ade4b05075a60ba953ef471d1c1a9c05df
F src/pcache.h 2cedcd8407eb23017d92790b112186886e179490
F src/pcache1.c 7f51d2b541aab57596adf62db2c4bb025d34f04d
F src/prepare.c 22df6171aec1d86904ed2ad30c2348a5748aa04e
F src/printf.c a5f0ca08ddede803c241266abb46356ec748ded1
F src/random.c ba2679f80ec82c4190062d756f22d0c358180696
-F src/resolve.c cca3aa77b95706df5d635a2141a4d1de60ae6598
+F src/resolve.c 9680caadd54772699e5a0a8ebd680e014703e4ee
F src/rowset.c 7b7e7e479212e65b723bf40128c7b36dc5afdfac
-F src/select.c f3c6e9065fb34f6a23af27ec7f1f717ffbfc2ee4
+F src/select.c 0115f5d222f5cf9b5511ec4072088417354d738a
F src/shell.c 14ff7f660530a52b117d110ba3390b7b2eb719b6
F src/sqlite.h.in b9ba728c1083b7a8ab5f6a628b25cd2a00325fbf
F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
F src/sqlite3ext.h 2a170163d121095c6ab1ef05ed0413722f391d01
-F src/sqliteInt.h dcf43b8abc5605b70f54ba80f42b6ad054b8ba95
+F src/sqliteInt.h dd2dd1d880ffd33137d20dc6da21f169836b8f5a
F src/sqliteLimit.h c0373387c287c8d0932510b5547ecde31b5da247
F src/status.c 5b18f9526900f61189ab0b83f1ef41d9f871a2ab
F src/table.c 5226df15ab9179b9ed558d89575ea0ce37b03fc9
F src/utf.c 699001c79f28e48e9bcdf8a463da029ea660540c
F src/util.c 810ec3f22e2d1b62e66c30fe3621ebdedd23584d
F src/vacuum.c feb1eabb20987983d9350cad98299b21fa811f52
-F src/vdbe.c 22b46c3b725e950e9f2760e2d76953d592600ad4
+F src/vdbe.c 680c118a20b4b496644001e7ff4819c3e3ff8d85
F src/vdbe.h 67bc551f7faf04c33493892e4b378aada823ed10
F src/vdbeInt.h c59381049af5c7751a83456c39b80d1a6fde1f9d
F src/vdbeapi.c 02bcbc2ca5d2004b029088b05b468b394881e103
F src/wal.c 02eeecc265f6ffd0597378f5d8ae9070b62a406a
F src/wal.h 6dd221ed384afdc204bc61e25c23ef7fd5a511f2
F src/walker.c 0f142b5bd3ed2041fc52d773880748b212e63354
-F src/where.c 48eed8ebe319c6cbc7bf7682018f32af0f5189f5
-F src/whereInt.h e5b939701a7ceffc5a3a8188a37f9746416ebcd0
-F src/wherecode.c e20cb381ff621e56a4684c71e31999aca2547ca6
-F src/whereexpr.c d7dcbf14ce1b5876c1f76496162c30fcba669563
+F src/where.c 898a45969bae1298cbaaaf05e6aeacfb45971293
+F src/whereInt.h 1ad3be2a43cb821418e1100476a3a14cd57635c4
+F src/wherecode.c a66c589bdcaa9da45d9576d54663666083e0c109
+F src/whereexpr.c d88ee6ce356cb9fd986d0e81249a2cd66a513093
F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
F test/affinity2.test a6d901b436328bd67a79b41bb0ac2663918fe3bd
F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
F test/rowallock.test 3f88ec6819489d0b2341c7a7528ae17c053ab7cc
F test/rowhash.test 0bc1d31415e4575d10cacf31e1a66b5cc0f8be81
F test/rowid.test 5b7509f384f4f6fae1af3c8c104c8ca299fea18d
+F test/rowvalue.test 979738b3d49f1d93e3fee56a71d4446217917abc
+F test/rowvalue2.test 8d5dfe75b8f4d1868a2f91f0356f20d36cba64ff
F test/rtree.test 0c8d9dd458d6824e59683c19ab2ffa9ef946f798
F test/run-wordcount.sh 891e89c4c2d16e629cd45951d4ed899ad12afc09
F test/savepoint.test c671fdbd34cd3bfe1518a777526ada595180cf8d
F tool/GetFile.cs a15e08acb5dd7539b75ba23501581d7c2b462cb5
F tool/GetTclKit.bat 629d87562e0487c386db630033931d12d62e6372
F tool/Replace.cs 02c67258801c2fb5f63231e0ac0f220b4b36ba91
-F tool/addopcodes.tcl 2b089684eb8b7d0db64cf9d8e6d2fe1b6d279e8d
+F tool/addopcodes.tcl 7d4954564d7d4bfde5ba139ebced25542696fa52
F tool/build-all-msvc.bat 3e4e4043b53f1aede4308e0d2567bbd773614630 x
F tool/build-shell.sh 950f47c6174f1eea171319438b93ba67ff5bf367
F tool/cg_anno.tcl 692ce4b8693d59e3a3de77ca97f4139ecfa641b0 x
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 29fb988f1afc3fe623097acee1a5d08bf8386626
-R 767a7d8abd9b9525d1b45069b4c3dba2
-U drh
-Z df36acb2648e26f22b53c52b73476f6c
+P c869bf34a8ee42ac6542862e59c7a4b89b042f79
+R e70f91ca2d7d2c655198f54d385cd62e
+T *branch * rowvalue
+T *sym-rowvalue *
+T -sym-trunk *
+U dan
+Z e86f169a98e6cbe5718a428ba6e6f5e0
-c869bf34a8ee42ac6542862e59c7a4b89b042f79
\ No newline at end of file
+b2204215b231202aef7a218411cc2ddaecf28f35
\ No newline at end of file
return addr;
}
+int sqlite3ExprVectorSize(Expr *pExpr){
+ if( (pExpr->flags & EP_Vector)==0 ) return 1;
+ if( pExpr->flags & EP_xIsSelect ){
+ return pExpr->x.pSelect->pEList->nExpr;
+ }
+ return pExpr->x.pList->nExpr;
+}
+
+static Expr *exprVectorField(Expr *pVector, int i){
+ if( pVector->flags & EP_xIsSelect ){
+ return pVector->x.pSelect->pEList->a[i].pExpr;
+ }
+ return pVector->x.pList->a[i].pExpr;
+}
+
+static void codeVectorCompare(Parse *pParse, Expr *pExpr, int dest){
+ 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 opCmp;
+ int opTest;
+ int i;
+ int p3 = 1;
+ int regLeft = 0;
+ int regRight = 0;
+
+ 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
+ );
+
+ switch( pExpr->op ){
+ case TK_EQ:
+ case TK_IS:
+ opTest = OP_IfNot;
+ opCmp = OP_Eq;
+ break;
+
+ case TK_NE:
+ case TK_ISNOT:
+ opTest = OP_If;
+ opCmp = OP_Ne;
+ break;
+
+ case TK_LT:
+ case TK_LE:
+ case TK_GT:
+ case TK_GE:
+ opCmp = OP_Cmp;
+ opTest = OP_CmpTest;
+ p3 = pExpr->op;
+ break;
+ }
+
+ if( pLeft->flags & EP_xIsSelect ){
+ assert( pLeft->op==TK_SELECT || pLeft->op==TK_REGISTER );
+ regLeft = sqlite3ExprCodeTarget(pParse, pLeft, 1);
+ assert( regLeft!=1 );
+ }
+ if( pRight->flags & EP_xIsSelect ){
+ assert( pRight->op==TK_SELECT || pRight->op==TK_REGISTER );
+ regRight = sqlite3ExprCodeTarget(pParse, pRight, 1);
+ assert( regRight!=1 );
+ }
+ if( pParse->nErr ) return;
+
+ for(i=0; i<nLeft; i++){
+ int regFree1 = 0, regFree2 = 0;
+ Expr *pL, *pR;
+ int r1, r2;
+
+ if( regLeft ){
+ pL = pLeft->x.pSelect->pEList->a[i].pExpr;
+ r1 = regLeft+i;
+ }else{
+ pL = pLeft->x.pList->a[i].pExpr;
+ r1 = sqlite3ExprCodeTemp(pParse, pL, ®Free1);
+ }
+
+ if( regRight ){
+ pR = pRight->x.pSelect->pEList->a[i].pExpr;
+ r2 = regRight+i;
+ }else{
+ pR = pRight->x.pList->a[i].pExpr;
+ r2 = sqlite3ExprCodeTemp(pParse, pR, ®Free1);
+ }
+
+ codeCompare(pParse, pL, pR, opCmp, r1, r2, dest, SQLITE_STOREP2 | p5);
+ sqlite3VdbeAddOp3(v, opTest, dest, addr, p3);
+ sqlite3ReleaseTempReg(pParse, regFree1);
+ sqlite3ReleaseTempReg(pParse, regFree2);
+ }
+ }
+
+ sqlite3VdbeResolveLabel(v, addr);
+}
+
#if SQLITE_MAX_EXPR_DEPTH>0
/*
** Check that argument nHeight is less than or equal to the maximum
if( !ExprHasProperty(p, EP_TokenOnly) ){
/* The Expr.x union is never used at the same time as Expr.pRight */
assert( p->x.pList==0 || p->pRight==0 );
- sqlite3ExprDelete(db, p->pLeft);
+ if( p->op!=TK_SELECT_COLUMN ) sqlite3ExprDelete(db, p->pLeft);
sqlite3ExprDelete(db, p->pRight);
if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
if( ExprHasProperty(p, EP_xIsSelect) ){
/* If no preexisting index is available for the IN clause
** and IN_INDEX_NOOP is an allowed reply
** and the RHS of the IN operator is a list, not a subquery
- ** and the RHS is not contant or has two or fewer terms,
+ ** and the RHS is not constant or has two or fewer terms,
** then it is not worth creating an ephemeral table to evaluate
** the IN operator so return IN_INDEX_NOOP.
*/
}
#endif
+static char *exprINAffinity(Parse *pParse, Expr *pExpr){
+ Expr *pLeft = pExpr->pLeft;
+ int nVal = sqlite3ExprVectorSize(pLeft);
+ char *zRet;
+
+ zRet = sqlite3DbMallocZero(pParse->db, nVal+1);
+ if( zRet ){
+ int i;
+ for(i=0; i<nVal; i++){
+ Expr *pA;
+ char a;
+ if( nVal==1 ){
+ pA = pLeft;
+ }else{
+ pA = exprVectorField(pLeft, i);
+ }
+ a = sqlite3ExprAffinity(pA);
+ zRet[i] = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[i].pExpr, a);
+ }
+ zRet[nVal] = '\0';
+ }
+ return zRet;
+}
+
/*
** Generate code for scalar subqueries used as a subquery expression, EXISTS,
** or IN operators. Examples:
switch( pExpr->op ){
case TK_IN: {
- char affinity; /* Affinity of the LHS of the IN */
int addr; /* Address of OP_OpenEphemeral instruction */
Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
KeyInfo *pKeyInfo = 0; /* Key information */
-
- affinity = sqlite3ExprAffinity(pLeft);
+ int nVal; /* Size of vector pLeft */
+
+ nVal = sqlite3ExprVectorSize(pLeft);
/* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
** expression it is handled the same way. An ephemeral table is
** is used.
*/
pExpr->iTable = pParse->nTab++;
- addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
- pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, 1, 1);
+ addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral,
+ pExpr->iTable, (isRowid?0:nVal));
+ pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
if( ExprHasProperty(pExpr, EP_xIsSelect) ){
/* Case 1: expr IN (SELECT ...)
** table allocated and opened above.
*/
Select *pSelect = pExpr->x.pSelect;
- SelectDest dest;
- ExprList *pEList;
+ ExprList *pEList = pSelect->pEList;
assert( !isRowid );
- sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
- dest.affSdst = (u8)affinity;
- assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
- pSelect->iLimit = 0;
- testcase( pSelect->selFlags & SF_Distinct );
- testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
- if( sqlite3Select(pParse, pSelect, &dest) ){
- sqlite3KeyInfoUnref(pKeyInfo);
- return 0;
+ if( pEList->nExpr!=nVal ){
+ sqlite3ErrorMsg(pParse, "SELECT has %d columns - expected %d",
+ pEList->nExpr, nVal);
+ }else{
+ SelectDest dest;
+ int i;
+ sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
+ dest.zAffSdst = exprINAffinity(pParse, pExpr);
+ assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
+ pSelect->iLimit = 0;
+ testcase( pSelect->selFlags & SF_Distinct );
+ testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
+ if( sqlite3Select(pParse, pSelect, &dest) ){
+ sqlite3DbFree(pParse->db, dest.zAffSdst);
+ sqlite3KeyInfoUnref(pKeyInfo);
+ return 0;
+ }
+ sqlite3DbFree(pParse->db, dest.zAffSdst);
+ assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
+ assert( pEList!=0 );
+ assert( pEList->nExpr>0 );
+ assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
+ for(i=0; i<nVal; i++){
+ Expr *p = (nVal>1) ? exprVectorField(pLeft, i) : pLeft;
+ pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
+ pParse, p, pEList->a[i].pExpr
+ );
+ }
}
- pEList = pSelect->pEList;
- assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
- assert( pEList!=0 );
- assert( pEList->nExpr>0 );
- assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
- pKeyInfo->aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
- pEList->a[0].pExpr);
}else if( ALWAYS(pExpr->x.pList!=0) ){
/* Case 2: expr IN (exprlist)
**
** that columns affinity when building index keys. If <expr> is not
** a column, use numeric affinity.
*/
+ char affinity; /* Affinity of the LHS of the IN */
int i;
ExprList *pList = pExpr->x.pList;
struct ExprList_item *pItem;
int r1, r2, r3;
+ affinity = sqlite3ExprAffinity(pLeft);
if( !affinity ){
affinity = SQLITE_AFF_BLOB;
}
*/
Select *pSel; /* SELECT statement to encode */
SelectDest dest; /* How to deal with SELECt result */
+ int nReg; /* Registers to allocate */
testcase( pExpr->op==TK_EXISTS );
testcase( pExpr->op==TK_SELECT );
assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
-
assert( ExprHasProperty(pExpr, EP_xIsSelect) );
+
pSel = pExpr->x.pSelect;
- sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
+ nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
+ sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
+ pParse->nMem += nReg;
if( pExpr->op==TK_SELECT ){
dest.eDest = SRT_Mem;
dest.iSdst = dest.iSDParm;
- sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iSDParm);
+ dest.nSdst = nReg;
+ sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
VdbeComment((v, "Init subquery result"));
}else{
dest.eDest = SRT_Exists;
}
#endif /* SQLITE_OMIT_SUBQUERY */
+#ifndef SQLITE_OMIT_SUBQUERY
+void exprCodeVectorIN(
+ Parse *pParse, /* Parsing and code generating context */
+ Expr *pExpr, /* The IN expression */
+ int destIfFalse, /* Jump here if LHS is not contained in the RHS */
+ int destIfNull /* Jump here if the results are unknown due to NULLs */
+){
+ int i;
+ int addrNext;
+ int iSkip;
+ int r1;
+ int r2 = sqlite3GetTempReg(pParse);
+ int r3 = sqlite3GetTempReg(pParse);
+ int r4 = sqlite3GetTempReg(pParse);
+ int regResult = sqlite3GetTempReg(pParse);
+ int nVal = sqlite3ExprVectorSize(pExpr->pLeft);
+
+ Expr *pLeft = pExpr->pLeft;
+ Vdbe *v = pParse->pVdbe;
+
+ /* Code the LHS, the <expr> from "<expr> IN (...)". Leave the results in
+ ** an array of nVal registers starting at r1. */
+ sqlite3ExprCachePush(pParse);
+ if( pLeft->flags & EP_xIsSelect ){
+ r1 = sqlite3CodeSubselect(pParse, pLeft, 0, 0);
+ }else{
+ r1 = pParse->nMem + 1;
+ pParse->nMem += nVal;
+ sqlite3ExprCodeExprList(pParse, pLeft->x.pList, r1, 0, 0);
+ }
+
+ /* Generate an epheremal index containing the contents of the SELECT
+ ** to the right of the "<expr> IN (SELECT ...)" expression. The cursor
+ ** number for the epheremal table is left in pExpr->iTable. */
+ assert( pExpr->flags & EP_xIsSelect );
+ sqlite3CodeSubselect(pParse, pExpr, 0, 0);
+
+ sqlite3VdbeAddOp2(v, OP_Integer, 0, regResult);
+
+ /* Iterate through the ephemeral table just populated */
+ addrNext = 1 + sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
+ for(i=0; i<nVal; i++){
+ Expr *p;
+ CollSeq *pColl;
+ p = exprVectorField(pLeft, i);
+ pColl = sqlite3ExprCollSeq(pParse, p);
+ sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, i, r2);
+ sqlite3VdbeAddOp4(v, OP_Eq, r1+i, i==0?r3:r4, r2, (void*)pColl,P4_COLLSEQ);
+ sqlite3VdbeChangeP5(v, SQLITE_STOREP2);
+ VdbeCoverage(v);
+ if( i!=0 ){
+ sqlite3VdbeAddOp3(v, OP_And, r3, r4, r4);
+ }
+ }
+ sqlite3VdbeAddOp2(v, OP_If, r4, sqlite3VdbeCurrentAddr(v)+6);
+ sqlite3VdbeAddOp2(v, OP_IfNot, r4, sqlite3VdbeCurrentAddr(v)+2);
+ sqlite3VdbeAddOp2(v, OP_Null, 0, regResult);
+ sqlite3VdbeAddOp2(v, OP_Next, pExpr->iTable, addrNext);
+ sqlite3VdbeAddOp3(v, OP_If, regResult, destIfNull, 1);
+ sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
+
+ sqlite3ReleaseTempReg(pParse, r2);
+ sqlite3ReleaseTempReg(pParse, r3);
+ sqlite3ReleaseTempReg(pParse, r4);
+ sqlite3ReleaseTempReg(pParse, regResult);
+ sqlite3ExprCachePop(pParse);
+}
+#endif
+
#ifndef SQLITE_OMIT_SUBQUERY
/*
** Generate code for an IN expression.
int r1; /* Temporary use register */
Vdbe *v; /* Statement under construction */
+ if( pExpr->pLeft->flags & EP_Vector ){
+ return exprCodeVectorIN(pParse, pExpr, destIfFalse, destIfNull);
+ }
+
/* Compute the RHS. After this step, the table with cursor
** pExpr->iTable will contains the values that make up the RHS.
*/
ExprClearProperty(p, EP_Skip);
}
+static void exprCodeBetween(Parse*,Expr*,int,void(*)(Parse*,Expr*,int,int),int);
+
/*
** Generate code into the current Vdbe to evaluate the given
** expression. Attempt to store the results in register "target".
int r1, r2, r3, r4; /* Various register numbers */
sqlite3 *db = pParse->db; /* The database connection */
Expr tempX; /* Temporary expression node */
+ int p5 = 0;
assert( target>0 && target<=pParse->nMem );
if( v==0 ){
break;
}
#endif /* SQLITE_OMIT_CAST */
+ case TK_IS:
+ case TK_ISNOT:
+ op = (op==TK_IS) ? TK_EQ : TK_NE;
+ p5 = SQLITE_NULLEQ;
+ /* fall-through */
case TK_LT:
case TK_LE:
case TK_GT:
case TK_GE:
case TK_NE:
case TK_EQ: {
- r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
- r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
- codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
- r1, r2, inReg, SQLITE_STOREP2);
- assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
- assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
- assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
- assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
- assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
- assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
- testcase( regFree1==0 );
- testcase( regFree2==0 );
- break;
- }
- case TK_IS:
- case TK_ISNOT: {
- testcase( op==TK_IS );
- testcase( op==TK_ISNOT );
- r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
- r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
- op = (op==TK_IS) ? TK_EQ : TK_NE;
- codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
- r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
- VdbeCoverageIf(v, op==TK_EQ);
- VdbeCoverageIf(v, op==TK_NE);
- testcase( regFree1==0 );
- testcase( regFree2==0 );
+ Expr *pLeft = pExpr->pLeft;
+ if( (pLeft->flags & EP_Vector) ){
+ codeVectorCompare(pParse, pExpr, target);
+ }else{
+ r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1);
+ r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
+ codeCompare(pParse, pLeft, pExpr->pRight, op,
+ r1, r2, inReg, SQLITE_STOREP2 | p5);
+ assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
+ assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
+ assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
+ assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
+ assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
+ assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
+ testcase( regFree1==0 );
+ testcase( regFree2==0 );
+ }
break;
}
case TK_AND:
** Z is stored in pExpr->pList->a[1].pExpr.
*/
case TK_BETWEEN: {
+ exprCodeBetween(pParse, pExpr, target, 0, 0);
+#if 0
Expr *pLeft = pExpr->pLeft;
struct ExprList_item *pLItem = pExpr->x.pList->a;
Expr *pRight = pLItem->pExpr;
sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
sqlite3ReleaseTempReg(pParse, r3);
sqlite3ReleaseTempReg(pParse, r4);
+#endif
break;
}
case TK_SPAN:
break;
}
+ case TK_VECTOR: {
+ sqlite3ErrorMsg(pParse, "invalid use of row value (1)");
+ break;
+ }
+
+ case TK_SELECT_COLUMN: {
+ Expr *pLeft = pExpr->pLeft;
+ assert( pLeft );
+ assert( pLeft->op==TK_SELECT || pLeft->op==TK_REGISTER );
+ if( pLeft->op==TK_SELECT ){
+ pLeft->iTable = sqlite3CodeSubselect(pParse, pLeft, 0, 0);
+ pLeft->op = TK_REGISTER;
+ }
+ inReg = pLeft->iTable + pExpr->iColumn;
+ break;
+ }
/*
** Form A:
Parse *pParse, /* Parsing and code generating context */
Expr *pExpr, /* The BETWEEN expression */
int dest, /* Jump here if the jump is taken */
- int jumpIfTrue, /* Take the jump if the BETWEEN is true */
+ void (*xJumpIf)(Parse*,Expr*,int,int),
int jumpIfNull /* Take the jump if the BETWEEN is NULL */
){
Expr exprAnd; /* The AND operator in x>=y AND x<=z */
Expr exprX; /* The x subexpression */
int regFree1 = 0; /* Temporary use register */
+ memset(&compLeft, 0, sizeof(Expr));
+ memset(&compRight, 0, sizeof(Expr));
+ memset(&exprAnd, 0, sizeof(Expr));
+
assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
exprX = *pExpr->pLeft;
exprAnd.op = TK_AND;
compRight.op = TK_LE;
compRight.pLeft = &exprX;
compRight.pRight = pExpr->x.pList->a[1].pExpr;
- exprToRegister(&exprX, sqlite3ExprCodeTemp(pParse, &exprX, ®Free1));
- if( jumpIfTrue ){
- sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
+ if( (exprX.flags & EP_Vector)==0 ){
+ exprToRegister(&exprX, sqlite3ExprCodeTemp(pParse, &exprX, ®Free1));
+ }
+ if( xJumpIf ){
+ xJumpIf(pParse, &exprAnd, dest, jumpIfNull);
}else{
- sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
+ exprX.flags |= EP_FromJoin;
+ sqlite3ExprCodeTarget(pParse, &exprAnd, dest);
}
sqlite3ReleaseTempReg(pParse, regFree1);
if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */
if( NEVER(pExpr==0) ) return; /* No way this can happen */
op = pExpr->op;
- switch( op ){
+ switch( op | (pExpr->pLeft ? (pExpr->pLeft->flags & EP_Vector) : 0)){
case TK_AND: {
int d2 = sqlite3VdbeMakeLabel(v);
testcase( jumpIfNull==0 );
}
case TK_BETWEEN: {
testcase( jumpIfNull==0 );
- exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
+ exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
break;
}
#ifndef SQLITE_OMIT_SUBQUERY
assert( pExpr->op!=TK_GT || op==OP_Le );
assert( pExpr->op!=TK_GE || op==OP_Lt );
- switch( pExpr->op ){
+ switch( pExpr->op | (pExpr->pLeft ? (pExpr->pLeft->flags & EP_Vector) : 0)){
case TK_AND: {
testcase( jumpIfNull==0 );
sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
}
case TK_BETWEEN: {
testcase( jumpIfNull==0 );
- exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
+ exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
break;
}
#ifndef SQLITE_OMIT_SUBQUERY
%left CONCAT.
%left COLLATE.
%right BITNOT.
+%right VECTOR.
// An IDENTIFIER can be a generic identifier, or one of several
// keywords. Any non-standard keyword can also be an identifier.
}
}
+expr(A) ::= LP(L) nexprlist(X) COMMA expr(Y) RP(R). {
+ A.pExpr = sqlite3PExpr(pParse, TK_VECTOR, 0, 0, 0);
+ if( A.pExpr ){
+ A.pExpr->x.pList = sqlite3ExprListAppend(pParse, X, Y.pExpr);
+ spanSet(&A, &L, &R);
+ }
+}
+
expr(A) ::= expr(A) AND(OP) expr(Y). {spanBinaryExpr(pParse,@OP,&A,&Y);}
expr(A) ::= expr(A) OR(OP) expr(Y). {spanBinaryExpr(pParse,@OP,&A,&Y);}
expr(A) ::= expr(A) LT|GT|GE|LE(OP) expr(Y).
ExprSetProperty(pExpr, EP_VarSelect);
pNC->ncFlags |= NC_VarSelect;
}
+
+ if( pExpr->op==TK_SELECT && pExpr->x.pSelect->pEList->nExpr>1 ){
+ if( !ExprHasProperty(pExpr, EP_VectorOk) ){
+ sqlite3ErrorMsg(pParse, "invalid use of row value");
+ }else{
+ ExprSetProperty(pExpr, EP_Vector);
+ }
+ }
+ if( pExpr->op==TK_IN ){
+ ExprSetProperty(pExpr->pLeft, EP_VectorOk);
+ }
}
break;
}
notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
break;
}
+
+ case TK_BETWEEN: {
+ ExprSetProperty(pExpr->pLeft, EP_VectorOk);
+ ExprSetProperty(pExpr->x.pList->a[0].pExpr, EP_VectorOk);
+ ExprSetProperty(pExpr->x.pList->a[1].pExpr, EP_VectorOk);
+ break;
+ }
+
+ case TK_EQ: case TK_NE: case TK_IS: case TK_ISNOT:
+ case TK_LE: case TK_LT: case TK_GE: case TK_GT:
+ {
+ ExprSetProperty(pExpr->pLeft, EP_VectorOk);
+ ExprSetProperty(pExpr->pRight, EP_VectorOk);
+ break;
+ };
+
+ case TK_VECTOR: {
+ if( !ExprHasProperty(pExpr, EP_VectorOk) ){
+ sqlite3ErrorMsg(pParse, "invalid use of row value");
+ }else{
+ ExprSetProperty(pExpr, EP_Vector);
+ }
+ break;
+ }
}
return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
}
void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
pDest->eDest = (u8)eDest;
pDest->iSDParm = iParm;
- pDest->affSdst = 0;
+ pDest->zAffSdst = 0;
pDest->iSdst = 0;
pDest->nSdst = 0;
}
int nExpr /* Number of result columns returned by SELECT */
){
int eDest = pDest->eDest;
- if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
+ if( 0 && nExpr>1 && eDest==SRT_Set ){
sqlite3ErrorMsg(pParse, "only a single result allowed for "
"a SELECT that is part of an expression");
return 1;
** item into the set table with bogus data.
*/
case SRT_Set: {
- assert( nResultCol==1 );
- pDest->affSdst =
- sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affSdst);
if( pSort ){
/* At first glance you would think we could optimize out the
** ORDER BY in this case since the order of entries in the set
pushOntoSorter(pParse, pSort, p, regResult, regResult, 1, nPrefixReg);
}else{
int r1 = sqlite3GetTempReg(pParse);
- sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult,1,r1, &pDest->affSdst, 1);
- sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
+ assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
+ sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
+ r1, pDest->zAffSdst, 1);
+ sqlite3ExprCacheAffinityChange(pParse, regResult, nResultCol);
sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
sqlite3ReleaseTempReg(pParse, r1);
}
** of the scan loop.
*/
case SRT_Mem: {
- assert( nResultCol==1 );
+ assert( nResultCol==pDest->nSdst );
if( pSort ){
- pushOntoSorter(pParse, pSort, p, regResult, regResult, 1, nPrefixReg);
+ pushOntoSorter(pParse, pSort, p, regResult, regResult, nResultCol, nPrefixReg);
}else{
assert( regResult==iParm );
/* The LIMIT clause will jump out of the loop for us */
sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
}
iTab = pSort->iECursor;
- if( eDest==SRT_Output || eDest==SRT_Coroutine ){
+ if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){
regRowid = 0;
regRow = pDest->iSdst;
nSortData = nColumn;
}
#ifndef SQLITE_OMIT_SUBQUERY
case SRT_Set: {
- assert( nColumn==1 );
- sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid,
- &pDest->affSdst, 1);
- sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
+ assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
+ sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
+ pDest->zAffSdst, 1);
+ sqlite3ExprCacheAffinityChange(pParse, regRow, nColumn);
sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
break;
}
case SRT_Mem: {
- assert( nColumn==1 );
- sqlite3ExprCodeMove(pParse, regRow, iParm, 1);
+ /* sqlite3ExprCodeMove(pParse, regRow, iParm, nColumn); */
/* The LIMIT clause will terminate the loop for us */
break;
}
case SRT_Set: {
int r1;
assert( pIn->nSdst==1 || pParse->nErr>0 );
- pDest->affSdst =
- sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affSdst);
r1 = sqlite3GetTempReg(pParse);
- sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, 1, r1, &pDest->affSdst,1);
+ sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
+ r1, pDest->zAffSdst,1);
sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, 1);
sqlite3VdbeAddOp2(v, OP_IdxInsert, pDest->iSDParm, r1);
sqlite3ReleaseTempReg(pParse, r1);
#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
#define EP_Alias 0x400000 /* Is an alias for a result set column */
+#define EP_VectorOk 0x800000 /* This expression may be a row value */
+#define EP_Vector 0x1000000/* This expression is a row value */
/*
** Combinations of two or more EP_* flags
*/
struct SelectDest {
u8 eDest; /* How to dispose of the results. On of SRT_* above. */
- char affSdst; /* Affinity used when eDest==SRT_Set */
+ char *zAffSdst; /* Affinity used when eDest==SRT_Set */
int iSDParm; /* A parameter used by the eDest disposal method */
int iSdst; /* Base register where results are written */
int nSdst; /* Number of registers allocated */
int sqlite3DbstatRegister(sqlite3*);
#endif
+int sqlite3ExprVectorSize(Expr *pExpr);
+
#endif /* SQLITEINT_H */
** the content of register P3 is greater than or equal to the content of
** register P1. See the Lt opcode for additional information.
*/
+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_Lt: res = res<0; break;
case OP_Le: res = res<=0; break;
case OP_Gt: res = res>0; break;
- default: res = res>=0; break;
+ case OP_Ge: res = res>=0; break;
+ default: assert( pOp->opcode==OP_Cmp ); break;
}
/* Undo any changes made by applyAffinity() to the input registers. */
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: CmpTest P1 P2 P3 * *
+**
+** P2 is a jump destination. Register P1 is guaranteed to contain either
+** an integer value or a NULL. The jump is taken if P1 contains any value
+** other than 0 (i.e. NULL does cause a jump).
+**
+** If P1 is not NULL, its value is modified to integer value 0 or 1
+** according to the value of the P3 operand:
+**
+** P3 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( (pIn1->flags & MEM_Int) ){
+ bJump = (pIn1->u.i!=0);
+ switch( pOp->p3 ){
+ 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->p3==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( pLoop->nOut > nRow-iReduce ) pLoop->nOut = nRow - iReduce;
}
+/*
+** Term pTerm is a vector range comparison operation. The first comparison
+** in the vector can be optimized using column nEq of the index.
+*/
+int whereRangeVectorLen(
+ Parse *pParse, int iCur, Index *pIdx, int nEq, WhereTerm *pTerm
+){
+ int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
+ int i;
+
+ nCmp = MIN(nCmp, (pIdx->nColumn - nEq));
+ for(i=1; i<nCmp; i++){
+ /* Test if comparison i of pTerm is compatible with column (i+nEq)
+ ** of the index. If not, exit the loop. */
+ char aff; /* Comparison affinity */
+ char idxaff = 0; /* Indexed columns affinity */
+ CollSeq *pColl; /* Comparison collation sequence */
+ Expr *pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
+ Expr *pRhs = pTerm->pExpr->pRight;
+ if( pRhs->flags & EP_xIsSelect ){
+ pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
+ }else{
+ pRhs = pRhs->x.pList->a[i].pExpr;
+ }
+
+ /* Check that the LHS of the comparison is a column reference to
+ ** the right column of the right source table.
+ */
+ if( pLhs->op!=TK_COLUMN
+ || pLhs->iTable!=iCur
+ || pLhs->iColumn!=pIdx->aiColumn[i+nEq]
+ ){
+ break;
+ }
+
+ aff = sqlite3CompareAffinity(pRhs, sqlite3ExprAffinity(pLhs));
+ idxaff = pIdx->pTable->aCol[pLhs->iColumn].affinity;
+ if( aff!=idxaff ) break;
+
+ pColl = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
+ if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
+ }
+ return i;
+}
+
/*
** Adjust the cost C by the costMult facter T. This only occurs if
** compiled with -DSQLITE_ENABLE_COSTMULT
Bitmask saved_prereq; /* Original value of pNew->prereq */
u16 saved_nLTerm; /* Original value of pNew->nLTerm */
u16 saved_nEq; /* Original value of pNew->u.btree.nEq */
+ u16 saved_nBtm; /* Original value of pNew->u.btree.nBtm */
+ u16 saved_nTop; /* Original value of pNew->u.btree.nTop */
u16 saved_nSkip; /* Original value of pNew->nSkip */
u32 saved_wsFlags; /* Original value of pNew->wsFlags */
LogEst saved_nOut; /* Original value of pNew->nOut */
if( pNew->wsFlags & WHERE_BTM_LIMIT ){
opMask = WO_LT|WO_LE;
}else{
+ assert( pNew->u.btree.nBtm==0 );
opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE|WO_ISNULL|WO_IS;
}
if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE);
assert( pNew->u.btree.nEq<pProbe->nColumn );
saved_nEq = pNew->u.btree.nEq;
+ saved_nBtm = pNew->u.btree.nBtm;
+ saved_nTop = pNew->u.btree.nTop;
saved_nSkip = pNew->nSkip;
saved_nLTerm = pNew->nLTerm;
saved_wsFlags = pNew->wsFlags;
pNew->wsFlags = saved_wsFlags;
pNew->u.btree.nEq = saved_nEq;
+ pNew->u.btree.nBtm = saved_nBtm;
+ pNew->u.btree.nTop = saved_nTop;
pNew->nLTerm = saved_nLTerm;
if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
pNew->aLTerm[pNew->nLTerm++] = pTerm;
testcase( eOp & WO_GT );
testcase( eOp & WO_GE );
pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT;
+ pNew->u.btree.nBtm = whereRangeVectorLen(
+ pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
+ );
pBtm = pTerm;
pTop = 0;
if( pTerm->wtFlags & TERM_LIKEOPT ){
if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
pNew->aLTerm[pNew->nLTerm++] = pTop;
pNew->wsFlags |= WHERE_TOP_LIMIT;
+ pNew->u.btree.nTop = 1;
}
}else{
assert( eOp & (WO_LT|WO_LE) );
testcase( eOp & WO_LT );
testcase( eOp & WO_LE );
pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT;
+ pNew->u.btree.nTop = whereRangeVectorLen(
+ pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
+ );
pTop = pTerm;
pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ?
pNew->aLTerm[pNew->nLTerm-2] : 0;
}
pNew->prereq = saved_prereq;
pNew->u.btree.nEq = saved_nEq;
+ pNew->u.btree.nBtm = saved_nBtm;
+ pNew->u.btree.nTop = saved_nTop;
pNew->nSkip = saved_nSkip;
pNew->wsFlags = saved_wsFlags;
pNew->nOut = saved_nOut;
/*
** Add all WhereLoop objects for a single table of the join where the table
-** is idenfied by pBuilder->pNew->iTab. That table is guaranteed to be
+** is identified by pBuilder->pNew->iTab. That table is guaranteed to be
** a b-tree table, not a virtual table.
**
** The costs (WhereLoop.rRun) of the b-tree loops added by this function
}
rSize = pProbe->aiRowLogEst[0];
pNew->u.btree.nEq = 0;
+ pNew->u.btree.nBtm = 0;
+ pNew->u.btree.nTop = 0;
pNew->nSkip = 0;
pNew->nLTerm = 0;
pNew->iSortIdx = 0;
union {
struct { /* Information for internal btree tables */
u16 nEq; /* Number of equality constraints */
+ u16 nBtm; /* Size of BTM vector */
+ u16 nTop; /* Size of TOP vector */
Index *pIndex; /* Index used, or NULL */
} btree;
struct { /* Information for virtual tables */
}
}
+static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
+ assert( nReg>0 );
+ if( p->flags & EP_Vector ){
+ int i;
+ if( (p->flags & EP_xIsSelect)==0 ){
+ ExprList *pList = p->x.pList;
+ assert( nReg<=pList->nExpr );
+ for(i=0; i<nReg; i++){
+ sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
+ }
+ }else{
+ Vdbe *v = pParse->pVdbe;
+ int iSelect = sqlite3CodeSubselect(pParse, p, 0, 0);
+ sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
+ p->op2 = p->op;
+ p->op = TK_REGISTER;
+ p->iTable = iSelect;
+ }
+ }else{
+ assert( nReg==1 );
+ sqlite3ExprCode(pParse, p, iReg);
+ }
+}
+
/*
** Generate code for the start of the iLevel-th loop in the WHERE clause
** implementation described by pWInfo.
OP_IdxLT, /* 3: (end_constraints && bRev && endEq) */
};
u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */
+ u16 nBtm = pLoop->u.btree.nBtm; /* Length of BTM vector */
+ u16 nTop = pLoop->u.btree.nTop; /* Length of TOP vector */
int regBase; /* Base register holding constraint values */
WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */
WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */
j = nEq;
if( pLoop->wsFlags & WHERE_BTM_LIMIT ){
pRangeStart = pLoop->aLTerm[j++];
- nExtraReg = 1;
+ nExtraReg = MAX(nExtraReg, pLoop->u.btree.nBtm);
/* Like optimization range constraints always occur in pairs */
assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 ||
(pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 );
}
if( pLoop->wsFlags & WHERE_TOP_LIMIT ){
pRangeEnd = pLoop->aLTerm[j++];
- nExtraReg = 1;
+ nExtraReg = MAX(nExtraReg, pLoop->u.btree.nTop);
#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){
assert( pRangeStart!=0 ); /* LIKE opt constraints */
){
SWAP(WhereTerm *, pRangeEnd, pRangeStart);
SWAP(u8, bSeekPastNull, bStopAtNull);
+ SWAP(u8, nBtm, nTop);
}
/* Generate code to evaluate all constraint terms using == or IN
nConstraint = nEq;
if( pRangeStart ){
Expr *pRight = pRangeStart->pExpr->pRight;
- sqlite3ExprCode(pParse, pRight, regBase+nEq);
+ codeExprOrVector(pParse, pRight, regBase+nEq, nBtm);
whereLikeOptimizationStringFixup(v, pLevel, pRangeStart);
if( (pRangeStart->wtFlags & TERM_VNULL)==0
&& sqlite3ExprCanBeNull(pRight)
zStartAff[nEq] = SQLITE_AFF_BLOB;
}
}
- nConstraint++;
+ nConstraint += nBtm;
testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
+ if( (pRight->flags & EP_Vector)==0 ){
+ disableTerm(pLevel, pRangeStart);
+ }else{
+ startEq = 1;
+ }
}else if( bSeekPastNull ){
sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
nConstraint++;
if( pRangeEnd ){
Expr *pRight = pRangeEnd->pExpr->pRight;
sqlite3ExprCacheRemove(pParse, regBase+nEq, 1);
- sqlite3ExprCode(pParse, pRight, regBase+nEq);
+ codeExprOrVector(pParse, pRight, regBase+nEq, nTop);
whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd);
if( (pRangeEnd->wtFlags & TERM_VNULL)==0
&& sqlite3ExprCanBeNull(pRight)
){
codeApplyAffinity(pParse, regBase+nEq, 1, &cEndAff);
}
- nConstraint++;
+ nConstraint += nTop;
testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
+
+ if( (pRight->flags & EP_Vector)==0 ){
+ disableTerm(pLevel, pRangeEnd);
+ }else{
+ endEq = 1;
+ }
}else if( bStopAtNull ){
sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
endEq = 0;
testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
}
+ /* Disable the start and end range terms if possible */
+ /* disableTerm(pLevel, pRangeStart); */
+ /* disableTerm(pLevel, pRangeEnd); */
+
/* Seek the table cursor, if required */
- disableTerm(pLevel, pRangeStart);
- disableTerm(pLevel, pRangeEnd);
if( omitTable ){
/* pIdx is a covering index. No need to access the main table. */
}else if( HasRowid(pIdx->pTable) ){
iRowidReg, pPk->nKeyCol); VdbeCoverage(v);
}
- /* Record the instruction used to terminate the loop. Disable
- ** WHERE clause terms made redundant by the index range scan.
- */
+ /* Record the instruction used to terminate the loop. */
if( pLoop->wsFlags & WHERE_ONEROW ){
pLevel->op = OP_Noop;
}else if( bRev ){
/*
** Return TRUE if the given operator is one of the operators that is
** allowed for an indexable WHERE clause term. The allowed operators are
-** "=", "<", ">", "<=", ">=", "IN", and "IS NULL"
+** "=", "<", ">", "<=", ">=", "IN", "IS", and "IS NULL"
*/
static int allowedOp(int op){
assert( TK_GT>TK_EQ && TK_GT<TK_GE );
*/
static int exprMightBeIndexed(
SrcList *pFrom, /* The FROM clause */
+ int op,
Bitmask mPrereq, /* Bitmask of FROM clause terms referenced by pExpr */
Expr *pExpr, /* An operand of a comparison operator */
int *piCur, /* Write the referenced table cursor number here */
Index *pIdx;
int i;
int iCur;
+
+ /* If this expression is a vector to the left or right of a
+ ** inequality constraint (>, <, >= or <=), perform the processing
+ ** on the first element of the vector. */
+ assert( TK_GT+1==TK_LE && TK_GT+2==TK_LT && TK_GT+3==TK_GE );
+ if( (pExpr->flags & (EP_Vector|EP_xIsSelect))==EP_Vector
+ && (op>=TK_GT && op<=TK_GE)
+ ){
+ pExpr = pExpr->x.pList->a[0].pExpr;
+ }
+
if( pExpr->op==TK_COLUMN ){
*piCur = pExpr->iTable;
*piColumn = pExpr->iColumn;
return 0;
}
+static Expr *exprVectorExpr(Parse *pParse, Expr *p, int iField){
+ Expr *pRet;
+ if( p->flags & EP_xIsSelect ){
+ pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, p, 0, 0);
+ if( pRet ) pRet->iColumn = iField;
+ }else{
+ pRet = sqlite3ExprDup(pParse->db, p->x.pList->a[iField].pExpr, 0);
+ }
+ return pRet;
+}
+
/*
** The input to this routine is an WhereTerm structure with only the
** "pExpr" field filled in. The job of this routine is to analyze the
Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
- if( exprMightBeIndexed(pSrc, prereqLeft, pLeft, &iCur, &iColumn) ){
+ if( exprMightBeIndexed(pSrc, op, prereqLeft, pLeft, &iCur, &iColumn) ){
pTerm->leftCursor = iCur;
pTerm->u.leftColumn = iColumn;
pTerm->eOperator = operatorMask(op) & opMask;
}
if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
if( pRight
- && exprMightBeIndexed(pSrc, pTerm->prereqRight, pRight, &iCur, &iColumn)
+ && exprMightBeIndexed(pSrc, op, pTerm->prereqRight, pRight, &iCur,&iColumn)
){
WhereTerm *pNew;
Expr *pDup;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
+ if( pWC->op==TK_AND
+ && (pExpr->op==TK_EQ || pExpr->op==TK_IS)
+ && (pExpr->pLeft->flags & EP_Vector)
+ && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
+ || (pExpr->pRight->flags & EP_xIsSelect)==0
+ )){
+ int i;
+ for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
+ int idxNew;
+ Expr *pNew;
+ Expr *pLeft = exprVectorExpr(pParse, pExpr->pLeft, i);
+ Expr *pRight = exprVectorExpr(pParse, pExpr->pRight, i);
+
+ pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight, 0);
+ idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
+ exprAnalyze(pSrc, pWC, idxNew);
+ markTermAsChild(pWC, idxNew, idxTerm);
+ }
+ }
+
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
/* When sqlite_stat3 histogram data is available an operator of the
** form "x IS NOT NULL" can sometimes be evaluated more efficiently
--- /dev/null
+# 2016 June 17
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library. The
+# focus of this file is testing the SELECT statement.
+#
+
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set ::testprefix rowvalue
+
+do_execsql_test 0.0 {
+ CREATE TABLE one(o);
+ INSERT INTO one VALUES(1);
+}
+
+foreach {tn v1 v2 eq ne is isnot} {
+ 1 "1, 2, 3" "1, 2, 3" 1 0 1 0
+ 2 "1, 0, 3" "1, 2, 3" 0 1 0 1
+ 3 "1, 2, NULL" "1, 2, 3" {} {} 0 1
+ 4 "1, 2, NULL" "1, 2, NULL" {} {} 1 0
+ 5 "NULL, NULL, NULL" "NULL, NULL, NULL" {} {} 1 0
+} {
+ do_execsql_test 1.$tn.eq "SELECT ($v1) == ($v2)" [list $eq]
+ do_execsql_test 1.$tn.ne "SELECT ($v1) != ($v2)" [list $ne]
+
+ do_execsql_test 1.$tn.is "SELECT ($v1) IS ($v2)" [list $is]
+ do_execsql_test 1.$tn.isnot "SELECT ($v1) IS NOT ($v2)" [list $isnot]
+
+ do_execsql_test 1.$tn.2.eq "SELECT (SELECT $v1) == (SELECT $v2)" [list $eq]
+ do_execsql_test 1.$tn.2.ne "SELECT (SELECT $v1) != (SELECT $v2)" [list $ne]
+}
+
+foreach {tn v1 v2 lt gt le ge} {
+ 1 "(1, 1, 3)" "(1, 2, 3)" 1 0 1 0
+ 2 "(1, 2, 3)" "(1, 2, 3)" 0 0 1 1
+ 3 "(1, 3, 3)" "(1, 2, 3)" 0 1 0 1
+
+ 4 "(1, NULL, 3)" "(1, 2, 3)" {} {} {} {}
+ 5 "(1, 3, 3)" "(1, NULL, 3)" {} {} {} {}
+ 6 "(1, NULL, 3)" "(1, NULL, 3)" {} {} {} {}
+} {
+ foreach {tn2 expr res} [list \
+ 2.$tn.lt "$v1 < $v2" $lt \
+ 2.$tn.gt "$v1 > $v2" $gt \
+ 2.$tn.le "$v1 <= $v2" $le \
+ 2.$tn.ge "$v1 >= $v2" $ge \
+ ] {
+ do_execsql_test $tn2 "SELECT $expr" [list $res]
+
+ set map(0) [list]
+ set map() [list]
+ set map(1) [list 1]
+ do_execsql_test $tn2.where1 "SELECT * FROM one WHERE $expr" $map($res)
+
+ set map(0) [list 1]
+ set map() [list]
+ set map(1) [list]
+ do_execsql_test $tn2.where2 "SELECT * FROM one WHERE NOT $expr" $map($res)
+ }
+}
+
+do_execsql_test 3.0 {
+ CREATE TABLE t1(x, y);
+ INSERT INTO t1 VALUES(1, 1);
+ INSERT INTO t1 VALUES(1, 2);
+ INSERT INTO t1 VALUES(2, 3);
+ INSERT INTO t1 VALUES(2, 4);
+ INSERT INTO t1 VALUES(3, 5);
+ INSERT INTO t1 VALUES(3, 6);
+}
+
+foreach {tn r order} {
+ 1 "(1, 1)" "ORDER BY y"
+ 2 "(1, 1)" "ORDER BY x, y"
+ 3 "(1, 2)" "ORDER BY x, y DESC"
+ 4 "(3, 6)" "ORDER BY x DESC, y DESC"
+ 5 "((3, 5))" "ORDER BY x DESC, y"
+ 6 "(SELECT 3, 5)" "ORDER BY x DESC, y"
+} {
+ do_execsql_test 3.$tn.1 "SELECT $r == (SELECT x,y FROM t1 $order)" 1
+ do_execsql_test 3.$tn.2 "SELECT $r == (SELECT * FROM t1 $order)" 1
+
+ do_execsql_test 3.$tn.3 "
+ SELECT (SELECT * FROM t1 $order) == (SELECT * FROM t1 $order)
+ " 1
+ do_execsql_test 3.$tn.4 "
+ SELECT (SELECT 0, 0) == (SELECT * FROM t1 $order)
+ " 0
+}
+
+foreach {tn expr res} {
+ 1 {(2, 2) BETWEEN (2, 2) AND (3, 3)} 1
+ 2 {(2, 2) BETWEEN (2, NULL) AND (3, 3)} {}
+ 3 {(2, 2) BETWEEN (3, NULL) AND (3, 3)} 0
+} {
+ do_execsql_test 4.$tn "SELECT $expr" [list $res]
+}
+
+foreach {tn expr res} {
+ 1 {(2, 4) IN (SELECT * FROM t1)} 1
+ 2 {(3, 4) IN (SELECT * FROM t1)} 0
+
+ 3 {(NULL, 4) IN (SELECT * FROM t1)} {}
+ 4 {(NULL, 0) IN (SELECT * FROM t1)} 0
+
+ 5 {(NULL, 4) NOT IN (SELECT * FROM t1)} {}
+ 6 {(NULL, 0) NOT IN (SELECT * FROM t1)} 1
+} {
+ do_execsql_test 5.$tn "SELECT $expr" [list $res]
+}
+
+finish_test
+
+
--- /dev/null
+# 2016 June 17
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library. The
+# focus of this file is testing the SELECT statement.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set ::testprefix rowvalue2
+
+do_execsql_test 1.0 {
+ CREATE TABLE t1(a, b, c);
+ INSERT INTO t1 VALUES(0, 0, 0);
+ INSERT INTO t1 VALUES(0, 1, 1);
+ INSERT INTO t1 VALUES(1, 0, 2);
+ INSERT INTO t1 VALUES(1, 1, 3);
+
+ CREATE INDEX i1 ON t1(a, b);
+}
+
+do_execsql_test 1.1.1 { SELECT c FROM t1 WHERE (a, b) >= (1, 0) } {2 3}
+do_execsql_test 1.1.2 { SELECT c FROM t1 WHERE (a, b) > (1, 0) } {3}
+
+#-------------------------------------------------------------------------
+
+do_execsql_test 2.0.1 {
+ CREATE TABLE t2(a INTEGER, b INTEGER, c INTEGER, d INTEGER);
+ CREATE INDEX i2 ON t2(a, b, c);
+}
+do_test 2.0.2 {
+ foreach a {0 1 2 3} {
+ foreach b {0 1 2 3} {
+ foreach c {0 1 2 3} {
+ execsql { INSERT INTO t2 VALUES($a, $b, $c, $c + $b*4 + $a*16); }
+ }}}
+} {}
+
+do_execsql_test 2.1 {
+ SELECT d FROM t2 WHERE (a, b) > (2, 2);
+} [db eval { SELECT d FROM t2 WHERE a>2 OR (a=2 AND b>2) }]
+
+do_execsql_test 2.2 {
+ SELECT d FROM t2 WHERE (a, b) >= (2, 2);
+} [db eval { SELECT d FROM t2 WHERE a>2 OR (a=2 AND b>=2) }]
+
+do_execsql_test 2.3 {
+ SELECT d FROM t2 WHERE a=1 AND (b, c) >= (1, 2);
+} [db eval { SELECT d FROM t2 WHERE +a=1 AND (b>1 OR (b==1 AND c>=2)) }]
+
+do_execsql_test 2.4 {
+ SELECT d FROM t2 WHERE a=1 AND (b, c) > (1, 2);
+} [db eval { SELECT d FROM t2 WHERE +a=1 AND (b>1 OR (b==1 AND c>2)) }]
+
+#-------------------------------------------------------------------------
+
+set words {
+airfare airfield airfields airflow airfoil
+airfoils airframe airframes airily airing
+airings airless airlift airlifts airline
+airliner airlines airlock airlocks airmail
+airmails airman airmen airplane airplanes
+
+arraignment arraignments arraigns arrange arranged
+arrangement arrangements arranger arrangers arranges
+arranging arrant array arrayed arrays
+arrears arrest arrested arrester arresters
+arresting arrestingly arrestor arrestors arrests
+
+edifices edit edited editing edition
+editions editor editorial editorially editorials
+editors edits educable educate educated
+educates educating education educational educationally
+educations educator educators eel eelgrass
+}
+
+do_test 3.0 {
+ execsql { CREATE TABLE t3(a, b, c, w); }
+ foreach w $words {
+ set a [string range $w 0 2]
+ set b [string range $w 3 5]
+ set c [string range $w 6 end]
+ execsql { INSERT INTO t3 VALUES($a, $b, $c, $w) }
+ }
+} {}
+
+
+foreach {tn idx} {
+ IDX1 {}
+ IDX2 { CREATE INDEX i3 ON t3(a, b, c); }
+ IDX3 { CREATE INDEX i3 ON t3(a, b); }
+ IDX4 { CREATE INDEX i3 ON t3(a); }
+} {
+ execsql { DROP INDEX IF EXISTS i3 }
+ execsql $idx
+
+ foreach w $words {
+ set a [string range $w 0 2]
+ set b [string range $w 3 5]
+ set c [string range $w 6 end]
+
+ foreach op [list > >= < <= == IS] {
+ do_execsql_test 3.1.$tn.$w.$op [subst -novar {
+ SELECT rowid FROM t3 WHERE (a, b, c) [set op] ($a, $b, $c)
+ ORDER BY +rowid
+ }] [db eval [subst -novar {
+ SELECT rowid FROM t3 WHERE w [set op] $w ORDER BY +rowid
+ }]]
+
+ do_execsql_test 3.1.$tn.$w.$op.subselect [subst -novar {
+ SELECT rowid FROM t3 WHERE (a, b, c) [set op] (
+ SELECT a, b, c FROM t3 WHERE w = $w
+ )
+ ORDER BY +rowid
+ }] [db eval [subst -novar {
+ SELECT rowid FROM t3 WHERE w [set op] $w ORDER BY +rowid
+ }]]
+ }
+
+ }
+}
+
+#-------------------------------------------------------------------------
+#
+
+do_execsql_test 4.0 {
+ CREATE TABLE t4(a, b, c);
+ INSERT INTO t4 VALUES(NULL, NULL, NULL);
+ INSERT INTO t4 VALUES(NULL, NULL, 0);
+ INSERT INTO t4 VALUES(NULL, NULL, 1);
+ INSERT INTO t4 VALUES(NULL, 0, NULL);
+ INSERT INTO t4 VALUES(NULL, 0, 0);
+ INSERT INTO t4 VALUES(NULL, 0, 1);
+ INSERT INTO t4 VALUES(NULL, 1, NULL);
+ INSERT INTO t4 VALUES(NULL, 1, 0);
+ INSERT INTO t4 VALUES(NULL, 1, 1);
+
+ INSERT INTO t4 VALUES( 0, NULL, NULL);
+ INSERT INTO t4 VALUES( 0, NULL, 0);
+ INSERT INTO t4 VALUES( 0, NULL, 1);
+ INSERT INTO t4 VALUES( 0, 0, NULL);
+ INSERT INTO t4 VALUES( 0, 0, 0);
+ INSERT INTO t4 VALUES( 0, 0, 1);
+ INSERT INTO t4 VALUES( 0, 1, NULL);
+ INSERT INTO t4 VALUES( 0, 1, 0);
+ INSERT INTO t4 VALUES( 0, 1, 1);
+
+ INSERT INTO t4 VALUES( 1, NULL, NULL);
+ INSERT INTO t4 VALUES( 1, NULL, 0);
+ INSERT INTO t4 VALUES( 1, NULL, 1);
+ INSERT INTO t4 VALUES( 1, 0, NULL);
+ INSERT INTO t4 VALUES( 1, 0, 0);
+ INSERT INTO t4 VALUES( 1, 0, 1);
+ INSERT INTO t4 VALUES( 1, 1, NULL);
+ INSERT INTO t4 VALUES( 1, 1, 0);
+ INSERT INTO t4 VALUES( 1, 1, 1);
+}
+
+proc make_expr1 {cList vList op} {
+ return "([join $cList ,]) $op ([join $vList ,])"
+}
+
+proc make_expr3 {cList vList op} {
+ set n [llength $cList]
+
+ set aList [list]
+ foreach c [lrange $cList 0 end-1] v [lrange $vList 0 end-1] {
+ lappend aList "$c == $v"
+ }
+ lappend aList "[lindex $cList end] $op [lindex $vList end]"
+
+ return "([join $aList { AND }])"
+}
+
+proc make_expr2 {cList vList op} {
+ set ret ""
+
+ switch -- $op {
+ == - IS {
+ set aList [list]
+ foreach c $cList v $vList { lappend aList "($c $op $v)" }
+ set ret [join $aList " AND "]
+ }
+
+ < - > {
+ set oList [list]
+ for {set i 0} {$i < [llength $cList]} {incr i} {
+ lappend oList [make_expr3 [lrange $cList 0 $i] [lrange $vList 0 $i] $op]
+ }
+ set ret [join $oList " OR "]
+ }
+
+ <= - >= {
+ set o2 [string range $op 0 0]
+ set oList [list]
+ for {set i 0} {$i < [llength $cList]-1} {incr i} {
+ lappend oList [make_expr3 [lrange $cList 0 $i] [lrange $vList 0 $i] $o2]
+ }
+ lappend oList [make_expr3 $cList $vList $op]
+ set ret [join $oList " OR "]
+ }
+
+
+ default {
+ error "Unknown op: $op"
+ }
+ }
+
+ set ret
+}
+
+foreach {tn idx} {
+ IDX1 {}
+ IDX2 { CREATE INDEX i4 ON t4(a, b, c); }
+ IDX3 { CREATE INDEX i4 ON t4(a, b); }
+ IDX4 { CREATE INDEX i4 ON t4(a); }
+} {
+ execsql { DROP INDEX IF EXISTS i4 }
+ execsql $idx
+
+ foreach {tn2 vector} {
+ 1 {0 0 0}
+ 2 {1 1 1}
+ 3 {0 0 NULL}
+ 4 {0 NULL 0}
+ 5 {NULL 0 0}
+ 6 {1 1 NULL}
+ 7 {1 NULL 1}
+ 8 {NULL 1 1}
+ } {
+ foreach op { IS == < <= > >= } {
+ set e1 [make_expr1 {a b c} $vector $op]
+ set e2 [make_expr2 {a b c} $vector $op]
+
+ do_execsql_test 4.$tn.$tn2.$op \
+ "SELECT rowid FROM t4 WHERE $e2 ORDER BY +rowid" [
+ db eval "SELECT rowid FROM t4 WHERE $e1 ORDER BY +rowid"
+ ]
+ }
+ }
+}
+
+
+finish_test
+
UMINUS
UPLUS
REGISTER
+ SELECT_COLUMN
ASTERISK
SPAN
SPACE
projects / thirdparty / sqlite.git / commitdiff
