Fossil SCM

Update the built-in SQLite to version 3.36.0

drh 2021-06-18 20:25 trunk
Commit 3a97dff2cf7937cf11ce6fdb1e5cfa1933f9838202e91810ae0cc2368d8e6e5f
Parent 50615990313cfe5…
3 files changed +3 +43 -31 +5 -5
~ src/shell.c ~ src/sqlite3.c ~ src/sqlite3.h
M src/shell.c
+3
--- src/shell.c
+++ src/shell.c
@@ -242,10 +242,11 @@
242242
 /* Return the current wall-clock time */
243243
 static sqlite3_int64 timeOfDay(void){
244244
 static sqlite3_vfs *clockVfs = 0;
245245
 sqlite3_int64 t;
246246
 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
247
+ if( clockVfs==0 ) return 0; /* Never actually happens */
247248
 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
248249
 clockVfs->xCurrentTimeInt64(clockVfs, &t);
249250
 }else{
250251
 double r;
251252
 clockVfs->xCurrentTime(clockVfs, &r);
@@ -4281,10 +4282,11 @@
42814282
 sqlite3_vfs *pOrig;
42824283
 SQLITE_EXTENSION_INIT2(pApi);
42834284
 (void)pzErrMsg;
42844285
 (void)db;
42854286
 pOrig = sqlite3_vfs_find(0);
4287
+ if( pOrig==0 ) return SQLITE_ERROR;
42864288
 apnd_vfs.iVersion = pOrig->iVersion;
42874289
 apnd_vfs.pAppData = pOrig;
42884290
 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile);
42894291
 rc = sqlite3_vfs_register(&apnd_vfs, 0);
42904292
 #ifdef APPENDVFS_TEST
@@ -8143,10 +8145,11 @@
81438145
 ** time(2)).
81448146
 */
81458147
 static u32 zipfileTime(void){
81468148
 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
81478149
 u32 ret;
8150
+ if( pVfs==0 ) return 0;
81488151
 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
81498152
 i64 ms;
81508153
 pVfs->xCurrentTimeInt64(pVfs, &ms);
81518154
 ret = (u32)((ms/1000) - ((i64)24405875 * 8640));
81528155
 }else{
81538156
--- src/shell.c
+++ src/shell.c
@@ -242,10 +242,11 @@
242 /* Return the current wall-clock time */
243 static sqlite3_int64 timeOfDay(void){
244 static sqlite3_vfs *clockVfs = 0;
245 sqlite3_int64 t;
246 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
 
247 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
248 clockVfs->xCurrentTimeInt64(clockVfs, &t);
249 }else{
250 double r;
251 clockVfs->xCurrentTime(clockVfs, &r);
@@ -4281,10 +4282,11 @@
4281 sqlite3_vfs *pOrig;
4282 SQLITE_EXTENSION_INIT2(pApi);
4283 (void)pzErrMsg;
4284 (void)db;
4285 pOrig = sqlite3_vfs_find(0);
 
4286 apnd_vfs.iVersion = pOrig->iVersion;
4287 apnd_vfs.pAppData = pOrig;
4288 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile);
4289 rc = sqlite3_vfs_register(&apnd_vfs, 0);
4290 #ifdef APPENDVFS_TEST
@@ -8143,10 +8145,11 @@
8143 ** time(2)).
8144 */
8145 static u32 zipfileTime(void){
8146 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
8147 u32 ret;
 
8148 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
8149 i64 ms;
8150 pVfs->xCurrentTimeInt64(pVfs, &ms);
8151 ret = (u32)((ms/1000) - ((i64)24405875 * 8640));
8152 }else{
8153
--- src/shell.c
+++ src/shell.c
@@ -242,10 +242,11 @@
242 /* Return the current wall-clock time */
243 static sqlite3_int64 timeOfDay(void){
244 static sqlite3_vfs *clockVfs = 0;
245 sqlite3_int64 t;
246 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
247 if( clockVfs==0 ) return 0; /* Never actually happens */
248 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
249 clockVfs->xCurrentTimeInt64(clockVfs, &t);
250 }else{
251 double r;
252 clockVfs->xCurrentTime(clockVfs, &r);
@@ -4281,10 +4282,11 @@
4282 sqlite3_vfs *pOrig;
4283 SQLITE_EXTENSION_INIT2(pApi);
4284 (void)pzErrMsg;
4285 (void)db;
4286 pOrig = sqlite3_vfs_find(0);
4287 if( pOrig==0 ) return SQLITE_ERROR;
4288 apnd_vfs.iVersion = pOrig->iVersion;
4289 apnd_vfs.pAppData = pOrig;
4290 apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile);
4291 rc = sqlite3_vfs_register(&apnd_vfs, 0);
4292 #ifdef APPENDVFS_TEST
@@ -8143,10 +8145,11 @@
8145 ** time(2)).
8146 */
8147 static u32 zipfileTime(void){
8148 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
8149 u32 ret;
8150 if( pVfs==0 ) return 0;
8151 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
8152 i64 ms;
8153 pVfs->xCurrentTimeInt64(pVfs, &ms);
8154 ret = (u32)((ms/1000) - ((i64)24405875 * 8640));
8155 }else{
8156
M src/sqlite3.c
+43 -31
--- src/sqlite3.c
+++ src/sqlite3.c
@@ -1205,11 +1205,11 @@
12051205
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
12061206
 ** [sqlite_version()] and [sqlite_source_id()].
12071207
 */
12081208
 #define SQLITE_VERSION "3.36.0"
12091209
 #define SQLITE_VERSION_NUMBER 3036000
1210
-#define SQLITE_SOURCE_ID "2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9ef70"
1210
+#define SQLITE_SOURCE_ID "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5"
12111211
12121212
 /*
12131213
 ** CAPI3REF: Run-Time Library Version Numbers
12141214
 ** KEYWORDS: sqlite3_version sqlite3_sourceid
12151215
 **
@@ -5458,21 +5458,21 @@
54585458
 ** contain embedded NULs. The result of expressions involving strings
54595459
 ** with embedded NULs is undefined.
54605460
 **
54615461
 ** ^The fifth argument to the BLOB and string binding interfaces controls
54625462
 ** or indicates the lifetime of the object referenced by the third parameter.
5463
-** ^These three options exist:
5464
-** ^(1) A destructor to dispose of the BLOB or string after SQLite has finished
5463
+** These three options exist:
5464
+** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
54655465
 ** with it may be passed. ^It is called to dispose of the BLOB or string even
54665466
 ** if the call to the bind API fails, except the destructor is not called if
54675467
 ** the third parameter is a NULL pointer or the fourth parameter is negative.
5468
-** ^(2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
5468
+** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
54695469
 ** the application remains responsible for disposing of the object. ^In this
54705470
 ** case, the object and the provided pointer to it must remain valid until
54715471
 ** either the prepared statement is finalized or the same SQL parameter is
54725472
 ** bound to something else, whichever occurs sooner.
5473
-** ^(3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
5473
+** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
54745474
 ** object is to be copied prior to the return from sqlite3_bind_*(). ^The
54755475
 ** object and pointer to it must remain valid until then. ^SQLite will then
54765476
 ** manage the lifetime of its private copy.
54775477
 **
54785478
 ** ^The sixth argument to sqlite3_bind_text64() must be one of
@@ -30798,15 +30798,20 @@
3079830798
 ** Nothing in this file or anywhere else in SQLite does any kind of
3079930799
 ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random
3080030800
 ** number generator) not as an encryption device.
3080130801
 */
3080230802
 if( !wsdPrng.isInit ){
30803
+ sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
3080330804
 int i;
3080430805
 char k[256];
3080530806
 wsdPrng.j = 0;
3080630807
 wsdPrng.i = 0;
30807
- sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
30808
+ if( NEVER(pVfs==0) ){
30809
+ memset(k, 0, sizeof(k));
30810
+ }else{
30811
+ sqlite3OsRandomness(pVfs, 256, k);
30812
+ }
3080830813
 for(i=0; i<256; i++){
3080930814
 wsdPrng.s[i] = (u8)i;
3081030815
 }
3081130816
 for(i=0; i<256; i++){
3081230817
 wsdPrng.j += wsdPrng.s[i] + k[i];
@@ -42119,10 +42124,11 @@
4211942124
 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
4212042125
 sqlite3_vfs_register(&aVfs[i], i==0);
4212142126
 }
4212242127
 unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
4212342128
42129
+#ifndef SQLITE_OMIT_WAL
4212442130
 /* Validate lock assumptions */
4212542131
 assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */
4212642132
 assert( UNIX_SHM_BASE==120 ); /* Start of locking area */
4212742133
 /* Locks:
4212842134
 ** WRITE UNIX_SHM_BASE 120
@@ -42134,10 +42140,12 @@
4213442140
 ** READ-3 UNIX_SHM_BASE+6 126
4213542141
 ** READ-4 UNIX_SHM_BASE+7 127
4213642142
 ** DMS UNIX_SHM_BASE+8 128
4213742143
 */
4213842144
 assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
42145
+#endif
42146
+
4213942147
 return SQLITE_OK;
4214042148
 }
4214142149
4214242150
 /*
4214342151
 ** Shutdown the operating system interface.
@@ -49371,11 +49379,13 @@
4937149379
 ** This routine is called when the extension is loaded.
4937249380
 ** Register the new VFS.
4937349381
 */
4937449382
 SQLITE_PRIVATE int sqlite3MemdbInit(void){
4937549383
 sqlite3_vfs *pLower = sqlite3_vfs_find(0);
49376
- unsigned int sz = pLower->szOsFile;
49384
+ unsigned int sz;
49385
+ if( NEVER(pLower==0) ) return SQLITE_ERROR;
49386
+ sz = pLower->szOsFile;
4937749387
 memdb_vfs.pAppData = pLower;
4937849388
 /* The following conditional can only be true when compiled for
4937949389
 ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave
4938049390
 ** it in, to be safe, but it is marked as NO_TEST since there
4938149391
 ** is no way to reach it under most builds. */
@@ -96378,12 +96388,13 @@
9637896388
 int iTask = (pTask - pTask->pSorter->aTask);
9637996389
 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
9638096390
 fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent);
9638196391
 }
9638296392
 static void vdbeSorterRewindDebug(const char *zEvent){
96383
- i64 t;
96384
- sqlite3OsCurrentTimeInt64(sqlite3_vfs_find(0), &t);
96393
+ i64 t = 0;
96394
+ sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
96395
+ if( ALWAYS(pVfs) ) sqlite3OsCurrentTimeInt64(pVfs, &t);
9638596396
 fprintf(stderr, "%lld:X %s\n", t, zEvent);
9638696397
 }
9638796398
 static void vdbeSorterPopulateDebug(
9638896399
 SortSubtask *pTask,
9638996400
 const char *zEvent
@@ -108240,12 +108251,12 @@
108240108251
 static int renameUnmapSelectCb(Walker *pWalker, Select *p){
108241108252
 Parse *pParse = pWalker->pParse;
108242108253
 int i;
108243108254
 if( pParse->nErr ) return WRC_Abort;
108244108255
 if( p->selFlags & (SF_View|SF_CopyCte) ){
108245
- testcase( pSelect->selFlags & SF_View );
108246
- testcase( pSelect->selFlags & SF_CopyCte );
108256
+ testcase( p->selFlags & SF_View );
108257
+ testcase( p->selFlags & SF_CopyCte );
108247108258
 return WRC_Prune;
108248108259
 }
108249108260
 if( ALWAYS(p->pEList) ){
108250108261
 ExprList *pList = p->pEList;
108251108262
 for(i=0; i<pList->nExpr; i++){
@@ -108352,12 +108363,12 @@
108352108363
 ** because without a dummy callback, sqlite3WalkExpr() and similar do not
108353108364
 ** descend into sub-select statements.
108354108365
 */
108355108366
 static int renameColumnSelectCb(Walker *pWalker, Select *p){
108356108367
 if( p->selFlags & (SF_View|SF_CopyCte) ){
108357
- testcase( pSelect->selFlags & SF_View );
108358
- testcase( pSelect->selFlags & SF_CopyCte );
108368
+ testcase( p->selFlags & SF_View );
108369
+ testcase( p->selFlags & SF_CopyCte );
108359108370
 return WRC_Prune;
108360108371
 }
108361108372
 renameWalkWith(pWalker, p);
108362108373
 return WRC_Continue;
108363108374
 }
@@ -108549,17 +108560,17 @@
108549108560
 RenameCtx *pRename, /* Rename context */
108550108561
 const char *zSql, /* SQL statement to edit */
108551108562
 const char *zNew, /* New token text */
108552108563
 int bQuote /* True to always quote token */
108553108564
 ){
108554
- int nNew = sqlite3Strlen30(zNew);
108555
- int nSql = sqlite3Strlen30(zSql);
108565
+ i64 nNew = sqlite3Strlen30(zNew);
108566
+ i64 nSql = sqlite3Strlen30(zSql);
108556108567
 sqlite3 *db = sqlite3_context_db_handle(pCtx);
108557108568
 int rc = SQLITE_OK;
108558108569
 char *zQuot = 0;
108559108570
 char *zOut;
108560
- int nQuot = 0;
108571
+ i64 nQuot = 0;
108561108572
 char *zBuf1 = 0;
108562108573
 char *zBuf2 = 0;
108563108574
108564108575
 if( zNew ){
108565108576
 /* Set zQuot to point to a buffer containing a quoted copy of the
@@ -120617,29 +120628,29 @@
120617120628
 int argc,
120618120629
 sqlite3_value **argv
120619120630
 ){
120620120631
 const unsigned char *zIn; /* Input string */
120621120632
 const unsigned char *zCharSet; /* Set of characters to trim */
120622
- int nIn; /* Number of bytes in input */
120633
+ unsigned int nIn; /* Number of bytes in input */
120623120634
 int flags; /* 1: trimleft 2: trimright 3: trim */
120624120635
 int i; /* Loop counter */
120625
- unsigned char *aLen = 0; /* Length of each character in zCharSet */
120636
+ unsigned int *aLen = 0; /* Length of each character in zCharSet */
120626120637
 unsigned char **azChar = 0; /* Individual characters in zCharSet */
120627120638
 int nChar; /* Number of characters in zCharSet */
120628120639
120629120640
 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
120630120641
 return;
120631120642
 }
120632120643
 zIn = sqlite3_value_text(argv[0]);
120633120644
 if( zIn==0 ) return;
120634
- nIn = sqlite3_value_bytes(argv[0]);
120645
+ nIn = (unsigned)sqlite3_value_bytes(argv[0]);
120635120646
 assert( zIn==sqlite3_value_text(argv[0]) );
120636120647
 if( argc==1 ){
120637
- static const unsigned char lenOne[] = { 1 };
120648
+ static const unsigned lenOne[] = { 1 };
120638120649
 static unsigned char * const azOne[] = { (u8*)" " };
120639120650
 nChar = 1;
120640
- aLen = (u8*)lenOne;
120651
+ aLen = (unsigned*)lenOne;
120641120652
 azChar = (unsigned char **)azOne;
120642120653
 zCharSet = 0;
120643120654
 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
120644120655
 return;
120645120656
 }else{
@@ -120646,27 +120657,28 @@
120646120657
 const unsigned char *z;
120647120658
 for(z=zCharSet, nChar=0; *z; nChar++){
120648120659
 SQLITE_SKIP_UTF8(z);
120649120660
 }
120650120661
 if( nChar>0 ){
120651
- azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
120662
+ azChar = contextMalloc(context,
120663
+ ((i64)nChar)*(sizeof(char*)+sizeof(unsigned)));
120652120664
 if( azChar==0 ){
120653120665
 return;
120654120666
 }
120655
- aLen = (unsigned char*)&azChar[nChar];
120667
+ aLen = (unsigned*)&azChar[nChar];
120656120668
 for(z=zCharSet, nChar=0; *z; nChar++){
120657120669
 azChar[nChar] = (unsigned char *)z;
120658120670
 SQLITE_SKIP_UTF8(z);
120659
- aLen[nChar] = (u8)(z - azChar[nChar]);
120671
+ aLen[nChar] = (unsigned)(z - azChar[nChar]);
120660120672
 }
120661120673
 }
120662120674
 }
120663120675
 if( nChar>0 ){
120664120676
 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
120665120677
 if( flags & 1 ){
120666120678
 while( nIn>0 ){
120667
- int len = 0;
120679
+ unsigned int len = 0;
120668120680
 for(i=0; i<nChar; i++){
120669120681
 len = aLen[i];
120670120682
 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
120671120683
 }
120672120684
 if( i>=nChar ) break;
@@ -120674,11 +120686,11 @@
120674120686
 nIn -= len;
120675120687
 }
120676120688
 }
120677120689
 if( flags & 2 ){
120678120690
 while( nIn>0 ){
120679
- int len = 0;
120691
+ unsigned int len = 0;
120680120692
 for(i=0; i<nChar; i++){
120681120693
 len = aLen[i];
120682120694
 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
120683120695
 }
120684120696
 if( i>=nChar ) break;
@@ -151932,11 +151944,11 @@
151932151944
 }else{
151933151945
 #ifdef SQLITE_ENABLE_STAT4
151934151946
 tRowcnt nOut = 0;
151935151947
 if( nInMul==0
151936151948
 && pProbe->nSample
151937
- && pNew->u.btree.nEq<=pProbe->nSampleCol
151949
+ && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol)
151938151950
 && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
151939151951
 && OptimizationEnabled(db, SQLITE_Stat4)
151940151952
 ){
151941151953
 Expr *pExpr = pTerm->pExpr;
151942151954
 if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){
@@ -169349,11 +169361,11 @@
169349169361
 case 3: sqlite3WhereTrace = *ptr; break;
169350169362
 }
169351169363
 break;
169352169364
 }
169353169365
169354
-#ifdef SQLITE_DEBUG
169366
+#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
169355169367
 /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
169356169368
 **
169357169369
 ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
169358169370
 ** of the id-th tuning parameter to *piValue. If "id" is between -1
169359169371
 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
@@ -230568,11 +230580,11 @@
230568230580
 int nArg, /* Number of args */
230569230581
 sqlite3_value **apUnused /* Function arguments */
230570230582
 ){
230571230583
 assert( nArg==0 );
230572230584
 UNUSED_PARAM2(nArg, apUnused);
230573
- sqlite3_result_text(pCtx, "fts5: 2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9ef70", -1, SQLITE_TRANSIENT);
230585
+ sqlite3_result_text(pCtx, "fts5: 2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5", -1, SQLITE_TRANSIENT);
230574230586
 }
230575230587
230576230588
 /*
230577230589
 ** Return true if zName is the extension on one of the shadow tables used
230578230590
 ** by this module.
@@ -235494,12 +235506,12 @@
235494235506
 }
235495235507
 #endif /* SQLITE_CORE */
235496235508
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
235497235509
235498235510
 /************** End of stmt.c ************************************************/
235499
-#if __LINE__!=235499
235511
+#if __LINE__!=235511
235500235512
 #undef SQLITE_SOURCE_ID
235501
-#define SQLITE_SOURCE_ID "2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9alt2"
235513
+#define SQLITE_SOURCE_ID "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafaalt2"
235502235514
 #endif
235503235515
 /* Return the source-id for this library */
235504235516
 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
235505235517
 /************************** End of sqlite3.c ******************************/
235506235518
--- src/sqlite3.c
+++ src/sqlite3.c
@@ -1205,11 +1205,11 @@
1205 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
1206 ** [sqlite_version()] and [sqlite_source_id()].
1207 */
1208 #define SQLITE_VERSION "3.36.0"
1209 #define SQLITE_VERSION_NUMBER 3036000
1210 #define SQLITE_SOURCE_ID "2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9ef70"
1211
1212 /*
1213 ** CAPI3REF: Run-Time Library Version Numbers
1214 ** KEYWORDS: sqlite3_version sqlite3_sourceid
1215 **
@@ -5458,21 +5458,21 @@
5458 ** contain embedded NULs. The result of expressions involving strings
5459 ** with embedded NULs is undefined.
5460 **
5461 ** ^The fifth argument to the BLOB and string binding interfaces controls
5462 ** or indicates the lifetime of the object referenced by the third parameter.
5463 ** ^These three options exist:
5464 ** ^(1) A destructor to dispose of the BLOB or string after SQLite has finished
5465 ** with it may be passed. ^It is called to dispose of the BLOB or string even
5466 ** if the call to the bind API fails, except the destructor is not called if
5467 ** the third parameter is a NULL pointer or the fourth parameter is negative.
5468 ** ^(2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
5469 ** the application remains responsible for disposing of the object. ^In this
5470 ** case, the object and the provided pointer to it must remain valid until
5471 ** either the prepared statement is finalized or the same SQL parameter is
5472 ** bound to something else, whichever occurs sooner.
5473 ** ^(3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
5474 ** object is to be copied prior to the return from sqlite3_bind_*(). ^The
5475 ** object and pointer to it must remain valid until then. ^SQLite will then
5476 ** manage the lifetime of its private copy.
5477 **
5478 ** ^The sixth argument to sqlite3_bind_text64() must be one of
@@ -30798,15 +30798,20 @@
30798 ** Nothing in this file or anywhere else in SQLite does any kind of
30799 ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random
30800 ** number generator) not as an encryption device.
30801 */
30802 if( !wsdPrng.isInit ){
 
30803 int i;
30804 char k[256];
30805 wsdPrng.j = 0;
30806 wsdPrng.i = 0;
30807 sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
 
 
 
 
30808 for(i=0; i<256; i++){
30809 wsdPrng.s[i] = (u8)i;
30810 }
30811 for(i=0; i<256; i++){
30812 wsdPrng.j += wsdPrng.s[i] + k[i];
@@ -42119,10 +42124,11 @@
42119 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
42120 sqlite3_vfs_register(&aVfs[i], i==0);
42121 }
42122 unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
42123
 
42124 /* Validate lock assumptions */
42125 assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */
42126 assert( UNIX_SHM_BASE==120 ); /* Start of locking area */
42127 /* Locks:
42128 ** WRITE UNIX_SHM_BASE 120
@@ -42134,10 +42140,12 @@
42134 ** READ-3 UNIX_SHM_BASE+6 126
42135 ** READ-4 UNIX_SHM_BASE+7 127
42136 ** DMS UNIX_SHM_BASE+8 128
42137 */
42138 assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
 
 
42139 return SQLITE_OK;
42140 }
42141
42142 /*
42143 ** Shutdown the operating system interface.
@@ -49371,11 +49379,13 @@
49371 ** This routine is called when the extension is loaded.
49372 ** Register the new VFS.
49373 */
49374 SQLITE_PRIVATE int sqlite3MemdbInit(void){
49375 sqlite3_vfs *pLower = sqlite3_vfs_find(0);
49376 unsigned int sz = pLower->szOsFile;
 
 
49377 memdb_vfs.pAppData = pLower;
49378 /* The following conditional can only be true when compiled for
49379 ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave
49380 ** it in, to be safe, but it is marked as NO_TEST since there
49381 ** is no way to reach it under most builds. */
@@ -96378,12 +96388,13 @@
96378 int iTask = (pTask - pTask->pSorter->aTask);
96379 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
96380 fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent);
96381 }
96382 static void vdbeSorterRewindDebug(const char *zEvent){
96383 i64 t;
96384 sqlite3OsCurrentTimeInt64(sqlite3_vfs_find(0), &t);
 
96385 fprintf(stderr, "%lld:X %s\n", t, zEvent);
96386 }
96387 static void vdbeSorterPopulateDebug(
96388 SortSubtask *pTask,
96389 const char *zEvent
@@ -108240,12 +108251,12 @@
108240 static int renameUnmapSelectCb(Walker *pWalker, Select *p){
108241 Parse *pParse = pWalker->pParse;
108242 int i;
108243 if( pParse->nErr ) return WRC_Abort;
108244 if( p->selFlags & (SF_View|SF_CopyCte) ){
108245 testcase( pSelect->selFlags & SF_View );
108246 testcase( pSelect->selFlags & SF_CopyCte );
108247 return WRC_Prune;
108248 }
108249 if( ALWAYS(p->pEList) ){
108250 ExprList *pList = p->pEList;
108251 for(i=0; i<pList->nExpr; i++){
@@ -108352,12 +108363,12 @@
108352 ** because without a dummy callback, sqlite3WalkExpr() and similar do not
108353 ** descend into sub-select statements.
108354 */
108355 static int renameColumnSelectCb(Walker *pWalker, Select *p){
108356 if( p->selFlags & (SF_View|SF_CopyCte) ){
108357 testcase( pSelect->selFlags & SF_View );
108358 testcase( pSelect->selFlags & SF_CopyCte );
108359 return WRC_Prune;
108360 }
108361 renameWalkWith(pWalker, p);
108362 return WRC_Continue;
108363 }
@@ -108549,17 +108560,17 @@
108549 RenameCtx *pRename, /* Rename context */
108550 const char *zSql, /* SQL statement to edit */
108551 const char *zNew, /* New token text */
108552 int bQuote /* True to always quote token */
108553 ){
108554 int nNew = sqlite3Strlen30(zNew);
108555 int nSql = sqlite3Strlen30(zSql);
108556 sqlite3 *db = sqlite3_context_db_handle(pCtx);
108557 int rc = SQLITE_OK;
108558 char *zQuot = 0;
108559 char *zOut;
108560 int nQuot = 0;
108561 char *zBuf1 = 0;
108562 char *zBuf2 = 0;
108563
108564 if( zNew ){
108565 /* Set zQuot to point to a buffer containing a quoted copy of the
@@ -120617,29 +120628,29 @@
120617 int argc,
120618 sqlite3_value **argv
120619 ){
120620 const unsigned char *zIn; /* Input string */
120621 const unsigned char *zCharSet; /* Set of characters to trim */
120622 int nIn; /* Number of bytes in input */
120623 int flags; /* 1: trimleft 2: trimright 3: trim */
120624 int i; /* Loop counter */
120625 unsigned char *aLen = 0; /* Length of each character in zCharSet */
120626 unsigned char **azChar = 0; /* Individual characters in zCharSet */
120627 int nChar; /* Number of characters in zCharSet */
120628
120629 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
120630 return;
120631 }
120632 zIn = sqlite3_value_text(argv[0]);
120633 if( zIn==0 ) return;
120634 nIn = sqlite3_value_bytes(argv[0]);
120635 assert( zIn==sqlite3_value_text(argv[0]) );
120636 if( argc==1 ){
120637 static const unsigned char lenOne[] = { 1 };
120638 static unsigned char * const azOne[] = { (u8*)" " };
120639 nChar = 1;
120640 aLen = (u8*)lenOne;
120641 azChar = (unsigned char **)azOne;
120642 zCharSet = 0;
120643 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
120644 return;
120645 }else{
@@ -120646,27 +120657,28 @@
120646 const unsigned char *z;
120647 for(z=zCharSet, nChar=0; *z; nChar++){
120648 SQLITE_SKIP_UTF8(z);
120649 }
120650 if( nChar>0 ){
120651 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
 
120652 if( azChar==0 ){
120653 return;
120654 }
120655 aLen = (unsigned char*)&azChar[nChar];
120656 for(z=zCharSet, nChar=0; *z; nChar++){
120657 azChar[nChar] = (unsigned char *)z;
120658 SQLITE_SKIP_UTF8(z);
120659 aLen[nChar] = (u8)(z - azChar[nChar]);
120660 }
120661 }
120662 }
120663 if( nChar>0 ){
120664 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
120665 if( flags & 1 ){
120666 while( nIn>0 ){
120667 int len = 0;
120668 for(i=0; i<nChar; i++){
120669 len = aLen[i];
120670 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
120671 }
120672 if( i>=nChar ) break;
@@ -120674,11 +120686,11 @@
120674 nIn -= len;
120675 }
120676 }
120677 if( flags & 2 ){
120678 while( nIn>0 ){
120679 int len = 0;
120680 for(i=0; i<nChar; i++){
120681 len = aLen[i];
120682 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
120683 }
120684 if( i>=nChar ) break;
@@ -151932,11 +151944,11 @@
151932 }else{
151933 #ifdef SQLITE_ENABLE_STAT4
151934 tRowcnt nOut = 0;
151935 if( nInMul==0
151936 && pProbe->nSample
151937 && pNew->u.btree.nEq<=pProbe->nSampleCol
151938 && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
151939 && OptimizationEnabled(db, SQLITE_Stat4)
151940 ){
151941 Expr *pExpr = pTerm->pExpr;
151942 if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){
@@ -169349,11 +169361,11 @@
169349 case 3: sqlite3WhereTrace = *ptr; break;
169350 }
169351 break;
169352 }
169353
169354 #ifdef SQLITE_DEBUG
169355 /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
169356 **
169357 ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
169358 ** of the id-th tuning parameter to *piValue. If "id" is between -1
169359 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
@@ -230568,11 +230580,11 @@
230568 int nArg, /* Number of args */
230569 sqlite3_value **apUnused /* Function arguments */
230570 ){
230571 assert( nArg==0 );
230572 UNUSED_PARAM2(nArg, apUnused);
230573 sqlite3_result_text(pCtx, "fts5: 2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9ef70", -1, SQLITE_TRANSIENT);
230574 }
230575
230576 /*
230577 ** Return true if zName is the extension on one of the shadow tables used
230578 ** by this module.
@@ -235494,12 +235506,12 @@
235494 }
235495 #endif /* SQLITE_CORE */
235496 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
235497
235498 /************** End of stmt.c ************************************************/
235499 #if __LINE__!=235499
235500 #undef SQLITE_SOURCE_ID
235501 #define SQLITE_SOURCE_ID "2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9alt2"
235502 #endif
235503 /* Return the source-id for this library */
235504 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
235505 /************************** End of sqlite3.c ******************************/
235506
--- src/sqlite3.c
+++ src/sqlite3.c
@@ -1205,11 +1205,11 @@
1205 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
1206 ** [sqlite_version()] and [sqlite_source_id()].
1207 */
1208 #define SQLITE_VERSION "3.36.0"
1209 #define SQLITE_VERSION_NUMBER 3036000
1210 #define SQLITE_SOURCE_ID "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5"
1211
1212 /*
1213 ** CAPI3REF: Run-Time Library Version Numbers
1214 ** KEYWORDS: sqlite3_version sqlite3_sourceid
1215 **
@@ -5458,21 +5458,21 @@
5458 ** contain embedded NULs. The result of expressions involving strings
5459 ** with embedded NULs is undefined.
5460 **
5461 ** ^The fifth argument to the BLOB and string binding interfaces controls
5462 ** or indicates the lifetime of the object referenced by the third parameter.
5463 ** These three options exist:
5464 ** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
5465 ** with it may be passed. ^It is called to dispose of the BLOB or string even
5466 ** if the call to the bind API fails, except the destructor is not called if
5467 ** the third parameter is a NULL pointer or the fourth parameter is negative.
5468 ** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
5469 ** the application remains responsible for disposing of the object. ^In this
5470 ** case, the object and the provided pointer to it must remain valid until
5471 ** either the prepared statement is finalized or the same SQL parameter is
5472 ** bound to something else, whichever occurs sooner.
5473 ** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
5474 ** object is to be copied prior to the return from sqlite3_bind_*(). ^The
5475 ** object and pointer to it must remain valid until then. ^SQLite will then
5476 ** manage the lifetime of its private copy.
5477 **
5478 ** ^The sixth argument to sqlite3_bind_text64() must be one of
@@ -30798,15 +30798,20 @@
30798 ** Nothing in this file or anywhere else in SQLite does any kind of
30799 ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random
30800 ** number generator) not as an encryption device.
30801 */
30802 if( !wsdPrng.isInit ){
30803 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
30804 int i;
30805 char k[256];
30806 wsdPrng.j = 0;
30807 wsdPrng.i = 0;
30808 if( NEVER(pVfs==0) ){
30809 memset(k, 0, sizeof(k));
30810 }else{
30811 sqlite3OsRandomness(pVfs, 256, k);
30812 }
30813 for(i=0; i<256; i++){
30814 wsdPrng.s[i] = (u8)i;
30815 }
30816 for(i=0; i<256; i++){
30817 wsdPrng.j += wsdPrng.s[i] + k[i];
@@ -42119,10 +42124,11 @@
42124 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
42125 sqlite3_vfs_register(&aVfs[i], i==0);
42126 }
42127 unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
42128
42129 #ifndef SQLITE_OMIT_WAL
42130 /* Validate lock assumptions */
42131 assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */
42132 assert( UNIX_SHM_BASE==120 ); /* Start of locking area */
42133 /* Locks:
42134 ** WRITE UNIX_SHM_BASE 120
@@ -42134,10 +42140,12 @@
42140 ** READ-3 UNIX_SHM_BASE+6 126
42141 ** READ-4 UNIX_SHM_BASE+7 127
42142 ** DMS UNIX_SHM_BASE+8 128
42143 */
42144 assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
42145 #endif
42146
42147 return SQLITE_OK;
42148 }
42149
42150 /*
42151 ** Shutdown the operating system interface.
@@ -49371,11 +49379,13 @@
49379 ** This routine is called when the extension is loaded.
49380 ** Register the new VFS.
49381 */
49382 SQLITE_PRIVATE int sqlite3MemdbInit(void){
49383 sqlite3_vfs *pLower = sqlite3_vfs_find(0);
49384 unsigned int sz;
49385 if( NEVER(pLower==0) ) return SQLITE_ERROR;
49386 sz = pLower->szOsFile;
49387 memdb_vfs.pAppData = pLower;
49388 /* The following conditional can only be true when compiled for
49389 ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave
49390 ** it in, to be safe, but it is marked as NO_TEST since there
49391 ** is no way to reach it under most builds. */
@@ -96378,12 +96388,13 @@
96388 int iTask = (pTask - pTask->pSorter->aTask);
96389 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
96390 fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent);
96391 }
96392 static void vdbeSorterRewindDebug(const char *zEvent){
96393 i64 t = 0;
96394 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
96395 if( ALWAYS(pVfs) ) sqlite3OsCurrentTimeInt64(pVfs, &t);
96396 fprintf(stderr, "%lld:X %s\n", t, zEvent);
96397 }
96398 static void vdbeSorterPopulateDebug(
96399 SortSubtask *pTask,
96400 const char *zEvent
@@ -108240,12 +108251,12 @@
108251 static int renameUnmapSelectCb(Walker *pWalker, Select *p){
108252 Parse *pParse = pWalker->pParse;
108253 int i;
108254 if( pParse->nErr ) return WRC_Abort;
108255 if( p->selFlags & (SF_View|SF_CopyCte) ){
108256 testcase( p->selFlags & SF_View );
108257 testcase( p->selFlags & SF_CopyCte );
108258 return WRC_Prune;
108259 }
108260 if( ALWAYS(p->pEList) ){
108261 ExprList *pList = p->pEList;
108262 for(i=0; i<pList->nExpr; i++){
@@ -108352,12 +108363,12 @@
108363 ** because without a dummy callback, sqlite3WalkExpr() and similar do not
108364 ** descend into sub-select statements.
108365 */
108366 static int renameColumnSelectCb(Walker *pWalker, Select *p){
108367 if( p->selFlags & (SF_View|SF_CopyCte) ){
108368 testcase( p->selFlags & SF_View );
108369 testcase( p->selFlags & SF_CopyCte );
108370 return WRC_Prune;
108371 }
108372 renameWalkWith(pWalker, p);
108373 return WRC_Continue;
108374 }
@@ -108549,17 +108560,17 @@
108560 RenameCtx *pRename, /* Rename context */
108561 const char *zSql, /* SQL statement to edit */
108562 const char *zNew, /* New token text */
108563 int bQuote /* True to always quote token */
108564 ){
108565 i64 nNew = sqlite3Strlen30(zNew);
108566 i64 nSql = sqlite3Strlen30(zSql);
108567 sqlite3 *db = sqlite3_context_db_handle(pCtx);
108568 int rc = SQLITE_OK;
108569 char *zQuot = 0;
108570 char *zOut;
108571 i64 nQuot = 0;
108572 char *zBuf1 = 0;
108573 char *zBuf2 = 0;
108574
108575 if( zNew ){
108576 /* Set zQuot to point to a buffer containing a quoted copy of the
@@ -120617,29 +120628,29 @@
120628 int argc,
120629 sqlite3_value **argv
120630 ){
120631 const unsigned char *zIn; /* Input string */
120632 const unsigned char *zCharSet; /* Set of characters to trim */
120633 unsigned int nIn; /* Number of bytes in input */
120634 int flags; /* 1: trimleft 2: trimright 3: trim */
120635 int i; /* Loop counter */
120636 unsigned int *aLen = 0; /* Length of each character in zCharSet */
120637 unsigned char **azChar = 0; /* Individual characters in zCharSet */
120638 int nChar; /* Number of characters in zCharSet */
120639
120640 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
120641 return;
120642 }
120643 zIn = sqlite3_value_text(argv[0]);
120644 if( zIn==0 ) return;
120645 nIn = (unsigned)sqlite3_value_bytes(argv[0]);
120646 assert( zIn==sqlite3_value_text(argv[0]) );
120647 if( argc==1 ){
120648 static const unsigned lenOne[] = { 1 };
120649 static unsigned char * const azOne[] = { (u8*)" " };
120650 nChar = 1;
120651 aLen = (unsigned*)lenOne;
120652 azChar = (unsigned char **)azOne;
120653 zCharSet = 0;
120654 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
120655 return;
120656 }else{
@@ -120646,27 +120657,28 @@
120657 const unsigned char *z;
120658 for(z=zCharSet, nChar=0; *z; nChar++){
120659 SQLITE_SKIP_UTF8(z);
120660 }
120661 if( nChar>0 ){
120662 azChar = contextMalloc(context,
120663 ((i64)nChar)*(sizeof(char*)+sizeof(unsigned)));
120664 if( azChar==0 ){
120665 return;
120666 }
120667 aLen = (unsigned*)&azChar[nChar];
120668 for(z=zCharSet, nChar=0; *z; nChar++){
120669 azChar[nChar] = (unsigned char *)z;
120670 SQLITE_SKIP_UTF8(z);
120671 aLen[nChar] = (unsigned)(z - azChar[nChar]);
120672 }
120673 }
120674 }
120675 if( nChar>0 ){
120676 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
120677 if( flags & 1 ){
120678 while( nIn>0 ){
120679 unsigned int len = 0;
120680 for(i=0; i<nChar; i++){
120681 len = aLen[i];
120682 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
120683 }
120684 if( i>=nChar ) break;
@@ -120674,11 +120686,11 @@
120686 nIn -= len;
120687 }
120688 }
120689 if( flags & 2 ){
120690 while( nIn>0 ){
120691 unsigned int len = 0;
120692 for(i=0; i<nChar; i++){
120693 len = aLen[i];
120694 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
120695 }
120696 if( i>=nChar ) break;
@@ -151932,11 +151944,11 @@
151944 }else{
151945 #ifdef SQLITE_ENABLE_STAT4
151946 tRowcnt nOut = 0;
151947 if( nInMul==0
151948 && pProbe->nSample
151949 && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol)
151950 && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
151951 && OptimizationEnabled(db, SQLITE_Stat4)
151952 ){
151953 Expr *pExpr = pTerm->pExpr;
151954 if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){
@@ -169349,11 +169361,11 @@
169361 case 3: sqlite3WhereTrace = *ptr; break;
169362 }
169363 break;
169364 }
169365
169366 #if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
169367 /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
169368 **
169369 ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
169370 ** of the id-th tuning parameter to *piValue. If "id" is between -1
169371 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
@@ -230568,11 +230580,11 @@
230580 int nArg, /* Number of args */
230581 sqlite3_value **apUnused /* Function arguments */
230582 ){
230583 assert( nArg==0 );
230584 UNUSED_PARAM2(nArg, apUnused);
230585 sqlite3_result_text(pCtx, "fts5: 2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5", -1, SQLITE_TRANSIENT);
230586 }
230587
230588 /*
230589 ** Return true if zName is the extension on one of the shadow tables used
230590 ** by this module.
@@ -235494,12 +235506,12 @@
235506 }
235507 #endif /* SQLITE_CORE */
235508 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
235509
235510 /************** End of stmt.c ************************************************/
235511 #if __LINE__!=235511
235512 #undef SQLITE_SOURCE_ID
235513 #define SQLITE_SOURCE_ID "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafaalt2"
235514 #endif
235515 /* Return the source-id for this library */
235516 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
235517 /************************** End of sqlite3.c ******************************/
235518
M src/sqlite3.h
+5 -5
--- src/sqlite3.h
+++ src/sqlite3.h
@@ -123,11 +123,11 @@
123123
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
124124
 ** [sqlite_version()] and [sqlite_source_id()].
125125
 */
126126
 #define SQLITE_VERSION "3.36.0"
127127
 #define SQLITE_VERSION_NUMBER 3036000
128
-#define SQLITE_SOURCE_ID "2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9ef70"
128
+#define SQLITE_SOURCE_ID "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5"
129129
130130
 /*
131131
 ** CAPI3REF: Run-Time Library Version Numbers
132132
 ** KEYWORDS: sqlite3_version sqlite3_sourceid
133133
 **
@@ -4376,21 +4376,21 @@
43764376
 ** contain embedded NULs. The result of expressions involving strings
43774377
 ** with embedded NULs is undefined.
43784378
 **
43794379
 ** ^The fifth argument to the BLOB and string binding interfaces controls
43804380
 ** or indicates the lifetime of the object referenced by the third parameter.
4381
-** ^These three options exist:
4382
-** ^(1) A destructor to dispose of the BLOB or string after SQLite has finished
4381
+** These three options exist:
4382
+** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
43834383
 ** with it may be passed. ^It is called to dispose of the BLOB or string even
43844384
 ** if the call to the bind API fails, except the destructor is not called if
43854385
 ** the third parameter is a NULL pointer or the fourth parameter is negative.
4386
-** ^(2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
4386
+** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
43874387
 ** the application remains responsible for disposing of the object. ^In this
43884388
 ** case, the object and the provided pointer to it must remain valid until
43894389
 ** either the prepared statement is finalized or the same SQL parameter is
43904390
 ** bound to something else, whichever occurs sooner.
4391
-** ^(3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
4391
+** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
43924392
 ** object is to be copied prior to the return from sqlite3_bind_*(). ^The
43934393
 ** object and pointer to it must remain valid until then. ^SQLite will then
43944394
 ** manage the lifetime of its private copy.
43954395
 **
43964396
 ** ^The sixth argument to sqlite3_bind_text64() must be one of
43974397
--- src/sqlite3.h
+++ src/sqlite3.h
@@ -123,11 +123,11 @@
123 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
124 ** [sqlite_version()] and [sqlite_source_id()].
125 */
126 #define SQLITE_VERSION "3.36.0"
127 #define SQLITE_VERSION_NUMBER 3036000
128 #define SQLITE_SOURCE_ID "2021-06-14 20:41:20 e5a5acd6006133c5da4a7dd79726dbaa41c0d60ebeda890f848a6aafe5f9ef70"
129
130 /*
131 ** CAPI3REF: Run-Time Library Version Numbers
132 ** KEYWORDS: sqlite3_version sqlite3_sourceid
133 **
@@ -4376,21 +4376,21 @@
4376 ** contain embedded NULs. The result of expressions involving strings
4377 ** with embedded NULs is undefined.
4378 **
4379 ** ^The fifth argument to the BLOB and string binding interfaces controls
4380 ** or indicates the lifetime of the object referenced by the third parameter.
4381 ** ^These three options exist:
4382 ** ^(1) A destructor to dispose of the BLOB or string after SQLite has finished
4383 ** with it may be passed. ^It is called to dispose of the BLOB or string even
4384 ** if the call to the bind API fails, except the destructor is not called if
4385 ** the third parameter is a NULL pointer or the fourth parameter is negative.
4386 ** ^(2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
4387 ** the application remains responsible for disposing of the object. ^In this
4388 ** case, the object and the provided pointer to it must remain valid until
4389 ** either the prepared statement is finalized or the same SQL parameter is
4390 ** bound to something else, whichever occurs sooner.
4391 ** ^(3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
4392 ** object is to be copied prior to the return from sqlite3_bind_*(). ^The
4393 ** object and pointer to it must remain valid until then. ^SQLite will then
4394 ** manage the lifetime of its private copy.
4395 **
4396 ** ^The sixth argument to sqlite3_bind_text64() must be one of
4397
--- src/sqlite3.h
+++ src/sqlite3.h
@@ -123,11 +123,11 @@
123 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
124 ** [sqlite_version()] and [sqlite_source_id()].
125 */
126 #define SQLITE_VERSION "3.36.0"
127 #define SQLITE_VERSION_NUMBER 3036000
128 #define SQLITE_SOURCE_ID "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5"
129
130 /*
131 ** CAPI3REF: Run-Time Library Version Numbers
132 ** KEYWORDS: sqlite3_version sqlite3_sourceid
133 **
@@ -4376,21 +4376,21 @@
4376 ** contain embedded NULs. The result of expressions involving strings
4377 ** with embedded NULs is undefined.
4378 **
4379 ** ^The fifth argument to the BLOB and string binding interfaces controls
4380 ** or indicates the lifetime of the object referenced by the third parameter.
4381 ** These three options exist:
4382 ** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
4383 ** with it may be passed. ^It is called to dispose of the BLOB or string even
4384 ** if the call to the bind API fails, except the destructor is not called if
4385 ** the third parameter is a NULL pointer or the fourth parameter is negative.
4386 ** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
4387 ** the application remains responsible for disposing of the object. ^In this
4388 ** case, the object and the provided pointer to it must remain valid until
4389 ** either the prepared statement is finalized or the same SQL parameter is
4390 ** bound to something else, whichever occurs sooner.
4391 ** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
4392 ** object is to be copied prior to the return from sqlite3_bind_*(). ^The
4393 ** object and pointer to it must remain valid until then. ^SQLite will then
4394 ** manage the lifetime of its private copy.
4395 **
4396 ** ^The sixth argument to sqlite3_bind_text64() must be one of
4397

Keyboard Shortcuts

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