-C Add\snew\stest\sfile\srowvaluefault.test.
-D 2016-08-02T20:45:56.795
+C Fix\sstat4-based\scost\sestimates\sfor\svector\srange\sconstraints.
+D 2016-08-03T16:14:33.444
F Makefile.in 6c20d44f72d4564f11652b26291a214c8367e5db
F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
F Makefile.msc 3340e479e5221f06c3d61726f8f7efff885e4233
F src/date.c 1cc9fb516ec9932c6fd4d2a0d2f8bc4480145c39
F src/dbstat.c 4f6f7f52b49beb9636ffbd517cfe44a402ba4ad0
F src/delete.c 4aba4214a377ce8ddde2d2e609777bcc8235200f
-F src/expr.c 200cad2bc4eaaea03d36d1a13c47a90f6595154d
+F src/expr.c 9539a6e0941248b63d631757406e089f48bea50c
F src/fault.c 160a0c015b6c2629d3899ed2daf63d75754a32bb
F src/fkey.c bc4145347595b7770f9a598cff1c848302cf5413
F src/func.c 61a4114cf7004f10c542cfabbab9f2bcb9033045
F src/sqlite.h.in e011dcc3942e6ddc8dd7b894e9e6702e4269161e
F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
F src/sqlite3ext.h 8648034aa702469afb553231677306cc6492a1ae
-F src/sqliteInt.h 9d6623807cc94dfa49d0eab6380ad77091e97019
+F src/sqliteInt.h a1cf00afd6a5666a160e81c7a600418a3b59a8a6
F src/sqliteLimit.h c0373387c287c8d0932510b5547ecde31b5da247
F src/status.c a9e66593dfb28a9e746cba7153f84d49c1ddc4b1
F src/table.c 5226df15ab9179b9ed558d89575ea0ce37b03fc9
F src/vdbeapi.c c3f6715a99995c11748ecad91d25e93fd9fc390b
F src/vdbeaux.c a32d79aeaa88dc2b97c261172d952d395254a055
F src/vdbeblob.c 83d2d266383157b02e2b809350bb197e89d7895b
-F src/vdbemem.c 1ecaa5ee0caff07255f25d04e8dc88befb6f88d1
+F src/vdbemem.c 77d6505956bf4e45c328ab3ebef6b461334cab5d
F src/vdbesort.c 91fda3909326860382b0ca8aa251e609c6a9d62c
F src/vdbetrace.c 41963d5376f0349842b5fc4aaaaacd7d9cdc0834
F src/vtab.c 6fece06fdd50eb2b0673e37e627ce6710e4af5be
F src/wal.c 02eeecc265f6ffd0597378f5d8ae9070b62a406a
F src/wal.h 6dd221ed384afdc204bc61e25c23ef7fd5a511f2
F src/walker.c 0f142b5bd3ed2041fc52d773880748b212e63354
-F src/where.c 25eae2e051809c75a8a1a23288f335382ac0215f
+F src/where.c 21095414c4bf8d5fdf05f3be790bf8b65e370f94
F src/whereInt.h 14dd243e13b81cbb0a66063d38b70f93a7d6e613
F src/wherecode.c c2392fa30bcb0c555a8ae402d646b357ca428ad6
F src/whereexpr.c 4a8cefc7c122132ac9f3ed125c61629a0e3de094
F test/rowvalue.test 56b34d31d91340a6e922e753b798880170cc1aa7
F test/rowvalue2.test 8d5dfe75b8f4d1868a2f91f0356f20d36cba64ff
F test/rowvalue3.test dbe935260851b197dfbbbcb0ac2a15cb5f324fd4
-F test/rowvalue4.test 9aa6a5efe6069b34bcbefe004bb481cdaaca0dc5
+F test/rowvalue4.test 86a04529ab1da3879d6ef56defe15446e4575b3d
F test/rowvaluefault.test 7b16485e3f2b371f3e3d05455b8ded6d0c090244
F test/rtree.test 0c8d9dd458d6824e59683c19ab2ffa9ef946f798
F test/run-wordcount.sh 891e89c4c2d16e629cd45951d4ed899ad12afc09
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 092b1c5ff53c9f3cfed079c46e3353d93f99303e
-R 7575cd5084e4e0e048e98a52c8b1c879
+P e496b2d63984311e6ae117677e6c2417ae24b6bc
+R 2ab02159e20122e5dc19c46ffdea23b5
U dan
-Z 1ac631fd43d573ba36f8f7688c8dc1d7
+Z 1b607e01edb5341321c1446f2f3437dc
-e496b2d63984311e6ae117677e6c2417ae24b6bc
\ No newline at end of file
+18af74abc8ceae47ab9fbee3e3e5bb37db8fcba5
\ No newline at end of file
** pointer to the i'th returned column value. Otherwise, return a copy
** of the first argument.
*/
-static Expr *exprVectorField(Expr *pVector, int i){
+Expr *sqlite3ExprVectorField(Expr *pVector, int i){
assert( i<sqlite3ExprVectorSize(pVector) );
if( sqlite3ExprIsVector(pVector) ){
if( pVector->op==TK_SELECT ){
** comparison is the same as the affinity of each column. If
** it not, it is not possible to use any index. */
for(i=0; i<nExpr && affinity_ok; i++){
- Expr *pLhs = exprVectorField(pX->pLeft, i);
+ Expr *pLhs = sqlite3ExprVectorField(pX->pLeft, i);
int iCol = pEList->a[i].pExpr->iColumn;
char idxaff = pTab->aCol[iCol].affinity;
char cmpaff = sqlite3CompareAffinity(pLhs, idxaff);
}
for(i=0; i<nExpr; i++){
- Expr *pLhs = exprVectorField(pX->pLeft, i);
+ Expr *pLhs = sqlite3ExprVectorField(pX->pLeft, i);
Expr *pRhs = pEList->a[i].pExpr;
CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
int j;
if( zRet ){
int i;
for(i=0; i<nVal; i++){
- Expr *pA = exprVectorField(pLeft, i);
+ Expr *pA = sqlite3ExprVectorField(pLeft, i);
char a = sqlite3ExprAffinity(pA);
if( pSelect ){
zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
assert( pEList->nExpr>0 );
assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
for(i=0; i<nVal; i++){
- Expr *p = (nVal>1) ? exprVectorField(pLeft, i) : pLeft;
+ Expr *p = (nVal>1) ? sqlite3ExprVectorField(pLeft, i) : pLeft;
pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
pParse, p, pEList->a[i].pExpr
);
}
}else{
for(i=0; i<nVector; i++){
- Expr *pLhs = exprVectorField(pLeft, i);
+ Expr *pLhs = sqlite3ExprVectorField(pLeft, i);
sqlite3ExprCode(pParse, pLhs, r1+aiMap[i]);
}
}
** completely empty, or NULL otherwise. */
if( destIfNull==destIfFalse ){
for(i=0; i<nVector; i++){
- Expr *p = exprVectorField(pExpr->pLeft, i);
+ Expr *p = sqlite3ExprVectorField(pExpr->pLeft, i);
if( sqlite3ExprCanBeNull(p) ){
sqlite3VdbeAddOp2(v, OP_IsNull, r1+aiMap[i], destIfNull);
}
Expr *p;
CollSeq *pColl;
int r2 = sqlite3GetTempReg(pParse);
- p = exprVectorField(pLeft, i);
+ p = sqlite3ExprVectorField(pLeft, i);
pColl = sqlite3ExprCollSeq(pParse, p);
sqlite3VdbeAddOp3(v, OP_Column, iIdx, i, r2);
** result is 1. */
sqlite3VdbeJumpHere(v, addr);
for(i=0; i<nVector; i++){
- Expr *p = exprVectorField(pExpr->pLeft, i);
+ Expr *p = sqlite3ExprVectorField(pExpr->pLeft, i);
if( sqlite3ExprCanBeNull(p) ){
sqlite3VdbeAddOp2(v, OP_IsNull, r1+aiMap[i], destIfNull);
}
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
void sqlite3AnalyzeFunctions(void);
-int sqlite3Stat4ProbeSetValue(Parse*,Index*,UnpackedRecord**,Expr*,u8,int,int*);
+int sqlite3Stat4ProbeSetValue(
+ Parse*,Index*,UnpackedRecord**,Expr*,int,int,int*);
int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**);
void sqlite3Stat4ProbeFree(UnpackedRecord*);
int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**);
+char sqlite3IndexColumnAffinity(sqlite3*, Index*, int);
#endif
/*
int sqlite3ExprVectorSize(Expr *pExpr);
int sqlite3ExprIsVector(Expr *pExpr);
+Expr *sqlite3ExprVectorField(Expr*, int);
#endif /* SQLITEINT_H */
** structures intended to be compared against sample index keys stored
** in the sqlite_stat4 table.
**
-** A single call to this function attempts to populates field iVal (leftmost
-** is 0 etc.) of the unpacked record with a value extracted from expression
-** pExpr. Extraction of values is possible if:
+** A single call to this function populates zero or more fields of the
+** record starting with field iVal (fields are numbered from left to
+** right starting with 0). A single field is populated if:
**
** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
**
** * The sqlite3ValueFromExpr() function is able to extract a value
** from the expression (i.e. the expression is a literal value).
**
-** If a value can be extracted, the affinity passed as the 5th argument
-** is applied to it before it is copied into the UnpackedRecord. Output
-** parameter *pbOk is set to true if a value is extracted, or false
-** otherwise.
+** Or, if pExpr is a TK_VECTOR, one field is populated for each of the
+** vector components that match either of the two latter criteria listed
+** above.
+**
+** Before any value is appended to the record, the affinity of the
+** corresponding column within index pIdx is applied to it. Before
+** this function returns, output parameter *pnExtract is set to the
+** number of values appended to the record.
**
** When this function is called, *ppRec must either point to an object
** allocated by an earlier call to this function, or must be NULL. If it
Index *pIdx, /* Index being probed */
UnpackedRecord **ppRec, /* IN/OUT: Probe record */
Expr *pExpr, /* The expression to extract a value from */
- u8 affinity, /* Affinity to use */
+ int nElem, /* Maximum number of values to append */
int iVal, /* Array element to populate */
- int *pbOk /* OUT: True if value was extracted */
+ int *pnExtract /* OUT: Values appended to the record */
){
- int rc;
- sqlite3_value *pVal = 0;
- struct ValueNewStat4Ctx alloc;
+ int rc = SQLITE_OK;
+ int nExtract = 0;
- alloc.pParse = pParse;
- alloc.pIdx = pIdx;
- alloc.ppRec = ppRec;
- alloc.iVal = iVal;
+ if( pExpr==0 || pExpr->op!=TK_SELECT ){
+ int i;
+ struct ValueNewStat4Ctx alloc;
+
+ alloc.pParse = pParse;
+ alloc.pIdx = pIdx;
+ alloc.ppRec = ppRec;
+
+ for(i=0; i<nElem; i++){
+ sqlite3_value *pVal = 0;
+ Expr *pElem = (pExpr ? sqlite3ExprVectorField(pExpr, i) : 0);
+ u8 aff = sqlite3IndexColumnAffinity(pParse->db, pIdx, iVal+i);
+ alloc.iVal = iVal+i;
+ rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal);
+ if( !pVal ) break;
+ nExtract++;
+ }
+ }
- rc = stat4ValueFromExpr(pParse, pExpr, affinity, &alloc, &pVal);
- assert( pVal==0 || pVal->db==pParse->db );
- *pbOk = (pVal!=0);
+ *pnExtract = nExtract;
return rc;
}
/*
** Return the affinity for a single column of an index.
*/
-static char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
+char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
assert( iCol>=0 && iCol<pIdx->nColumn );
if( !pIdx->zColAff ){
if( sqlite3IndexAffinityStr(db, pIdx)==0 ) return SQLITE_AFF_BLOB;
if( nEq==pBuilder->nRecValid ){
UnpackedRecord *pRec = pBuilder->pRec;
tRowcnt a[2];
- u8 aff;
+ int nBtm = pLoop->u.btree.nBtm;
+ int nTop = pLoop->u.btree.nTop;
/* Variable iLower will be set to the estimate of the number of rows in
** the index that are less than the lower bound of the range query. The
testcase( pRec->nField!=pBuilder->nRecValid );
pRec->nField = pBuilder->nRecValid;
}
- aff = sqlite3IndexColumnAffinity(pParse->db, p, nEq);
- assert( nEq!=p->nKeyCol || aff==SQLITE_AFF_INTEGER );
/* Determine iLower and iUpper using ($P) only. */
if( nEq==0 ){
iLower = 0;
if( p->aSortOrder[nEq] ){
/* The roles of pLower and pUpper are swapped for a DESC index */
SWAP(WhereTerm*, pLower, pUpper);
+ SWAP(int, nBtm, nTop);
}
/* If possible, improve on the iLower estimate using ($P:$L). */
if( pLower ){
- int bOk; /* True if value is extracted from pExpr */
+ int n; /* Values extracted from pExpr */
Expr *pExpr = pLower->pExpr->pRight;
- rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk);
- if( rc==SQLITE_OK && bOk ){
+ rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
+ if( rc==SQLITE_OK && n ){
tRowcnt iNew;
+ u16 mask = WO_GT|WO_LE;
+ if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a);
- iNew = a[0] + ((pLower->eOperator & (WO_GT|WO_LE)) ? a[1] : 0);
+ iNew = a[0] + ((pLower->eOperator & mask) ? a[1] : 0);
if( iNew>iLower ) iLower = iNew;
nOut--;
pLower = 0;
/* If possible, improve on the iUpper estimate using ($P:$U). */
if( pUpper ){
- int bOk; /* True if value is extracted from pExpr */
+ int n; /* Values extracted from pExpr */
Expr *pExpr = pUpper->pExpr->pRight;
- rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk);
- if( rc==SQLITE_OK && bOk ){
+ rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
+ if( rc==SQLITE_OK && n ){
tRowcnt iNew;
+ u16 mask = WO_GT|WO_LE;
+ if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
iUprIdx = whereKeyStats(pParse, p, pRec, 1, a);
- iNew = a[0] + ((pUpper->eOperator & (WO_GT|WO_LE)) ? a[1] : 0);
+ iNew = a[0] + ((pUpper->eOperator & mask) ? a[1] : 0);
if( iNew<iUpper ) iUpper = iNew;
nOut--;
pUpper = 0;
Index *p = pBuilder->pNew->u.btree.pIndex;
int nEq = pBuilder->pNew->u.btree.nEq;
UnpackedRecord *pRec = pBuilder->pRec;
- u8 aff; /* Column affinity */
int rc; /* Subfunction return code */
tRowcnt a[2]; /* Statistics */
int bOk;
return SQLITE_OK;
}
- aff = sqlite3IndexColumnAffinity(pParse->db, p, nEq-1);
- rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq-1, &bOk);
+ rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
pBuilder->pRec = pRec;
if( rc!=SQLITE_OK ) return rc;
if( bOk==0 ) return SQLITE_NOTFOUND;
}
}
+ifcapable stat4 {
+ do_execsql_test 3.0 {
+ CREATE TABLE c1(a, b, c, d);
+ INSERT INTO c1(a, b) VALUES(1, 'a');
+ INSERT INTO c1(a, b) VALUES(1, 'b');
+ INSERT INTO c1(a, b) VALUES(1, 'c');
+ INSERT INTO c1(a, b) VALUES(1, 'd');
+ INSERT INTO c1(a, b) VALUES(1, 'e');
+ INSERT INTO c1(a, b) VALUES(1, 'f');
+ INSERT INTO c1(a, b) VALUES(1, 'g');
+ INSERT INTO c1(a, b) VALUES(1, 'h');
+ INSERT INTO c1(a, b) VALUES(1, 'i');
+ INSERT INTO c1(a, b) VALUES(1, 'j');
+ INSERT INTO c1(a, b) VALUES(1, 'k');
+ INSERT INTO c1(a, b) VALUES(1, 'l');
+ INSERT INTO c1(a, b) VALUES(1, 'm');
+ INSERT INTO c1(a, b) VALUES(1, 'n');
+ INSERT INTO c1(a, b) VALUES(1, 'o');
+ INSERT INTO c1(a, b) VALUES(1, 'p');
+ INSERT INTO c1(a, b) VALUES(2, 'a');
+ INSERT INTO c1(a, b) VALUES(2, 'b');
+ INSERT INTO c1(a, b) VALUES(2, 'c');
+ INSERT INTO c1(a, b) VALUES(2, 'd');
+ INSERT INTO c1(a, b) VALUES(2, 'e');
+ INSERT INTO c1(a, b) VALUES(2, 'f');
+ INSERT INTO c1(a, b) VALUES(2, 'g');
+ INSERT INTO c1(a, b) VALUES(2, 'h');
+
+ INSERT INTO c1(c, d) SELECT a, b FROM c1;
+
+ CREATE INDEX c1ab ON c1(a, b);
+ CREATE INDEX c1cd ON c1(c, d);
+ ANALYZE;
+ }
+
+ do_eqp_test 3.1.1 { SELECT * FROM c1 WHERE a=1 AND c=2 } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1cd (c=?)}
+ }
+ do_eqp_test 3.1.2 { SELECT * FROM c1 WHERE a=1 AND b>'d' AND c=2 } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1cd (c=?)}
+ }
+ do_eqp_test 3.1.3 { SELECT * FROM c1 WHERE a=1 AND b>'l' AND c=2 } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1ab (a=? AND b>?)}
+ }
+
+ do_eqp_test 3.2.1 { SELECT * FROM c1 WHERE a=1 AND c>1 } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1cd (c>?)}
+ }
+ do_eqp_test 3.2.2 { SELECT * FROM c1 WHERE a=1 AND c>0 } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1ab (a=?)}
+ }
+ do_eqp_test 3.2.3 { SELECT * FROM c1 WHERE a=1 AND c>=1 } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1ab (a=?)}
+ }
+ do_eqp_test 3.2.4 { SELECT * FROM c1 WHERE a=1 AND (c, d)>(1, 'c') } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1ab (a=?)}
+ }
+ do_eqp_test 3.2.5 { SELECT * FROM c1 WHERE a=1 AND (c, d)>(1, 'o') } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1cd (c>?)}
+ }
+ do_eqp_test 3.2.6 { SELECT * FROM c1 WHERE a=1 AND (c, +b)>(1, 'c') } {
+ 0 0 0 {SEARCH TABLE c1 USING INDEX c1ab (a=?)}
+ }
+}
finish_test
projects / thirdparty / sqlite.git / commitdiff
