Fossil SCM

Update to SQLite 3.15.2

jan.nijtmans 2016-12-08 06:17 UTC branch-1.36
Commit 8b03934eadb7c666c42cb1aec8697fb9d974b268
Parent a8a67989fc99495…
2 files changed +74 -36 +3 -3
~ src/sqlite3.c ~ src/sqlite3.h
M src/sqlite3.c
+74 -36
--- src/sqlite3.c
+++ src/sqlite3.c
@@ -1,8 +1,8 @@
11
 /******************************************************************************
22
 ** This file is an amalgamation of many separate C source files from SQLite
3
-** version 3.15.1. By combining all the individual C code files into this
3
+** version 3.15.2. By combining all the individual C code files into this
44
 ** single large file, the entire code can be compiled as a single translation
55
 ** unit. This allows many compilers to do optimizations that would not be
66
 ** possible if the files were compiled separately. Performance improvements
77
 ** of 5% or more are commonly seen when SQLite is compiled as a single
88
 ** translation unit.
@@ -379,13 +379,13 @@
379379
 **
380380
 ** See also: [sqlite3_libversion()],
381381
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
382382
 ** [sqlite_version()] and [sqlite_source_id()].
383383
 */
384
-#define SQLITE_VERSION "3.15.1"
385
-#define SQLITE_VERSION_NUMBER 3015001
386
-#define SQLITE_SOURCE_ID "2016-11-04 12:08:49 1136863c76576110e710dd5d69ab6bf347c65e36"
384
+#define SQLITE_VERSION "3.15.2"
385
+#define SQLITE_VERSION_NUMBER 3015002
386
+#define SQLITE_SOURCE_ID "2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8"
387387
388388
 /*
389389
 ** CAPI3REF: Run-Time Library Version Numbers
390390
 ** KEYWORDS: sqlite3_version, sqlite3_sourceid
391391
 **
@@ -15581,19 +15581,19 @@
1558115581
 int iReg; /* Reg with value of this column. 0 means none. */
1558215582
 int lru; /* Least recently used entry has the smallest value */
1558315583
 } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
1558415584
 int aTempReg[8]; /* Holding area for temporary registers */
1558515585
 Token sNameToken; /* Token with unqualified schema object name */
15586
- Token sLastToken; /* The last token parsed */
1558715586
1558815587
 /************************************************************************
1558915588
 ** Above is constant between recursions. Below is reset before and after
1559015589
 ** each recursion. The boundary between these two regions is determined
15591
- ** using offsetof(Parse,nVar) so the nVar field must be the first field
15592
- ** in the recursive region.
15590
+ ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
15591
+ ** first field in the recursive region.
1559315592
 ************************************************************************/
1559415593
15594
+ Token sLastToken; /* The last token parsed */
1559515595
 ynVar nVar; /* Number of '?' variables seen in the SQL so far */
1559615596
 int nzVar; /* Number of available slots in azVar[] */
1559715597
 u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */
1559815598
 u8 explain; /* True if the EXPLAIN flag is found on the query */
1559915599
 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -15623,11 +15623,11 @@
1562315623
1562415624
 /*
1562515625
 ** Sizes and pointers of various parts of the Parse object.
1562615626
 */
1562715627
 #define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
15628
-#define PARSE_RECURSE_SZ offsetof(Parse,nVar) /* Recursive part */
15628
+#define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
1562915629
 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
1563015630
 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
1563115631
1563215632
 /*
1563315633
 ** Return true if currently inside an sqlite3_declare_vtab() call.
@@ -88582,10 +88582,14 @@
8858288582
 assert( pExpr->x.pSelect==0 );
8858388583
 pOrig = pEList->a[j].pExpr;
8858488584
 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
8858588585
 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
8858688586
 return WRC_Abort;
88587
+ }
88588
+ if( sqlite3ExprVectorSize(pOrig)!=1 ){
88589
+ sqlite3ErrorMsg(pParse, "row value misused");
88590
+ return WRC_Abort;
8858788591
 }
8858888592
 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
8858988593
 cnt = 1;
8859088594
 pMatch = 0;
8859188595
 assert( zTab==0 && zDb==0 );
@@ -88959,10 +88963,11 @@
8895988963
 }
8896088964
 case TK_VARIABLE: {
8896188965
 notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
8896288966
 break;
8896388967
 }
88968
+ case TK_BETWEEN:
8896488969
 case TK_EQ:
8896588970
 case TK_NE:
8896688971
 case TK_LT:
8896788972
 case TK_LE:
8896888973
 case TK_GT:
@@ -88969,23 +88974,31 @@
8896988974
 case TK_GE:
8897088975
 case TK_IS:
8897188976
 case TK_ISNOT: {
8897288977
 int nLeft, nRight;
8897388978
 if( pParse->db->mallocFailed ) break;
88974
- assert( pExpr->pRight!=0 );
8897588979
 assert( pExpr->pLeft!=0 );
8897688980
 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
88977
- nRight = sqlite3ExprVectorSize(pExpr->pRight);
88981
+ if( pExpr->op==TK_BETWEEN ){
88982
+ nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
88983
+ if( nRight==nLeft ){
88984
+ nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
88985
+ }
88986
+ }else{
88987
+ assert( pExpr->pRight!=0 );
88988
+ nRight = sqlite3ExprVectorSize(pExpr->pRight);
88989
+ }
8897888990
 if( nLeft!=nRight ){
8897988991
 testcase( pExpr->op==TK_EQ );
8898088992
 testcase( pExpr->op==TK_NE );
8898188993
 testcase( pExpr->op==TK_LT );
8898288994
 testcase( pExpr->op==TK_LE );
8898388995
 testcase( pExpr->op==TK_GT );
8898488996
 testcase( pExpr->op==TK_GE );
8898588997
 testcase( pExpr->op==TK_IS );
8898688998
 testcase( pExpr->op==TK_ISNOT );
88999
+ testcase( pExpr->op==TK_BETWEEN );
8898789000
 sqlite3ErrorMsg(pParse, "row value misused");
8898889001
 }
8898989002
 break;
8899089003
 }
8899189004
 }
@@ -93010,11 +93023,11 @@
9301093023
 }else{
9301193024
 int i;
9301293025
 iResult = pParse->nMem+1;
9301393026
 pParse->nMem += nResult;
9301493027
 for(i=0; i<nResult; i++){
93015
- sqlite3ExprCode(pParse, p->x.pList->a[i].pExpr, i+iResult);
93028
+ sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
9301693029
 }
9301793030
 }
9301893031
 }
9301993032
 return iResult;
9302093033
 }
@@ -97762,10 +97775,11 @@
9776297775
 NameContext sName;
9776397776
 Vdbe *v;
9776497777
 sqlite3* db = pParse->db;
9776597778
 int regArgs;
9776697779
97780
+ if( pParse->nErr ) goto attach_end;
9776797781
 memset(&sName, 0, sizeof(NameContext));
9776897782
 sName.pParse = pParse;
9776997783
9777097784
 if(
9777197785
 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
@@ -104307,10 +104321,12 @@
104307104321
 isText = 0;
104308104322
 }else{
104309104323
 zHaystack = sqlite3_value_text(argv[0]);
104310104324
 zNeedle = sqlite3_value_text(argv[1]);
104311104325
 isText = 1;
104326
+ if( zNeedle==0 ) return;
104327
+ assert( zHaystack );
104312104328
 }
104313104329
 while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){
104314104330
 N++;
104315104331
 do{
104316104332
 nHaystack--;
@@ -124769,10 +124785,11 @@
124769124785
 if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){
124770124786
 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0);
124771124787
 }else{
124772124788
 Select *pSelect = pX->x.pSelect;
124773124789
 sqlite3 *db = pParse->db;
124790
+ u16 savedDbOptFlags = db->dbOptFlags;
124774124791
 ExprList *pOrigRhs = pSelect->pEList;
124775124792
 ExprList *pOrigLhs = pX->pLeft->x.pList;
124776124793
 ExprList *pRhs = 0; /* New Select.pEList for RHS */
124777124794
 ExprList *pLhs = 0; /* New pX->pLeft vector */
124778124795
@@ -124812,11 +124829,13 @@
124812124829
 pLeft->x.pList = pLhs;
124813124830
 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int) * nEq);
124814124831
 testcase( aiMap==0 );
124815124832
 }
124816124833
 pSelect->pEList = pRhs;
124834
+ db->dbOptFlags |= SQLITE_QueryFlattener;
124817124835
 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap);
124836
+ db->dbOptFlags = savedDbOptFlags;
124818124837
 testcase( aiMap!=0 && aiMap[0]!=0 );
124819124838
 pSelect->pEList = pOrigRhs;
124820124839
 pLeft->x.pList = pOrigLhs;
124821124840
 pX->pLeft = pLeft;
124822124841
 }
@@ -127631,10 +127650,12 @@
127631127650
 #endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */
127632127651
127633127652
 /* Prevent ON clause terms of a LEFT JOIN from being used to drive
127634127653
 ** an index for tables to the left of the join.
127635127654
 */
127655
+ testcase( pTerm!=&pWC->a[idxTerm] );
127656
+ pTerm = &pWC->a[idxTerm];
127636127657
 pTerm->prereqRight |= extraRight;
127637127658
 }
127638127659
127639127660
 /***************************************************************************
127640127661
 ** Routines with file scope above. Interface to the rest of the where.c
@@ -165383,24 +165404,24 @@
165383165404
 int nArg; /* Number of arguments */
165384165405
 int enc; /* Optimal text encoding */
165385165406
 void *pContext; /* sqlite3_user_data() context */
165386165407
 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
165387165408
 } scalars[] = {
165388
- {"regexp", 2, SQLITE_ANY, 0, icuRegexpFunc},
165389
-
165390
- {"lower", 1, SQLITE_UTF16, 0, icuCaseFunc16},
165391
- {"lower", 2, SQLITE_UTF16, 0, icuCaseFunc16},
165392
- {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
165393
- {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
165394
-
165395
- {"lower", 1, SQLITE_UTF8, 0, icuCaseFunc16},
165396
- {"lower", 2, SQLITE_UTF8, 0, icuCaseFunc16},
165397
- {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16},
165398
- {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16},
165399
-
165400
- {"like", 2, SQLITE_UTF8, 0, icuLikeFunc},
165401
- {"like", 3, SQLITE_UTF8, 0, icuLikeFunc},
165409
+ {"regexp", 2, SQLITE_ANY|SQLITE_DETERMINISTIC, 0, icuRegexpFunc},
165410
+
165411
+ {"lower", 1, SQLITE_UTF16|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165412
+ {"lower", 2, SQLITE_UTF16|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165413
+ {"upper", 1, SQLITE_UTF16|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165414
+ {"upper", 2, SQLITE_UTF16|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165415
+
165416
+ {"lower", 1, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165417
+ {"lower", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165418
+ {"upper", 1, SQLITE_UTF8|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165419
+ {"upper", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165420
+
165421
+ {"like", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuLikeFunc},
165422
+ {"like", 3, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuLikeFunc},
165402165423
165403165424
 {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
165404165425
 };
165405165426
165406165427
 int rc = SQLITE_OK;
@@ -176414,17 +176435,19 @@
176414176435
 ** to pass signed char values.
176415176436
 */
176416176437
 #ifdef sqlite3Isdigit
176417176438
 /* Use the SQLite core versions if this routine is part of the
176418176439
 ** SQLite amalgamation */
176419
-# define safe_isdigit(x) sqlite3Isdigit(x)
176420
-# define safe_isalnum(x) sqlite3Isalnum(x)
176440
+# define safe_isdigit(x) sqlite3Isdigit(x)
176441
+# define safe_isalnum(x) sqlite3Isalnum(x)
176442
+# define safe_isxdigit(x) sqlite3Isxdigit(x)
176421176443
 #else
176422176444
 /* Use the standard library for separate compilation */
176423176445
 #include <ctype.h> /* amalgamator: keep */
176424
-# define safe_isdigit(x) isdigit((unsigned char)(x))
176425
-# define safe_isalnum(x) isalnum((unsigned char)(x))
176446
+# define safe_isdigit(x) isdigit((unsigned char)(x))
176447
+# define safe_isalnum(x) isalnum((unsigned char)(x))
176448
+# define safe_isxdigit(x) isxdigit((unsigned char)(x))
176426176449
 #endif
176427176450
176428176451
 /*
176429176452
 ** Growing our own isspace() routine this way is twice as fast as
176430176453
 ** the library isspace() function, resulting in a 7% overall performance
@@ -177066,10 +177089,19 @@
177066177089
 p->iVal = 0;
177067177090
 p->n = n;
177068177091
 p->u.zJContent = zContent;
177069177092
 return pParse->nNode++;
177070177093
 }
177094
+
177095
+/*
177096
+** Return true if z[] begins with 4 (or more) hexadecimal digits
177097
+*/
177098
+static int jsonIs4Hex(const char *z){
177099
+ int i;
177100
+ for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0;
177101
+ return 1;
177102
+}
177071177103
177072177104
 /*
177073177105
 ** Parse a single JSON value which begins at pParse->zJson[i]. Return the
177074177106
 ** index of the first character past the end of the value parsed.
177075177107
 **
@@ -177141,12 +177173,17 @@
177141177173
 for(;;){
177142177174
 c = pParse->zJson[j];
177143177175
 if( c==0 ) return -1;
177144177176
 if( c=='\\' ){
177145177177
 c = pParse->zJson[++j];
177146
- if( c==0 ) return -1;
177147
- jnFlags = JNODE_ESCAPE;
177178
+ if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f'
177179
+ || c=='n' || c=='r' || c=='t'
177180
+ || (c=='u' && jsonIs4Hex(pParse->zJson+j+1)) ){
177181
+ jnFlags = JNODE_ESCAPE;
177182
+ }else{
177183
+ return -1;
177184
+ }
177148177185
 }else if( c=='"' ){
177149177186
 break;
177150177187
 }
177151177188
 j++;
177152177189
 }
@@ -178010,11 +178047,11 @@
178010178047
 JsonString *pStr;
178011178048
 pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
178012178049
 if( pStr ){
178013178050
 jsonAppendChar(pStr, '}');
178014178051
 if( pStr->bErr ){
178015
- if( pStr->bErr==0 ) sqlite3_result_error_nomem(ctx);
178052
+ if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
178016178053
 assert( pStr->bStatic );
178017178054
 }else{
178018178055
 sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
178019178056
 pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
178020178057
 pStr->bStatic = 1;
@@ -178288,13 +178325,13 @@
178288178325
 break;
178289178326
 }
178290178327
 /* For json_each() path and root are the same so fall through
178291178328
 ** into the root case */
178292178329
 }
178293
- case JEACH_ROOT: {
178330
+ default: {
178294178331
 const char *zRoot = p->zRoot;
178295
- if( zRoot==0 ) zRoot = "$";
178332
+ if( zRoot==0 ) zRoot = "$";
178296178333
 sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC);
178297178334
 break;
178298178335
 }
178299178336
 case JEACH_JSON: {
178300178337
 assert( i==JEACH_JSON );
@@ -184217,11 +184254,11 @@
184217184254
 pNode->bEof = 1;
184218184255
 return rc;
184219184256
 }
184220184257
 }else{
184221184258
 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
184222
- if( pIter->iRowid==iLast ) continue;
184259
+ if( pIter->iRowid==iLast || pIter->bEof ) continue;
184223184260
 bMatch = 0;
184224184261
 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
184225184262
 return rc;
184226184263
 }
184227184264
 }
@@ -189357,10 +189394,11 @@
189357189394
 Fts5Iter *pIter,
189358189395
 int bFrom, /* True if argument iFrom is valid */
189359189396
 i64 iFrom /* Advance at least as far as this */
189360189397
 ){
189361189398
 int bUseFrom = bFrom;
189399
+ assert( pIter->base.bEof==0 );
189362189400
 while( p->rc==SQLITE_OK ){
189363189401
 int iFirst = pIter->aFirst[1].iFirst;
189364189402
 int bNewTerm = 0;
189365189403
 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
189366189404
 assert( p->rc==SQLITE_OK );
@@ -195621,11 +195659,11 @@
195621195659
 int nArg, /* Number of args */
195622195660
 sqlite3_value **apUnused /* Function arguments */
195623195661
 ){
195624195662
 assert( nArg==0 );
195625195663
 UNUSED_PARAM2(nArg, apUnused);
195626
- sqlite3_result_text(pCtx, "fts5: 2016-11-04 12:08:49 1136863c76576110e710dd5d69ab6bf347c65e36", -1, SQLITE_TRANSIENT);
195664
+ sqlite3_result_text(pCtx, "fts5: 2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8", -1, SQLITE_TRANSIENT);
195627195665
 }
195628195666
195629195667
 static int fts5Init(sqlite3 *db){
195630195668
 static const sqlite3_module fts5Mod = {
195631195669
 /* iVersion */ 2,
195632195670
--- src/sqlite3.c
+++ src/sqlite3.c
@@ -1,8 +1,8 @@
1 /******************************************************************************
2 ** This file is an amalgamation of many separate C source files from SQLite
3 ** version 3.15.1. By combining all the individual C code files into this
4 ** single large file, the entire code can be compiled as a single translation
5 ** unit. This allows many compilers to do optimizations that would not be
6 ** possible if the files were compiled separately. Performance improvements
7 ** of 5% or more are commonly seen when SQLite is compiled as a single
8 ** translation unit.
@@ -379,13 +379,13 @@
379 **
380 ** See also: [sqlite3_libversion()],
381 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
382 ** [sqlite_version()] and [sqlite_source_id()].
383 */
384 #define SQLITE_VERSION "3.15.1"
385 #define SQLITE_VERSION_NUMBER 3015001
386 #define SQLITE_SOURCE_ID "2016-11-04 12:08:49 1136863c76576110e710dd5d69ab6bf347c65e36"
387
388 /*
389 ** CAPI3REF: Run-Time Library Version Numbers
390 ** KEYWORDS: sqlite3_version, sqlite3_sourceid
391 **
@@ -15581,19 +15581,19 @@
15581 int iReg; /* Reg with value of this column. 0 means none. */
15582 int lru; /* Least recently used entry has the smallest value */
15583 } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
15584 int aTempReg[8]; /* Holding area for temporary registers */
15585 Token sNameToken; /* Token with unqualified schema object name */
15586 Token sLastToken; /* The last token parsed */
15587
15588 /************************************************************************
15589 ** Above is constant between recursions. Below is reset before and after
15590 ** each recursion. The boundary between these two regions is determined
15591 ** using offsetof(Parse,nVar) so the nVar field must be the first field
15592 ** in the recursive region.
15593 ************************************************************************/
15594
 
15595 ynVar nVar; /* Number of '?' variables seen in the SQL so far */
15596 int nzVar; /* Number of available slots in azVar[] */
15597 u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */
15598 u8 explain; /* True if the EXPLAIN flag is found on the query */
15599 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -15623,11 +15623,11 @@
15623
15624 /*
15625 ** Sizes and pointers of various parts of the Parse object.
15626 */
15627 #define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
15628 #define PARSE_RECURSE_SZ offsetof(Parse,nVar) /* Recursive part */
15629 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
15630 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
15631
15632 /*
15633 ** Return true if currently inside an sqlite3_declare_vtab() call.
@@ -88582,10 +88582,14 @@
88582 assert( pExpr->x.pSelect==0 );
88583 pOrig = pEList->a[j].pExpr;
88584 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
88585 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
88586 return WRC_Abort;
 
 
 
 
88587 }
88588 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
88589 cnt = 1;
88590 pMatch = 0;
88591 assert( zTab==0 && zDb==0 );
@@ -88959,10 +88963,11 @@
88959 }
88960 case TK_VARIABLE: {
88961 notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
88962 break;
88963 }
 
88964 case TK_EQ:
88965 case TK_NE:
88966 case TK_LT:
88967 case TK_LE:
88968 case TK_GT:
@@ -88969,23 +88974,31 @@
88969 case TK_GE:
88970 case TK_IS:
88971 case TK_ISNOT: {
88972 int nLeft, nRight;
88973 if( pParse->db->mallocFailed ) break;
88974 assert( pExpr->pRight!=0 );
88975 assert( pExpr->pLeft!=0 );
88976 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
88977 nRight = sqlite3ExprVectorSize(pExpr->pRight);
 
 
 
 
 
 
 
 
88978 if( nLeft!=nRight ){
88979 testcase( pExpr->op==TK_EQ );
88980 testcase( pExpr->op==TK_NE );
88981 testcase( pExpr->op==TK_LT );
88982 testcase( pExpr->op==TK_LE );
88983 testcase( pExpr->op==TK_GT );
88984 testcase( pExpr->op==TK_GE );
88985 testcase( pExpr->op==TK_IS );
88986 testcase( pExpr->op==TK_ISNOT );
 
88987 sqlite3ErrorMsg(pParse, "row value misused");
88988 }
88989 break;
88990 }
88991 }
@@ -93010,11 +93023,11 @@
93010 }else{
93011 int i;
93012 iResult = pParse->nMem+1;
93013 pParse->nMem += nResult;
93014 for(i=0; i<nResult; i++){
93015 sqlite3ExprCode(pParse, p->x.pList->a[i].pExpr, i+iResult);
93016 }
93017 }
93018 }
93019 return iResult;
93020 }
@@ -97762,10 +97775,11 @@
97762 NameContext sName;
97763 Vdbe *v;
97764 sqlite3* db = pParse->db;
97765 int regArgs;
97766
 
97767 memset(&sName, 0, sizeof(NameContext));
97768 sName.pParse = pParse;
97769
97770 if(
97771 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
@@ -104307,10 +104321,12 @@
104307 isText = 0;
104308 }else{
104309 zHaystack = sqlite3_value_text(argv[0]);
104310 zNeedle = sqlite3_value_text(argv[1]);
104311 isText = 1;
 
 
104312 }
104313 while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){
104314 N++;
104315 do{
104316 nHaystack--;
@@ -124769,10 +124785,11 @@
124769 if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){
124770 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0);
124771 }else{
124772 Select *pSelect = pX->x.pSelect;
124773 sqlite3 *db = pParse->db;
 
124774 ExprList *pOrigRhs = pSelect->pEList;
124775 ExprList *pOrigLhs = pX->pLeft->x.pList;
124776 ExprList *pRhs = 0; /* New Select.pEList for RHS */
124777 ExprList *pLhs = 0; /* New pX->pLeft vector */
124778
@@ -124812,11 +124829,13 @@
124812 pLeft->x.pList = pLhs;
124813 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int) * nEq);
124814 testcase( aiMap==0 );
124815 }
124816 pSelect->pEList = pRhs;
 
124817 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap);
 
124818 testcase( aiMap!=0 && aiMap[0]!=0 );
124819 pSelect->pEList = pOrigRhs;
124820 pLeft->x.pList = pOrigLhs;
124821 pX->pLeft = pLeft;
124822 }
@@ -127631,10 +127650,12 @@
127631 #endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */
127632
127633 /* Prevent ON clause terms of a LEFT JOIN from being used to drive
127634 ** an index for tables to the left of the join.
127635 */
 
 
127636 pTerm->prereqRight |= extraRight;
127637 }
127638
127639 /***************************************************************************
127640 ** Routines with file scope above. Interface to the rest of the where.c
@@ -165383,24 +165404,24 @@
165383 int nArg; /* Number of arguments */
165384 int enc; /* Optimal text encoding */
165385 void *pContext; /* sqlite3_user_data() context */
165386 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
165387 } scalars[] = {
165388 {"regexp", 2, SQLITE_ANY, 0, icuRegexpFunc},
165389
165390 {"lower", 1, SQLITE_UTF16, 0, icuCaseFunc16},
165391 {"lower", 2, SQLITE_UTF16, 0, icuCaseFunc16},
165392 {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
165393 {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
165394
165395 {"lower", 1, SQLITE_UTF8, 0, icuCaseFunc16},
165396 {"lower", 2, SQLITE_UTF8, 0, icuCaseFunc16},
165397 {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16},
165398 {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16},
165399
165400 {"like", 2, SQLITE_UTF8, 0, icuLikeFunc},
165401 {"like", 3, SQLITE_UTF8, 0, icuLikeFunc},
165402
165403 {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
165404 };
165405
165406 int rc = SQLITE_OK;
@@ -176414,17 +176435,19 @@
176414 ** to pass signed char values.
176415 */
176416 #ifdef sqlite3Isdigit
176417 /* Use the SQLite core versions if this routine is part of the
176418 ** SQLite amalgamation */
176419 # define safe_isdigit(x) sqlite3Isdigit(x)
176420 # define safe_isalnum(x) sqlite3Isalnum(x)
 
176421 #else
176422 /* Use the standard library for separate compilation */
176423 #include <ctype.h> /* amalgamator: keep */
176424 # define safe_isdigit(x) isdigit((unsigned char)(x))
176425 # define safe_isalnum(x) isalnum((unsigned char)(x))
 
176426 #endif
176427
176428 /*
176429 ** Growing our own isspace() routine this way is twice as fast as
176430 ** the library isspace() function, resulting in a 7% overall performance
@@ -177066,10 +177089,19 @@
177066 p->iVal = 0;
177067 p->n = n;
177068 p->u.zJContent = zContent;
177069 return pParse->nNode++;
177070 }
 
 
 
 
 
 
 
 
 
177071
177072 /*
177073 ** Parse a single JSON value which begins at pParse->zJson[i]. Return the
177074 ** index of the first character past the end of the value parsed.
177075 **
@@ -177141,12 +177173,17 @@
177141 for(;;){
177142 c = pParse->zJson[j];
177143 if( c==0 ) return -1;
177144 if( c=='\\' ){
177145 c = pParse->zJson[++j];
177146 if( c==0 ) return -1;
177147 jnFlags = JNODE_ESCAPE;
 
 
 
 
 
177148 }else if( c=='"' ){
177149 break;
177150 }
177151 j++;
177152 }
@@ -178010,11 +178047,11 @@
178010 JsonString *pStr;
178011 pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
178012 if( pStr ){
178013 jsonAppendChar(pStr, '}');
178014 if( pStr->bErr ){
178015 if( pStr->bErr==0 ) sqlite3_result_error_nomem(ctx);
178016 assert( pStr->bStatic );
178017 }else{
178018 sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
178019 pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
178020 pStr->bStatic = 1;
@@ -178288,13 +178325,13 @@
178288 break;
178289 }
178290 /* For json_each() path and root are the same so fall through
178291 ** into the root case */
178292 }
178293 case JEACH_ROOT: {
178294 const char *zRoot = p->zRoot;
178295 if( zRoot==0 ) zRoot = "$";
178296 sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC);
178297 break;
178298 }
178299 case JEACH_JSON: {
178300 assert( i==JEACH_JSON );
@@ -184217,11 +184254,11 @@
184217 pNode->bEof = 1;
184218 return rc;
184219 }
184220 }else{
184221 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
184222 if( pIter->iRowid==iLast ) continue;
184223 bMatch = 0;
184224 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
184225 return rc;
184226 }
184227 }
@@ -189357,10 +189394,11 @@
189357 Fts5Iter *pIter,
189358 int bFrom, /* True if argument iFrom is valid */
189359 i64 iFrom /* Advance at least as far as this */
189360 ){
189361 int bUseFrom = bFrom;
 
189362 while( p->rc==SQLITE_OK ){
189363 int iFirst = pIter->aFirst[1].iFirst;
189364 int bNewTerm = 0;
189365 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
189366 assert( p->rc==SQLITE_OK );
@@ -195621,11 +195659,11 @@
195621 int nArg, /* Number of args */
195622 sqlite3_value **apUnused /* Function arguments */
195623 ){
195624 assert( nArg==0 );
195625 UNUSED_PARAM2(nArg, apUnused);
195626 sqlite3_result_text(pCtx, "fts5: 2016-11-04 12:08:49 1136863c76576110e710dd5d69ab6bf347c65e36", -1, SQLITE_TRANSIENT);
195627 }
195628
195629 static int fts5Init(sqlite3 *db){
195630 static const sqlite3_module fts5Mod = {
195631 /* iVersion */ 2,
195632
--- src/sqlite3.c
+++ src/sqlite3.c
@@ -1,8 +1,8 @@
1 /******************************************************************************
2 ** This file is an amalgamation of many separate C source files from SQLite
3 ** version 3.15.2. By combining all the individual C code files into this
4 ** single large file, the entire code can be compiled as a single translation
5 ** unit. This allows many compilers to do optimizations that would not be
6 ** possible if the files were compiled separately. Performance improvements
7 ** of 5% or more are commonly seen when SQLite is compiled as a single
8 ** translation unit.
@@ -379,13 +379,13 @@
379 **
380 ** See also: [sqlite3_libversion()],
381 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
382 ** [sqlite_version()] and [sqlite_source_id()].
383 */
384 #define SQLITE_VERSION "3.15.2"
385 #define SQLITE_VERSION_NUMBER 3015002
386 #define SQLITE_SOURCE_ID "2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8"
387
388 /*
389 ** CAPI3REF: Run-Time Library Version Numbers
390 ** KEYWORDS: sqlite3_version, sqlite3_sourceid
391 **
@@ -15581,19 +15581,19 @@
15581 int iReg; /* Reg with value of this column. 0 means none. */
15582 int lru; /* Least recently used entry has the smallest value */
15583 } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
15584 int aTempReg[8]; /* Holding area for temporary registers */
15585 Token sNameToken; /* Token with unqualified schema object name */
 
15586
15587 /************************************************************************
15588 ** Above is constant between recursions. Below is reset before and after
15589 ** each recursion. The boundary between these two regions is determined
15590 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
15591 ** first field in the recursive region.
15592 ************************************************************************/
15593
15594 Token sLastToken; /* The last token parsed */
15595 ynVar nVar; /* Number of '?' variables seen in the SQL so far */
15596 int nzVar; /* Number of available slots in azVar[] */
15597 u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */
15598 u8 explain; /* True if the EXPLAIN flag is found on the query */
15599 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -15623,11 +15623,11 @@
15623
15624 /*
15625 ** Sizes and pointers of various parts of the Parse object.
15626 */
15627 #define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
15628 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
15629 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
15630 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
15631
15632 /*
15633 ** Return true if currently inside an sqlite3_declare_vtab() call.
@@ -88582,10 +88582,14 @@
88582 assert( pExpr->x.pSelect==0 );
88583 pOrig = pEList->a[j].pExpr;
88584 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
88585 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
88586 return WRC_Abort;
88587 }
88588 if( sqlite3ExprVectorSize(pOrig)!=1 ){
88589 sqlite3ErrorMsg(pParse, "row value misused");
88590 return WRC_Abort;
88591 }
88592 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
88593 cnt = 1;
88594 pMatch = 0;
88595 assert( zTab==0 && zDb==0 );
@@ -88959,10 +88963,11 @@
88963 }
88964 case TK_VARIABLE: {
88965 notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
88966 break;
88967 }
88968 case TK_BETWEEN:
88969 case TK_EQ:
88970 case TK_NE:
88971 case TK_LT:
88972 case TK_LE:
88973 case TK_GT:
@@ -88969,23 +88974,31 @@
88974 case TK_GE:
88975 case TK_IS:
88976 case TK_ISNOT: {
88977 int nLeft, nRight;
88978 if( pParse->db->mallocFailed ) break;
 
88979 assert( pExpr->pLeft!=0 );
88980 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
88981 if( pExpr->op==TK_BETWEEN ){
88982 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
88983 if( nRight==nLeft ){
88984 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
88985 }
88986 }else{
88987 assert( pExpr->pRight!=0 );
88988 nRight = sqlite3ExprVectorSize(pExpr->pRight);
88989 }
88990 if( nLeft!=nRight ){
88991 testcase( pExpr->op==TK_EQ );
88992 testcase( pExpr->op==TK_NE );
88993 testcase( pExpr->op==TK_LT );
88994 testcase( pExpr->op==TK_LE );
88995 testcase( pExpr->op==TK_GT );
88996 testcase( pExpr->op==TK_GE );
88997 testcase( pExpr->op==TK_IS );
88998 testcase( pExpr->op==TK_ISNOT );
88999 testcase( pExpr->op==TK_BETWEEN );
89000 sqlite3ErrorMsg(pParse, "row value misused");
89001 }
89002 break;
89003 }
89004 }
@@ -93010,11 +93023,11 @@
93023 }else{
93024 int i;
93025 iResult = pParse->nMem+1;
93026 pParse->nMem += nResult;
93027 for(i=0; i<nResult; i++){
93028 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
93029 }
93030 }
93031 }
93032 return iResult;
93033 }
@@ -97762,10 +97775,11 @@
97775 NameContext sName;
97776 Vdbe *v;
97777 sqlite3* db = pParse->db;
97778 int regArgs;
97779
97780 if( pParse->nErr ) goto attach_end;
97781 memset(&sName, 0, sizeof(NameContext));
97782 sName.pParse = pParse;
97783
97784 if(
97785 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
@@ -104307,10 +104321,12 @@
104321 isText = 0;
104322 }else{
104323 zHaystack = sqlite3_value_text(argv[0]);
104324 zNeedle = sqlite3_value_text(argv[1]);
104325 isText = 1;
104326 if( zNeedle==0 ) return;
104327 assert( zHaystack );
104328 }
104329 while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){
104330 N++;
104331 do{
104332 nHaystack--;
@@ -124769,10 +124785,11 @@
124785 if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){
124786 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0);
124787 }else{
124788 Select *pSelect = pX->x.pSelect;
124789 sqlite3 *db = pParse->db;
124790 u16 savedDbOptFlags = db->dbOptFlags;
124791 ExprList *pOrigRhs = pSelect->pEList;
124792 ExprList *pOrigLhs = pX->pLeft->x.pList;
124793 ExprList *pRhs = 0; /* New Select.pEList for RHS */
124794 ExprList *pLhs = 0; /* New pX->pLeft vector */
124795
@@ -124812,11 +124829,13 @@
124829 pLeft->x.pList = pLhs;
124830 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int) * nEq);
124831 testcase( aiMap==0 );
124832 }
124833 pSelect->pEList = pRhs;
124834 db->dbOptFlags |= SQLITE_QueryFlattener;
124835 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap);
124836 db->dbOptFlags = savedDbOptFlags;
124837 testcase( aiMap!=0 && aiMap[0]!=0 );
124838 pSelect->pEList = pOrigRhs;
124839 pLeft->x.pList = pOrigLhs;
124840 pX->pLeft = pLeft;
124841 }
@@ -127631,10 +127650,12 @@
127650 #endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */
127651
127652 /* Prevent ON clause terms of a LEFT JOIN from being used to drive
127653 ** an index for tables to the left of the join.
127654 */
127655 testcase( pTerm!=&pWC->a[idxTerm] );
127656 pTerm = &pWC->a[idxTerm];
127657 pTerm->prereqRight |= extraRight;
127658 }
127659
127660 /***************************************************************************
127661 ** Routines with file scope above. Interface to the rest of the where.c
@@ -165383,24 +165404,24 @@
165404 int nArg; /* Number of arguments */
165405 int enc; /* Optimal text encoding */
165406 void *pContext; /* sqlite3_user_data() context */
165407 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
165408 } scalars[] = {
165409 {"regexp", 2, SQLITE_ANY|SQLITE_DETERMINISTIC, 0, icuRegexpFunc},
165410
165411 {"lower", 1, SQLITE_UTF16|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165412 {"lower", 2, SQLITE_UTF16|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165413 {"upper", 1, SQLITE_UTF16|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165414 {"upper", 2, SQLITE_UTF16|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165415
165416 {"lower", 1, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165417 {"lower", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
165418 {"upper", 1, SQLITE_UTF8|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165419 {"upper", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
165420
165421 {"like", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuLikeFunc},
165422 {"like", 3, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuLikeFunc},
165423
165424 {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
165425 };
165426
165427 int rc = SQLITE_OK;
@@ -176414,17 +176435,19 @@
176435 ** to pass signed char values.
176436 */
176437 #ifdef sqlite3Isdigit
176438 /* Use the SQLite core versions if this routine is part of the
176439 ** SQLite amalgamation */
176440 # define safe_isdigit(x) sqlite3Isdigit(x)
176441 # define safe_isalnum(x) sqlite3Isalnum(x)
176442 # define safe_isxdigit(x) sqlite3Isxdigit(x)
176443 #else
176444 /* Use the standard library for separate compilation */
176445 #include <ctype.h> /* amalgamator: keep */
176446 # define safe_isdigit(x) isdigit((unsigned char)(x))
176447 # define safe_isalnum(x) isalnum((unsigned char)(x))
176448 # define safe_isxdigit(x) isxdigit((unsigned char)(x))
176449 #endif
176450
176451 /*
176452 ** Growing our own isspace() routine this way is twice as fast as
176453 ** the library isspace() function, resulting in a 7% overall performance
@@ -177066,10 +177089,19 @@
177089 p->iVal = 0;
177090 p->n = n;
177091 p->u.zJContent = zContent;
177092 return pParse->nNode++;
177093 }
177094
177095 /*
177096 ** Return true if z[] begins with 4 (or more) hexadecimal digits
177097 */
177098 static int jsonIs4Hex(const char *z){
177099 int i;
177100 for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0;
177101 return 1;
177102 }
177103
177104 /*
177105 ** Parse a single JSON value which begins at pParse->zJson[i]. Return the
177106 ** index of the first character past the end of the value parsed.
177107 **
@@ -177141,12 +177173,17 @@
177173 for(;;){
177174 c = pParse->zJson[j];
177175 if( c==0 ) return -1;
177176 if( c=='\\' ){
177177 c = pParse->zJson[++j];
177178 if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f'
177179 || c=='n' || c=='r' || c=='t'
177180 || (c=='u' && jsonIs4Hex(pParse->zJson+j+1)) ){
177181 jnFlags = JNODE_ESCAPE;
177182 }else{
177183 return -1;
177184 }
177185 }else if( c=='"' ){
177186 break;
177187 }
177188 j++;
177189 }
@@ -178010,11 +178047,11 @@
178047 JsonString *pStr;
178048 pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
178049 if( pStr ){
178050 jsonAppendChar(pStr, '}');
178051 if( pStr->bErr ){
178052 if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
178053 assert( pStr->bStatic );
178054 }else{
178055 sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
178056 pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
178057 pStr->bStatic = 1;
@@ -178288,13 +178325,13 @@
178325 break;
178326 }
178327 /* For json_each() path and root are the same so fall through
178328 ** into the root case */
178329 }
178330 default: {
178331 const char *zRoot = p->zRoot;
178332 if( zRoot==0 ) zRoot = "$";
178333 sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC);
178334 break;
178335 }
178336 case JEACH_JSON: {
178337 assert( i==JEACH_JSON );
@@ -184217,11 +184254,11 @@
184254 pNode->bEof = 1;
184255 return rc;
184256 }
184257 }else{
184258 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
184259 if( pIter->iRowid==iLast || pIter->bEof ) continue;
184260 bMatch = 0;
184261 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
184262 return rc;
184263 }
184264 }
@@ -189357,10 +189394,11 @@
189394 Fts5Iter *pIter,
189395 int bFrom, /* True if argument iFrom is valid */
189396 i64 iFrom /* Advance at least as far as this */
189397 ){
189398 int bUseFrom = bFrom;
189399 assert( pIter->base.bEof==0 );
189400 while( p->rc==SQLITE_OK ){
189401 int iFirst = pIter->aFirst[1].iFirst;
189402 int bNewTerm = 0;
189403 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
189404 assert( p->rc==SQLITE_OK );
@@ -195621,11 +195659,11 @@
195659 int nArg, /* Number of args */
195660 sqlite3_value **apUnused /* Function arguments */
195661 ){
195662 assert( nArg==0 );
195663 UNUSED_PARAM2(nArg, apUnused);
195664 sqlite3_result_text(pCtx, "fts5: 2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8", -1, SQLITE_TRANSIENT);
195665 }
195666
195667 static int fts5Init(sqlite3 *db){
195668 static const sqlite3_module fts5Mod = {
195669 /* iVersion */ 2,
195670
M src/sqlite3.h
+3 -3
--- src/sqlite3.h
+++ src/sqlite3.h
@@ -119,13 +119,13 @@
119119
 **
120120
 ** See also: [sqlite3_libversion()],
121121
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
122122
 ** [sqlite_version()] and [sqlite_source_id()].
123123
 */
124
-#define SQLITE_VERSION "3.15.1"
125
-#define SQLITE_VERSION_NUMBER 3015001
126
-#define SQLITE_SOURCE_ID "2016-11-04 12:08:49 1136863c76576110e710dd5d69ab6bf347c65e36"
124
+#define SQLITE_VERSION "3.15.2"
125
+#define SQLITE_VERSION_NUMBER 3015002
126
+#define SQLITE_SOURCE_ID "2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8"
127127
128128
 /*
129129
 ** CAPI3REF: Run-Time Library Version Numbers
130130
 ** KEYWORDS: sqlite3_version, sqlite3_sourceid
131131
 **
132132
--- src/sqlite3.h
+++ src/sqlite3.h
@@ -119,13 +119,13 @@
119 **
120 ** See also: [sqlite3_libversion()],
121 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
122 ** [sqlite_version()] and [sqlite_source_id()].
123 */
124 #define SQLITE_VERSION "3.15.1"
125 #define SQLITE_VERSION_NUMBER 3015001
126 #define SQLITE_SOURCE_ID "2016-11-04 12:08:49 1136863c76576110e710dd5d69ab6bf347c65e36"
127
128 /*
129 ** CAPI3REF: Run-Time Library Version Numbers
130 ** KEYWORDS: sqlite3_version, sqlite3_sourceid
131 **
132
--- src/sqlite3.h
+++ src/sqlite3.h
@@ -119,13 +119,13 @@
119 **
120 ** See also: [sqlite3_libversion()],
121 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
122 ** [sqlite_version()] and [sqlite_source_id()].
123 */
124 #define SQLITE_VERSION "3.15.2"
125 #define SQLITE_VERSION_NUMBER 3015002
126 #define SQLITE_SOURCE_ID "2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8"
127
128 /*
129 ** CAPI3REF: Run-Time Library Version Numbers
130 ** KEYWORDS: sqlite3_version, sqlite3_sourceid
131 **
132

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button