Fossil SCM

Update the built-in SQLite to the latest trunk version so that it will compile without warnings on Windows.

drh 2025-09-27 11:10 trunk
Commit 702a56d116a3d3b836cbe471f1d4b3c415a694c7bfcabe46658e4abc4f9fc651
Parent 82888a0d35a8094…
3 files changed +33 -14 +3 -3 +2 -2
~ extsrc/shell.c ~ extsrc/sqlite3.c ~ extsrc/sqlite3.h
M extsrc/shell.c
+33 -14
--- extsrc/shell.c
+++ extsrc/shell.c
@@ -6996,11 +6996,11 @@
69966996
 ** The following regular expression syntax is supported:
69976997
 **
69986998
 ** X* zero or more occurrences of X
69996999
 ** X+ one or more occurrences of X
70007000
 ** X? zero or one occurrences of X
7001
-** X{p,q} between p and q occurrences of X, 0 <= p,q <= 999
7001
+** X{p,q} between p and q occurrences of X
70027002
 ** (X) match X
70037003
 ** X|Y X or Y
70047004
 ** ^X X occurring at the beginning of the string
70057005
 ** X$ X occurring at the end of the string
70067006
 ** . Match any single character
@@ -7026,20 +7026,20 @@
70267026
 ** exhibits exponential behavior. Note that the X{p,q} operator expands
70277027
 ** to p copies of X following by q-p copies of X? and that the size of the
70287028
 ** regular expression in the O(N*M) performance bound is computed after
70297029
 ** this expansion.
70307030
 **
7031
-** To help prevent DoS attacks, the values of p and q in the "{p,q}" syntax
7032
-** are limited to SQLITE_MAX_REGEXP_REPEAT, default 999.
7031
+** To help prevent DoS attacks, the size of the NFA is limit to
7032
+** SQLITE_MAX_REGEXP states, default 9999.
70337033
 */
70347034
 #include <string.h>
70357035
 #include <stdlib.h>
70367036
 /* #include "sqlite3ext.h" */
70377037
 SQLITE_EXTENSION_INIT1
70387038
7039
-#ifndef SQLITE_MAX_REGEXP_REPEAT
7040
-# define SQLITE_MAX_REGEXP_REPEAT 999
7039
+#ifndef SQLITE_MAX_REGEXP
7040
+# define SQLITE_MAX_REGEXP 9999
70417041
 #endif
70427042
70437043
 /*
70447044
 ** The following #defines change the names of some functions implemented in
70457045
 ** this file to prevent name collisions with C-library functions of the
@@ -7135,10 +7135,11 @@
71357135
 unsigned (*xNextChar)(ReInput*); /* Next character function */
71367136
 unsigned char zInit[12]; /* Initial text to match */
71377137
 int nInit; /* Number of bytes in zInit */
71387138
 unsigned nState; /* Number of entries in aOp[] and aArg[] */
71397139
 unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
7140
+ unsigned mxAlloc; /* Complexity limit */
71407141
 };
71417142
71427143
 /* Add a state to the given state set if it is not already there */
71437144
 static void re_add_state(ReStateSet *pSet, int newState){
71447145
 unsigned i;
@@ -7352,15 +7353,16 @@
73527353
 /* Resize the opcode and argument arrays for an RE under construction.
73537354
 */
73547355
 static int re_resize(ReCompiled *p, int N){
73557356
 char *aOp;
73567357
 int *aArg;
7358
+ if( N>p->mxAlloc ){ p->zErr = "REGEXP pattern too big"; return 1; }
73577359
 aOp = sqlite3_realloc64(p->aOp, N*sizeof(p->aOp[0]));
7358
- if( aOp==0 ) return 1;
7360
+ if( aOp==0 ){ p->zErr = "out of memory"; return 1; }
73597361
 p->aOp = aOp;
73607362
 aArg = sqlite3_realloc64(p->aArg, N*sizeof(p->aArg[0]));
7361
- if( aArg==0 ) return 1;
7363
+ if( aArg==0 ){ p->zErr = "out of memory"; return 1; }
73627364
 p->aArg = aArg;
73637365
 p->nAlloc = N;
73647366
 return 0;
73657367
 }
73667368
@@ -7545,20 +7547,20 @@
75457547
 unsigned int m = 0, n = 0;
75467548
 unsigned int sz, j;
75477549
 if( iPrev<0 ) return "'{m,n}' without operand";
75487550
 while( (c=rePeek(p))>='0' && c<='9' ){
75497551
 m = m*10 + c - '0';
7550
- if( m>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
7552
+ if( m*2>p->mxAlloc ) return "REGEXP pattern too big";
75517553
 p->sIn.i++;
75527554
 }
75537555
 n = m;
75547556
 if( c==',' ){
75557557
 p->sIn.i++;
75567558
 n = 0;
75577559
 while( (c=rePeek(p))>='0' && c<='9' ){
75587560
 n = n*10 + c-'0';
7559
- if( n>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
7561
+ if( n*2>p->mxAlloc ) return "REGEXP pattern too big";
75607562
 p->sIn.i++;
75617563
 }
75627564
 }
75637565
 if( c!='}' ) return "unmatched '{'";
75647566
 if( n<m ) return "n less than m in '{m,n}'";
@@ -7575,11 +7577,11 @@
75757577
 for(j=m; j<n; j++){
75767578
 re_append(p, RE_OP_FORK, sz+1);
75777579
 re_copy(p, iPrev, sz);
75787580
 }
75797581
 if( n==0 && m>0 ){
7580
- re_append(p, RE_OP_FORK, -sz);
7582
+ re_append(p, RE_OP_FORK, -(int)sz);
75817583
 }
75827584
 break;
75837585
 }
75847586
 case '[': {
75857587
 unsigned int iFirst = p->nState;
@@ -7656,11 +7658,16 @@
76567658
 ** Compile a textual regular expression in zIn[] into a compiled regular
76577659
 ** expression suitable for us by re_match() and return a pointer to the
76587660
 ** compiled regular expression in *ppRe. Return NULL on success or an
76597661
 ** error message if something goes wrong.
76607662
 */
7661
-static const char *re_compile(ReCompiled **ppRe, const char *zIn, int noCase){
7663
+static const char *re_compile(
7664
+ ReCompiled **ppRe, /* OUT: write compiled NFA here */
7665
+ const char *zIn, /* Input regular expression */
7666
+ int mxRe, /* Complexity limit */
7667
+ int noCase /* True for caseless comparisons */
7668
+){
76627669
 ReCompiled *pRe;
76637670
 const char *zErr;
76647671
 int i, j;
76657672
76667673
 *ppRe = 0;
@@ -7668,13 +7675,15 @@
76687675
 if( pRe==0 ){
76697676
 return "out of memory";
76707677
 }
76717678
 memset(pRe, 0, sizeof(*pRe));
76727679
 pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
7680
+ pRe->mxAlloc = mxRe;
76737681
 if( re_resize(pRe, 30) ){
7682
+ zErr = pRe->zErr;
76747683
 re_free(pRe);
7675
- return "out of memory";
7684
+ return zErr;
76767685
 }
76777686
 if( zIn[0]=='^' ){
76787687
 zIn++;
76797688
 }else{
76807689
 re_append(pRe, RE_OP_ANYSTAR, 0);
@@ -7722,10 +7731,18 @@
77227731
 if( j>0 && pRe->zInit[j-1]==0 ) j--;
77237732
 pRe->nInit = j;
77247733
 }
77257734
 return pRe->zErr;
77267735
 }
7736
+
7737
+/*
7738
+** Compute a reasonable limit on the length of the REGEXP NFA.
7739
+*/
7740
+static int re_maxlen(sqlite3_context *context){
7741
+ sqlite3 *db = sqlite3_context_db_handle(context);
7742
+ return 75 + sqlite3_limit(db, SQLITE_LIMIT_LIKE_PATTERN_LENGTH,-1)/2;
7743
+}
77277744
77287745
 /*
77297746
 ** Implementation of the regexp() SQL function. This function implements
77307747
 ** the build-in REGEXP operator. The first argument to the function is the
77317748
 ** pattern and the second argument is the string. So, the SQL statements:
@@ -7748,11 +7765,12 @@
77487765
 (void)argc; /* Unused */
77497766
 pRe = sqlite3_get_auxdata(context, 0);
77507767
 if( pRe==0 ){
77517768
 zPattern = (const char*)sqlite3_value_text(argv[0]);
77527769
 if( zPattern==0 ) return;
7753
- zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
7770
+ zErr = re_compile(&pRe, zPattern, re_maxlen(context),
7771
+ sqlite3_user_data(context)!=0);
77547772
 if( zErr ){
77557773
 re_free(pRe);
77567774
 sqlite3_result_error(context, zErr, -1);
77577775
 return;
77587776
 }
@@ -7793,11 +7811,12 @@
77937811
 char *z;
77947812
 (void)argc;
77957813
77967814
 zPattern = (const char*)sqlite3_value_text(argv[0]);
77977815
 if( zPattern==0 ) return;
7798
- zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
7816
+ zErr = re_compile(&pRe, zPattern, re_maxlen(context),
7817
+ sqlite3_user_data(context)!=0);
77997818
 if( zErr ){
78007819
 re_free(pRe);
78017820
 sqlite3_result_error(context, zErr, -1);
78027821
 return;
78037822
 }
78047823
--- extsrc/shell.c
+++ extsrc/shell.c
@@ -6996,11 +6996,11 @@
6996 ** The following regular expression syntax is supported:
6997 **
6998 ** X* zero or more occurrences of X
6999 ** X+ one or more occurrences of X
7000 ** X? zero or one occurrences of X
7001 ** X{p,q} between p and q occurrences of X, 0 <= p,q <= 999
7002 ** (X) match X
7003 ** X|Y X or Y
7004 ** ^X X occurring at the beginning of the string
7005 ** X$ X occurring at the end of the string
7006 ** . Match any single character
@@ -7026,20 +7026,20 @@
7026 ** exhibits exponential behavior. Note that the X{p,q} operator expands
7027 ** to p copies of X following by q-p copies of X? and that the size of the
7028 ** regular expression in the O(N*M) performance bound is computed after
7029 ** this expansion.
7030 **
7031 ** To help prevent DoS attacks, the values of p and q in the "{p,q}" syntax
7032 ** are limited to SQLITE_MAX_REGEXP_REPEAT, default 999.
7033 */
7034 #include <string.h>
7035 #include <stdlib.h>
7036 /* #include "sqlite3ext.h" */
7037 SQLITE_EXTENSION_INIT1
7038
7039 #ifndef SQLITE_MAX_REGEXP_REPEAT
7040 # define SQLITE_MAX_REGEXP_REPEAT 999
7041 #endif
7042
7043 /*
7044 ** The following #defines change the names of some functions implemented in
7045 ** this file to prevent name collisions with C-library functions of the
@@ -7135,10 +7135,11 @@
7135 unsigned (*xNextChar)(ReInput*); /* Next character function */
7136 unsigned char zInit[12]; /* Initial text to match */
7137 int nInit; /* Number of bytes in zInit */
7138 unsigned nState; /* Number of entries in aOp[] and aArg[] */
7139 unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
 
7140 };
7141
7142 /* Add a state to the given state set if it is not already there */
7143 static void re_add_state(ReStateSet *pSet, int newState){
7144 unsigned i;
@@ -7352,15 +7353,16 @@
7352 /* Resize the opcode and argument arrays for an RE under construction.
7353 */
7354 static int re_resize(ReCompiled *p, int N){
7355 char *aOp;
7356 int *aArg;
 
7357 aOp = sqlite3_realloc64(p->aOp, N*sizeof(p->aOp[0]));
7358 if( aOp==0 ) return 1;
7359 p->aOp = aOp;
7360 aArg = sqlite3_realloc64(p->aArg, N*sizeof(p->aArg[0]));
7361 if( aArg==0 ) return 1;
7362 p->aArg = aArg;
7363 p->nAlloc = N;
7364 return 0;
7365 }
7366
@@ -7545,20 +7547,20 @@
7545 unsigned int m = 0, n = 0;
7546 unsigned int sz, j;
7547 if( iPrev<0 ) return "'{m,n}' without operand";
7548 while( (c=rePeek(p))>='0' && c<='9' ){
7549 m = m*10 + c - '0';
7550 if( m>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
7551 p->sIn.i++;
7552 }
7553 n = m;
7554 if( c==',' ){
7555 p->sIn.i++;
7556 n = 0;
7557 while( (c=rePeek(p))>='0' && c<='9' ){
7558 n = n*10 + c-'0';
7559 if( n>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
7560 p->sIn.i++;
7561 }
7562 }
7563 if( c!='}' ) return "unmatched '{'";
7564 if( n<m ) return "n less than m in '{m,n}'";
@@ -7575,11 +7577,11 @@
7575 for(j=m; j<n; j++){
7576 re_append(p, RE_OP_FORK, sz+1);
7577 re_copy(p, iPrev, sz);
7578 }
7579 if( n==0 && m>0 ){
7580 re_append(p, RE_OP_FORK, -sz);
7581 }
7582 break;
7583 }
7584 case '[': {
7585 unsigned int iFirst = p->nState;
@@ -7656,11 +7658,16 @@
7656 ** Compile a textual regular expression in zIn[] into a compiled regular
7657 ** expression suitable for us by re_match() and return a pointer to the
7658 ** compiled regular expression in *ppRe. Return NULL on success or an
7659 ** error message if something goes wrong.
7660 */
7661 static const char *re_compile(ReCompiled **ppRe, const char *zIn, int noCase){
 
 
 
 
 
7662 ReCompiled *pRe;
7663 const char *zErr;
7664 int i, j;
7665
7666 *ppRe = 0;
@@ -7668,13 +7675,15 @@
7668 if( pRe==0 ){
7669 return "out of memory";
7670 }
7671 memset(pRe, 0, sizeof(*pRe));
7672 pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
 
7673 if( re_resize(pRe, 30) ){
 
7674 re_free(pRe);
7675 return "out of memory";
7676 }
7677 if( zIn[0]=='^' ){
7678 zIn++;
7679 }else{
7680 re_append(pRe, RE_OP_ANYSTAR, 0);
@@ -7722,10 +7731,18 @@
7722 if( j>0 && pRe->zInit[j-1]==0 ) j--;
7723 pRe->nInit = j;
7724 }
7725 return pRe->zErr;
7726 }
 
 
 
 
 
 
 
 
7727
7728 /*
7729 ** Implementation of the regexp() SQL function. This function implements
7730 ** the build-in REGEXP operator. The first argument to the function is the
7731 ** pattern and the second argument is the string. So, the SQL statements:
@@ -7748,11 +7765,12 @@
7748 (void)argc; /* Unused */
7749 pRe = sqlite3_get_auxdata(context, 0);
7750 if( pRe==0 ){
7751 zPattern = (const char*)sqlite3_value_text(argv[0]);
7752 if( zPattern==0 ) return;
7753 zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
 
7754 if( zErr ){
7755 re_free(pRe);
7756 sqlite3_result_error(context, zErr, -1);
7757 return;
7758 }
@@ -7793,11 +7811,12 @@
7793 char *z;
7794 (void)argc;
7795
7796 zPattern = (const char*)sqlite3_value_text(argv[0]);
7797 if( zPattern==0 ) return;
7798 zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
 
7799 if( zErr ){
7800 re_free(pRe);
7801 sqlite3_result_error(context, zErr, -1);
7802 return;
7803 }
7804
--- extsrc/shell.c
+++ extsrc/shell.c
@@ -6996,11 +6996,11 @@
6996 ** The following regular expression syntax is supported:
6997 **
6998 ** X* zero or more occurrences of X
6999 ** X+ one or more occurrences of X
7000 ** X? zero or one occurrences of X
7001 ** X{p,q} between p and q occurrences of X
7002 ** (X) match X
7003 ** X|Y X or Y
7004 ** ^X X occurring at the beginning of the string
7005 ** X$ X occurring at the end of the string
7006 ** . Match any single character
@@ -7026,20 +7026,20 @@
7026 ** exhibits exponential behavior. Note that the X{p,q} operator expands
7027 ** to p copies of X following by q-p copies of X? and that the size of the
7028 ** regular expression in the O(N*M) performance bound is computed after
7029 ** this expansion.
7030 **
7031 ** To help prevent DoS attacks, the size of the NFA is limit to
7032 ** SQLITE_MAX_REGEXP states, default 9999.
7033 */
7034 #include <string.h>
7035 #include <stdlib.h>
7036 /* #include "sqlite3ext.h" */
7037 SQLITE_EXTENSION_INIT1
7038
7039 #ifndef SQLITE_MAX_REGEXP
7040 # define SQLITE_MAX_REGEXP 9999
7041 #endif
7042
7043 /*
7044 ** The following #defines change the names of some functions implemented in
7045 ** this file to prevent name collisions with C-library functions of the
@@ -7135,10 +7135,11 @@
7135 unsigned (*xNextChar)(ReInput*); /* Next character function */
7136 unsigned char zInit[12]; /* Initial text to match */
7137 int nInit; /* Number of bytes in zInit */
7138 unsigned nState; /* Number of entries in aOp[] and aArg[] */
7139 unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
7140 unsigned mxAlloc; /* Complexity limit */
7141 };
7142
7143 /* Add a state to the given state set if it is not already there */
7144 static void re_add_state(ReStateSet *pSet, int newState){
7145 unsigned i;
@@ -7352,15 +7353,16 @@
7353 /* Resize the opcode and argument arrays for an RE under construction.
7354 */
7355 static int re_resize(ReCompiled *p, int N){
7356 char *aOp;
7357 int *aArg;
7358 if( N>p->mxAlloc ){ p->zErr = "REGEXP pattern too big"; return 1; }
7359 aOp = sqlite3_realloc64(p->aOp, N*sizeof(p->aOp[0]));
7360 if( aOp==0 ){ p->zErr = "out of memory"; return 1; }
7361 p->aOp = aOp;
7362 aArg = sqlite3_realloc64(p->aArg, N*sizeof(p->aArg[0]));
7363 if( aArg==0 ){ p->zErr = "out of memory"; return 1; }
7364 p->aArg = aArg;
7365 p->nAlloc = N;
7366 return 0;
7367 }
7368
@@ -7545,20 +7547,20 @@
7547 unsigned int m = 0, n = 0;
7548 unsigned int sz, j;
7549 if( iPrev<0 ) return "'{m,n}' without operand";
7550 while( (c=rePeek(p))>='0' && c<='9' ){
7551 m = m*10 + c - '0';
7552 if( m*2>p->mxAlloc ) return "REGEXP pattern too big";
7553 p->sIn.i++;
7554 }
7555 n = m;
7556 if( c==',' ){
7557 p->sIn.i++;
7558 n = 0;
7559 while( (c=rePeek(p))>='0' && c<='9' ){
7560 n = n*10 + c-'0';
7561 if( n*2>p->mxAlloc ) return "REGEXP pattern too big";
7562 p->sIn.i++;
7563 }
7564 }
7565 if( c!='}' ) return "unmatched '{'";
7566 if( n<m ) return "n less than m in '{m,n}'";
@@ -7575,11 +7577,11 @@
7577 for(j=m; j<n; j++){
7578 re_append(p, RE_OP_FORK, sz+1);
7579 re_copy(p, iPrev, sz);
7580 }
7581 if( n==0 && m>0 ){
7582 re_append(p, RE_OP_FORK, -(int)sz);
7583 }
7584 break;
7585 }
7586 case '[': {
7587 unsigned int iFirst = p->nState;
@@ -7656,11 +7658,16 @@
7658 ** Compile a textual regular expression in zIn[] into a compiled regular
7659 ** expression suitable for us by re_match() and return a pointer to the
7660 ** compiled regular expression in *ppRe. Return NULL on success or an
7661 ** error message if something goes wrong.
7662 */
7663 static const char *re_compile(
7664 ReCompiled **ppRe, /* OUT: write compiled NFA here */
7665 const char *zIn, /* Input regular expression */
7666 int mxRe, /* Complexity limit */
7667 int noCase /* True for caseless comparisons */
7668 ){
7669 ReCompiled *pRe;
7670 const char *zErr;
7671 int i, j;
7672
7673 *ppRe = 0;
@@ -7668,13 +7675,15 @@
7675 if( pRe==0 ){
7676 return "out of memory";
7677 }
7678 memset(pRe, 0, sizeof(*pRe));
7679 pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
7680 pRe->mxAlloc = mxRe;
7681 if( re_resize(pRe, 30) ){
7682 zErr = pRe->zErr;
7683 re_free(pRe);
7684 return zErr;
7685 }
7686 if( zIn[0]=='^' ){
7687 zIn++;
7688 }else{
7689 re_append(pRe, RE_OP_ANYSTAR, 0);
@@ -7722,10 +7731,18 @@
7731 if( j>0 && pRe->zInit[j-1]==0 ) j--;
7732 pRe->nInit = j;
7733 }
7734 return pRe->zErr;
7735 }
7736
7737 /*
7738 ** Compute a reasonable limit on the length of the REGEXP NFA.
7739 */
7740 static int re_maxlen(sqlite3_context *context){
7741 sqlite3 *db = sqlite3_context_db_handle(context);
7742 return 75 + sqlite3_limit(db, SQLITE_LIMIT_LIKE_PATTERN_LENGTH,-1)/2;
7743 }
7744
7745 /*
7746 ** Implementation of the regexp() SQL function. This function implements
7747 ** the build-in REGEXP operator. The first argument to the function is the
7748 ** pattern and the second argument is the string. So, the SQL statements:
@@ -7748,11 +7765,12 @@
7765 (void)argc; /* Unused */
7766 pRe = sqlite3_get_auxdata(context, 0);
7767 if( pRe==0 ){
7768 zPattern = (const char*)sqlite3_value_text(argv[0]);
7769 if( zPattern==0 ) return;
7770 zErr = re_compile(&pRe, zPattern, re_maxlen(context),
7771 sqlite3_user_data(context)!=0);
7772 if( zErr ){
7773 re_free(pRe);
7774 sqlite3_result_error(context, zErr, -1);
7775 return;
7776 }
@@ -7793,11 +7811,12 @@
7811 char *z;
7812 (void)argc;
7813
7814 zPattern = (const char*)sqlite3_value_text(argv[0]);
7815 if( zPattern==0 ) return;
7816 zErr = re_compile(&pRe, zPattern, re_maxlen(context),
7817 sqlite3_user_data(context)!=0);
7818 if( zErr ){
7819 re_free(pRe);
7820 sqlite3_result_error(context, zErr, -1);
7821 return;
7822 }
7823
M extsrc/sqlite3.c
+3 -3
--- extsrc/sqlite3.c
+++ extsrc/sqlite3.c
@@ -16,11 +16,11 @@
1616
 ** if you want a wrapper to interface SQLite with your choice of programming
1717
 ** language. The code for the "sqlite3" command-line shell is also in a
1818
 ** separate file. This file contains only code for the core SQLite library.
1919
 **
2020
 ** The content in this amalgamation comes from Fossil check-in
21
-** 911c745f88c0ee8569e67bbcbbab034264f8 with changes in files:
21
+** 869c968569b09d05a5b7d587d8fddb3b4611 with changes in files:
2222
 **
2323
 **
2424
 */
2525
 #ifndef SQLITE_AMALGAMATION
2626
 #define SQLITE_CORE 1
@@ -467,14 +467,14 @@
467467
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
468468
 ** [sqlite_version()] and [sqlite_source_id()].
469469
 */
470470
 #define SQLITE_VERSION "3.51.0"
471471
 #define SQLITE_VERSION_NUMBER 3051000
472
-#define SQLITE_SOURCE_ID "2025-09-26 13:14:20 911c745f88c0ee8569e67bbcbbab034264f8c981b505aadac3ce7289486a1a68"
472
+#define SQLITE_SOURCE_ID "2025-09-26 15:38:52 869c968569b09d05a5b7d587d8fddb3b4611daf7467dc157701e5dc6c960alt1"
473473
 #define SQLITE_SCM_BRANCH "trunk"
474474
 #define SQLITE_SCM_TAGS ""
475
-#define SQLITE_SCM_DATETIME "2025-09-26T13:14:20.156Z"
475
+#define SQLITE_SCM_DATETIME "2025-09-26T15:38:52.279Z"
476476
477477
 /*
478478
 ** CAPI3REF: Run-Time Library Version Numbers
479479
 ** KEYWORDS: sqlite3_version sqlite3_sourceid
480480
 **
481481
--- extsrc/sqlite3.c
+++ extsrc/sqlite3.c
@@ -16,11 +16,11 @@
16 ** if you want a wrapper to interface SQLite with your choice of programming
17 ** language. The code for the "sqlite3" command-line shell is also in a
18 ** separate file. This file contains only code for the core SQLite library.
19 **
20 ** The content in this amalgamation comes from Fossil check-in
21 ** 911c745f88c0ee8569e67bbcbbab034264f8 with changes in files:
22 **
23 **
24 */
25 #ifndef SQLITE_AMALGAMATION
26 #define SQLITE_CORE 1
@@ -467,14 +467,14 @@
467 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
468 ** [sqlite_version()] and [sqlite_source_id()].
469 */
470 #define SQLITE_VERSION "3.51.0"
471 #define SQLITE_VERSION_NUMBER 3051000
472 #define SQLITE_SOURCE_ID "2025-09-26 13:14:20 911c745f88c0ee8569e67bbcbbab034264f8c981b505aadac3ce7289486a1a68"
473 #define SQLITE_SCM_BRANCH "trunk"
474 #define SQLITE_SCM_TAGS ""
475 #define SQLITE_SCM_DATETIME "2025-09-26T13:14:20.156Z"
476
477 /*
478 ** CAPI3REF: Run-Time Library Version Numbers
479 ** KEYWORDS: sqlite3_version sqlite3_sourceid
480 **
481
--- extsrc/sqlite3.c
+++ extsrc/sqlite3.c
@@ -16,11 +16,11 @@
16 ** if you want a wrapper to interface SQLite with your choice of programming
17 ** language. The code for the "sqlite3" command-line shell is also in a
18 ** separate file. This file contains only code for the core SQLite library.
19 **
20 ** The content in this amalgamation comes from Fossil check-in
21 ** 869c968569b09d05a5b7d587d8fddb3b4611 with changes in files:
22 **
23 **
24 */
25 #ifndef SQLITE_AMALGAMATION
26 #define SQLITE_CORE 1
@@ -467,14 +467,14 @@
467 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
468 ** [sqlite_version()] and [sqlite_source_id()].
469 */
470 #define SQLITE_VERSION "3.51.0"
471 #define SQLITE_VERSION_NUMBER 3051000
472 #define SQLITE_SOURCE_ID "2025-09-26 15:38:52 869c968569b09d05a5b7d587d8fddb3b4611daf7467dc157701e5dc6c960alt1"
473 #define SQLITE_SCM_BRANCH "trunk"
474 #define SQLITE_SCM_TAGS ""
475 #define SQLITE_SCM_DATETIME "2025-09-26T15:38:52.279Z"
476
477 /*
478 ** CAPI3REF: Run-Time Library Version Numbers
479 ** KEYWORDS: sqlite3_version sqlite3_sourceid
480 **
481
M extsrc/sqlite3.h
+2 -2
--- extsrc/sqlite3.h
+++ extsrc/sqlite3.h
@@ -146,14 +146,14 @@
146146
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147147
 ** [sqlite_version()] and [sqlite_source_id()].
148148
 */
149149
 #define SQLITE_VERSION "3.51.0"
150150
 #define SQLITE_VERSION_NUMBER 3051000
151
-#define SQLITE_SOURCE_ID "2025-09-26 13:14:20 911c745f88c0ee8569e67bbcbbab034264f8c981b505aadac3ce7289486a1a68"
151
+#define SQLITE_SOURCE_ID "2025-09-26 15:38:52 869c968569b09d05a5b7d587d8fddb3b4611daf7467dc157701e5dc6c960alt1"
152152
 #define SQLITE_SCM_BRANCH "trunk"
153153
 #define SQLITE_SCM_TAGS ""
154
-#define SQLITE_SCM_DATETIME "2025-09-26T13:14:20.156Z"
154
+#define SQLITE_SCM_DATETIME "2025-09-26T15:38:52.279Z"
155155
156156
 /*
157157
 ** CAPI3REF: Run-Time Library Version Numbers
158158
 ** KEYWORDS: sqlite3_version sqlite3_sourceid
159159
 **
160160
--- extsrc/sqlite3.h
+++ extsrc/sqlite3.h
@@ -146,14 +146,14 @@
146 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147 ** [sqlite_version()] and [sqlite_source_id()].
148 */
149 #define SQLITE_VERSION "3.51.0"
150 #define SQLITE_VERSION_NUMBER 3051000
151 #define SQLITE_SOURCE_ID "2025-09-26 13:14:20 911c745f88c0ee8569e67bbcbbab034264f8c981b505aadac3ce7289486a1a68"
152 #define SQLITE_SCM_BRANCH "trunk"
153 #define SQLITE_SCM_TAGS ""
154 #define SQLITE_SCM_DATETIME "2025-09-26T13:14:20.156Z"
155
156 /*
157 ** CAPI3REF: Run-Time Library Version Numbers
158 ** KEYWORDS: sqlite3_version sqlite3_sourceid
159 **
160
--- extsrc/sqlite3.h
+++ extsrc/sqlite3.h
@@ -146,14 +146,14 @@
146 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147 ** [sqlite_version()] and [sqlite_source_id()].
148 */
149 #define SQLITE_VERSION "3.51.0"
150 #define SQLITE_VERSION_NUMBER 3051000
151 #define SQLITE_SOURCE_ID "2025-09-26 15:38:52 869c968569b09d05a5b7d587d8fddb3b4611daf7467dc157701e5dc6c960alt1"
152 #define SQLITE_SCM_BRANCH "trunk"
153 #define SQLITE_SCM_TAGS ""
154 #define SQLITE_SCM_DATETIME "2025-09-26T15:38:52.279Z"
155
156 /*
157 ** CAPI3REF: Run-Time Library Version Numbers
158 ** KEYWORDS: sqlite3_version sqlite3_sourceid
159 **
160

Keyboard Shortcuts

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