Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Comment: | Merge recent enhancements from trunk. |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | apple-osx |
Files: | files | file ages | folders |
SHA3-256: |
dc3c0b8b2815c0658bc4ca7c045102d6 |
User & Date: | drh 2019-03-26 12:37:09 |
2019-04-02
| ||
00:34 | Merge enhancements from trunk. check-in: 0b35aebbb3 user: drh tags: apple-osx | |
2019-03-26
| ||
12:37 | Merge recent enhancements from trunk. check-in: dc3c0b8b28 user: drh tags: apple-osx | |
2019-03-25
| ||
22:05 | Fix an obsolete comment in the CLI. No code changes. check-in: fade103cba user: drh tags: trunk | |
2019-03-19
| ||
20:48 | Merge recent enhancements from trunk. check-in: 000f4398db user: drh tags: apple-osx | |
Changes to configure.
859 859 pdfdir 860 860 dvidir 861 861 htmldir 862 862 infodir 863 863 docdir 864 864 oldincludedir 865 865 includedir 866 +runstatedir 866 867 localstatedir 867 868 sharedstatedir 868 869 sysconfdir 869 870 datadir 870 871 datarootdir 871 872 libexecdir 872 873 sbindir ................................................................................ 960 961 sbindir='${exec_prefix}/sbin' 961 962 libexecdir='${exec_prefix}/libexec' 962 963 datarootdir='${prefix}/share' 963 964 datadir='${datarootdir}' 964 965 sysconfdir='${prefix}/etc' 965 966 sharedstatedir='${prefix}/com' 966 967 localstatedir='${prefix}/var' 968 +runstatedir='${localstatedir}/run' 967 969 includedir='${prefix}/include' 968 970 oldincludedir='/usr/include' 969 971 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' 970 972 infodir='${datarootdir}/info' 971 973 htmldir='${docdir}' 972 974 dvidir='${docdir}' 973 975 pdfdir='${docdir}' ................................................................................ 1211 1213 ac_prev=psdir ;; 1212 1214 -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) 1213 1215 psdir=$ac_optarg ;; 1214 1216 1215 1217 -q | -quiet | --quiet | --quie | --qui | --qu | --q \ 1216 1218 | -silent | --silent | --silen | --sile | --sil) 1217 1219 silent=yes ;; 1220 + 1221 + -runstatedir | --runstatedir | --runstatedi | --runstated \ 1222 + | --runstate | --runstat | --runsta | --runst | --runs \ 1223 + | --run | --ru | --r) 1224 + ac_prev=runstatedir ;; 1225 + -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ 1226 + | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ 1227 + | --run=* | --ru=* | --r=*) 1228 + runstatedir=$ac_optarg ;; 1218 1229 1219 1230 -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) 1220 1231 ac_prev=sbindir ;; 1221 1232 -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ 1222 1233 | --sbi=* | --sb=*) 1223 1234 sbindir=$ac_optarg ;; 1224 1235 ................................................................................ 1349 1360 esac 1350 1361 fi 1351 1362 1352 1363 # Check all directory arguments for consistency. 1353 1364 for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ 1354 1365 datadir sysconfdir sharedstatedir localstatedir includedir \ 1355 1366 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ 1356 - libdir localedir mandir 1367 + libdir localedir mandir runstatedir 1357 1368 do 1358 1369 eval ac_val=\$$ac_var 1359 1370 # Remove trailing slashes. 1360 1371 case $ac_val in 1361 1372 */ ) 1362 1373 ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` 1363 1374 eval $ac_var=\$ac_val;; ................................................................................ 1502 1513 Fine tuning of the installation directories: 1503 1514 --bindir=DIR user executables [EPREFIX/bin] 1504 1515 --sbindir=DIR system admin executables [EPREFIX/sbin] 1505 1516 --libexecdir=DIR program executables [EPREFIX/libexec] 1506 1517 --sysconfdir=DIR read-only single-machine data [PREFIX/etc] 1507 1518 --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] 1508 1519 --localstatedir=DIR modifiable single-machine data [PREFIX/var] 1520 + --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] 1509 1521 --libdir=DIR object code libraries [EPREFIX/lib] 1510 1522 --includedir=DIR C header files [PREFIX/include] 1511 1523 --oldincludedir=DIR C header files for non-gcc [/usr/include] 1512 1524 --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] 1513 1525 --datadir=DIR read-only architecture-independent data [DATAROOTDIR] 1514 1526 --infodir=DIR info documentation [DATAROOTDIR/info] 1515 1527 --localedir=DIR locale-dependent data [DATAROOTDIR/locale] ................................................................................ 3930 3942 { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 3931 3943 $as_echo_n "checking the name lister ($NM) interface... " >&6; } 3932 3944 if ${lt_cv_nm_interface+:} false; then : 3933 3945 $as_echo_n "(cached) " >&6 3934 3946 else 3935 3947 lt_cv_nm_interface="BSD nm" 3936 3948 echo "int some_variable = 0;" > conftest.$ac_ext 3937 - (eval echo "\"\$as_me:3937: $ac_compile\"" >&5) 3949 + (eval echo "\"\$as_me:3949: $ac_compile\"" >&5) 3938 3950 (eval "$ac_compile" 2>conftest.err) 3939 3951 cat conftest.err >&5 3940 - (eval echo "\"\$as_me:3940: $NM \\\"conftest.$ac_objext\\\"\"" >&5) 3952 + (eval echo "\"\$as_me:3952: $NM \\\"conftest.$ac_objext\\\"\"" >&5) 3941 3953 (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) 3942 3954 cat conftest.err >&5 3943 - (eval echo "\"\$as_me:3943: output\"" >&5) 3955 + (eval echo "\"\$as_me:3955: output\"" >&5) 3944 3956 cat conftest.out >&5 3945 3957 if $GREP 'External.*some_variable' conftest.out > /dev/null; then 3946 3958 lt_cv_nm_interface="MS dumpbin" 3947 3959 fi 3948 3960 rm -f conftest* 3949 3961 fi 3950 3962 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 ................................................................................ 5142 5154 ;; 5143 5155 esac 5144 5156 fi 5145 5157 rm -rf conftest* 5146 5158 ;; 5147 5159 *-*-irix6*) 5148 5160 # Find out which ABI we are using. 5149 - echo '#line 5149 "configure"' > conftest.$ac_ext 5161 + echo '#line 5161 "configure"' > conftest.$ac_ext 5150 5162 if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 5151 5163 (eval $ac_compile) 2>&5 5152 5164 ac_status=$? 5153 5165 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 5154 5166 test $ac_status = 0; }; then 5155 5167 if test "$lt_cv_prog_gnu_ld" = yes; then 5156 5168 case `/usr/bin/file conftest.$ac_objext` in ................................................................................ 6667 6679 # Note that $ac_compile itself does not contain backslashes and begins 6668 6680 # with a dollar sign (not a hyphen), so the echo should work correctly. 6669 6681 # The option is referenced via a variable to avoid confusing sed. 6670 6682 lt_compile=`echo "$ac_compile" | $SED \ 6671 6683 -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ 6672 6684 -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ 6673 6685 -e 's:$: $lt_compiler_flag:'` 6674 - (eval echo "\"\$as_me:6674: $lt_compile\"" >&5) 6686 + (eval echo "\"\$as_me:6686: $lt_compile\"" >&5) 6675 6687 (eval "$lt_compile" 2>conftest.err) 6676 6688 ac_status=$? 6677 6689 cat conftest.err >&5 6678 - echo "$as_me:6678: \$? = $ac_status" >&5 6690 + echo "$as_me:6690: \$? = $ac_status" >&5 6679 6691 if (exit $ac_status) && test -s "$ac_outfile"; then 6680 6692 # The compiler can only warn and ignore the option if not recognized 6681 6693 # So say no if there are warnings other than the usual output. 6682 6694 $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp 6683 6695 $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 6684 6696 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then 6685 6697 lt_cv_prog_compiler_rtti_exceptions=yes ................................................................................ 7006 7018 # Note that $ac_compile itself does not contain backslashes and begins 7007 7019 # with a dollar sign (not a hyphen), so the echo should work correctly. 7008 7020 # The option is referenced via a variable to avoid confusing sed. 7009 7021 lt_compile=`echo "$ac_compile" | $SED \ 7010 7022 -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ 7011 7023 -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ 7012 7024 -e 's:$: $lt_compiler_flag:'` 7013 - (eval echo "\"\$as_me:7013: $lt_compile\"" >&5) 7025 + (eval echo "\"\$as_me:7025: $lt_compile\"" >&5) 7014 7026 (eval "$lt_compile" 2>conftest.err) 7015 7027 ac_status=$? 7016 7028 cat conftest.err >&5 7017 - echo "$as_me:7017: \$? = $ac_status" >&5 7029 + echo "$as_me:7029: \$? = $ac_status" >&5 7018 7030 if (exit $ac_status) && test -s "$ac_outfile"; then 7019 7031 # The compiler can only warn and ignore the option if not recognized 7020 7032 # So say no if there are warnings other than the usual output. 7021 7033 $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp 7022 7034 $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 7023 7035 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then 7024 7036 lt_cv_prog_compiler_pic_works=yes ................................................................................ 7111 7123 # (2) before a word containing "conftest.", or (3) at the end. 7112 7124 # Note that $ac_compile itself does not contain backslashes and begins 7113 7125 # with a dollar sign (not a hyphen), so the echo should work correctly. 7114 7126 lt_compile=`echo "$ac_compile" | $SED \ 7115 7127 -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ 7116 7128 -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ 7117 7129 -e 's:$: $lt_compiler_flag:'` 7118 - (eval echo "\"\$as_me:7118: $lt_compile\"" >&5) 7130 + (eval echo "\"\$as_me:7130: $lt_compile\"" >&5) 7119 7131 (eval "$lt_compile" 2>out/conftest.err) 7120 7132 ac_status=$? 7121 7133 cat out/conftest.err >&5 7122 - echo "$as_me:7122: \$? = $ac_status" >&5 7134 + echo "$as_me:7134: \$? = $ac_status" >&5 7123 7135 if (exit $ac_status) && test -s out/conftest2.$ac_objext 7124 7136 then 7125 7137 # The compiler can only warn and ignore the option if not recognized 7126 7138 # So say no if there are warnings 7127 7139 $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp 7128 7140 $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 7129 7141 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then ................................................................................ 7166 7178 # (2) before a word containing "conftest.", or (3) at the end. 7167 7179 # Note that $ac_compile itself does not contain backslashes and begins 7168 7180 # with a dollar sign (not a hyphen), so the echo should work correctly. 7169 7181 lt_compile=`echo "$ac_compile" | $SED \ 7170 7182 -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ 7171 7183 -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ 7172 7184 -e 's:$: $lt_compiler_flag:'` 7173 - (eval echo "\"\$as_me:7173: $lt_compile\"" >&5) 7185 + (eval echo "\"\$as_me:7185: $lt_compile\"" >&5) 7174 7186 (eval "$lt_compile" 2>out/conftest.err) 7175 7187 ac_status=$? 7176 7188 cat out/conftest.err >&5 7177 - echo "$as_me:7177: \$? = $ac_status" >&5 7189 + echo "$as_me:7189: \$? = $ac_status" >&5 7178 7190 if (exit $ac_status) && test -s out/conftest2.$ac_objext 7179 7191 then 7180 7192 # The compiler can only warn and ignore the option if not recognized 7181 7193 # So say no if there are warnings 7182 7194 $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp 7183 7195 $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 7184 7196 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then ................................................................................ 9546 9558 else 9547 9559 if test "$cross_compiling" = yes; then : 9548 9560 lt_cv_dlopen_self=cross 9549 9561 else 9550 9562 lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 9551 9563 lt_status=$lt_dlunknown 9552 9564 cat > conftest.$ac_ext <<_LT_EOF 9553 -#line 9553 "configure" 9565 +#line 9565 "configure" 9554 9566 #include "confdefs.h" 9555 9567 9556 9568 #if HAVE_DLFCN_H 9557 9569 #include <dlfcn.h> 9558 9570 #endif 9559 9571 9560 9572 #include <stdio.h> ................................................................................ 9642 9654 else 9643 9655 if test "$cross_compiling" = yes; then : 9644 9656 lt_cv_dlopen_self_static=cross 9645 9657 else 9646 9658 lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 9647 9659 lt_status=$lt_dlunknown 9648 9660 cat > conftest.$ac_ext <<_LT_EOF 9649 -#line 9649 "configure" 9661 +#line 9661 "configure" 9650 9662 #include "confdefs.h" 9651 9663 9652 9664 #if HAVE_DLFCN_H 9653 9665 #include <dlfcn.h> 9654 9666 #endif 9655 9667 9656 9668 #include <stdio.h> ................................................................................ 9991 10003 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9992 10004 /* end confdefs.h. */ 9993 10005 #include <sys/types.h> 9994 10006 /* Check that off_t can represent 2**63 - 1 correctly. 9995 10007 We can't simply define LARGE_OFF_T to be 9223372036854775807, 9996 10008 since some C++ compilers masquerading as C compilers 9997 10009 incorrectly reject 9223372036854775807. */ 9998 -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) 10010 +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) 9999 10011 int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 10000 10012 && LARGE_OFF_T % 2147483647 == 1) 10001 10013 ? 1 : -1]; 10002 10014 int 10003 10015 main () 10004 10016 { 10005 10017 ................................................................................ 10037 10049 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10038 10050 /* end confdefs.h. */ 10039 10051 #include <sys/types.h> 10040 10052 /* Check that off_t can represent 2**63 - 1 correctly. 10041 10053 We can't simply define LARGE_OFF_T to be 9223372036854775807, 10042 10054 since some C++ compilers masquerading as C compilers 10043 10055 incorrectly reject 9223372036854775807. */ 10044 -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) 10056 +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) 10045 10057 int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 10046 10058 && LARGE_OFF_T % 2147483647 == 1) 10047 10059 ? 1 : -1]; 10048 10060 int 10049 10061 main () 10050 10062 { 10051 10063 ................................................................................ 10061 10073 /* end confdefs.h. */ 10062 10074 #define _FILE_OFFSET_BITS 64 10063 10075 #include <sys/types.h> 10064 10076 /* Check that off_t can represent 2**63 - 1 correctly. 10065 10077 We can't simply define LARGE_OFF_T to be 9223372036854775807, 10066 10078 since some C++ compilers masquerading as C compilers 10067 10079 incorrectly reject 9223372036854775807. */ 10068 -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) 10080 +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) 10069 10081 int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 10070 10082 && LARGE_OFF_T % 2147483647 == 1) 10071 10083 ? 1 : -1]; 10072 10084 int 10073 10085 main () 10074 10086 { 10075 10087 ................................................................................ 10106 10118 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10107 10119 /* end confdefs.h. */ 10108 10120 #include <sys/types.h> 10109 10121 /* Check that off_t can represent 2**63 - 1 correctly. 10110 10122 We can't simply define LARGE_OFF_T to be 9223372036854775807, 10111 10123 since some C++ compilers masquerading as C compilers 10112 10124 incorrectly reject 9223372036854775807. */ 10113 -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) 10125 +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) 10114 10126 int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 10115 10127 && LARGE_OFF_T % 2147483647 == 1) 10116 10128 ? 1 : -1]; 10117 10129 int 10118 10130 main () 10119 10131 { 10120 10132 ................................................................................ 10130 10142 /* end confdefs.h. */ 10131 10143 #define _LARGE_FILES 1 10132 10144 #include <sys/types.h> 10133 10145 /* Check that off_t can represent 2**63 - 1 correctly. 10134 10146 We can't simply define LARGE_OFF_T to be 9223372036854775807, 10135 10147 since some C++ compilers masquerading as C compilers 10136 10148 incorrectly reject 9223372036854775807. */ 10137 -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) 10149 +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) 10138 10150 int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 10139 10151 && LARGE_OFF_T % 2147483647 == 1) 10140 10152 ? 1 : -1]; 10141 10153 int 10142 10154 main () 10143 10155 { 10144 10156
Changes to ext/fts3/fts3_term.c.
94 94 95 95 rc = sqlite3_declare_vtab(db, FTS3_TERMS_SCHEMA); 96 96 if( rc!=SQLITE_OK ) return rc; 97 97 98 98 nByte = sizeof(Fts3termTable) + sizeof(Fts3Table) + nDb + nFts3 + 2; 99 99 p = (Fts3termTable *)sqlite3_malloc64(nByte); 100 100 if( !p ) return SQLITE_NOMEM; 101 - memset(p, 0, nByte); 101 + memset(p, 0, (size_t)nByte); 102 102 103 103 p->pFts3Tab = (Fts3Table *)&p[1]; 104 104 p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1]; 105 105 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1]; 106 106 p->pFts3Tab->db = db; 107 107 p->pFts3Tab->nIndex = iIndex+1; 108 108 p->iIndex = iIndex;
Changes to ext/fts3/unicode/mkunicode.tcl.
734 734 void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){ 735 735 int i = 0; 736 736 int iTbl = 0; 737 737 while( i<128 ){ 738 738 int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ]; 739 739 int n = (aFts5UnicodeData[iTbl] >> 5) + i; 740 740 for(; i<128 && i<n; i++){ 741 - aAscii[i] = bToken; 741 + aAscii[i] = (u8)bToken; 742 742 } 743 743 iTbl++; 744 744 } 745 745 } 746 746 }] 747 747 } 748 748
Changes to ext/fts5/fts5_aux.c.
349 349 } 350 350 351 351 *pnScore = nScore; 352 352 if( piPos ){ 353 353 sqlite3_int64 iAdj = iFirst - (nToken - (iLast-iFirst)) / 2; 354 354 if( (iAdj+nToken)>nDocsize ) iAdj = nDocsize - nToken; 355 355 if( iAdj<0 ) iAdj = 0; 356 - *piPos = iAdj; 356 + *piPos = (int)iAdj; 357 357 } 358 358 359 359 return rc; 360 360 } 361 361 362 362 /* 363 363 ** Return the value in pVal interpreted as utf-8 text. Except, if pVal ................................................................................ 577 577 /* Allocate the Fts5Bm25Data object */ 578 578 nPhrase = pApi->xPhraseCount(pFts); 579 579 nByte = sizeof(Fts5Bm25Data) + nPhrase*2*sizeof(double); 580 580 p = (Fts5Bm25Data*)sqlite3_malloc64(nByte); 581 581 if( p==0 ){ 582 582 rc = SQLITE_NOMEM; 583 583 }else{ 584 - memset(p, 0, nByte); 584 + memset(p, 0, (size_t)nByte); 585 585 p->nPhrase = nPhrase; 586 586 p->aIDF = (double*)&p[1]; 587 587 p->aFreq = &p->aIDF[nPhrase]; 588 588 } 589 589 590 590 /* Calculate the average document length for this FTS5 table */ 591 591 if( rc==SQLITE_OK ) rc = pApi->xRowCount(pFts, &nRow);
Changes to ext/fts5/fts5_buffer.c.
23 23 nNew = nNew * 2; 24 24 } 25 25 pNew = sqlite3_realloc64(pBuf->p, nNew); 26 26 if( pNew==0 ){ 27 27 *pRc = SQLITE_NOMEM; 28 28 return 1; 29 29 }else{ 30 - pBuf->nSpace = nNew; 30 + pBuf->nSpace = (int)nNew; 31 31 pBuf->p = pNew; 32 32 } 33 33 } 34 34 return 0; 35 35 } 36 36 37 37 ................................................................................ 247 247 void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte){ 248 248 void *pRet = 0; 249 249 if( *pRc==SQLITE_OK ){ 250 250 pRet = sqlite3_malloc64(nByte); 251 251 if( pRet==0 ){ 252 252 if( nByte>0 ) *pRc = SQLITE_NOMEM; 253 253 }else{ 254 - memset(pRet, 0, nByte); 254 + memset(pRet, 0, (size_t)nByte); 255 255 } 256 256 } 257 257 return pRet; 258 258 } 259 259 260 260 /* 261 261 ** Return a nul-terminated copy of the string indicated by pIn. If nIn
Changes to ext/fts5/fts5_config.c.
321 321 } 322 322 } 323 323 if( p==0 ){ 324 324 *pzErr = sqlite3_mprintf("parse error in tokenize directive"); 325 325 rc = SQLITE_ERROR; 326 326 }else{ 327 327 rc = sqlite3Fts5GetTokenizer(pGlobal, 328 - (const char**)azArg, nArg, &pConfig->pTok, &pConfig->pTokApi, 328 + (const char**)azArg, (int)nArg, &pConfig->pTok, &pConfig->pTokApi, 329 329 pzErr 330 330 ); 331 331 } 332 332 } 333 333 } 334 334 335 335 sqlite3_free(azArg); ................................................................................ 431 431 assert( *pRc==SQLITE_OK ); 432 432 *pbQuoted = 0; 433 433 *pzOut = 0; 434 434 435 435 if( zOut==0 ){ 436 436 *pRc = SQLITE_NOMEM; 437 437 }else{ 438 - memcpy(zOut, zIn, nIn+1); 438 + memcpy(zOut, zIn, (size_t)(nIn+1)); 439 439 if( fts5_isopenquote(zOut[0]) ){ 440 440 int ii = fts5Dequote(zOut); 441 441 zRet = &zIn[ii]; 442 442 *pbQuoted = 1; 443 443 }else{ 444 444 zRet = fts5ConfigSkipBareword(zIn); 445 445 if( zRet ){
Changes to ext/fts5/fts5_expr.c.
1483 1483 if( pNear==0 ){ 1484 1484 sqlite3_int64 nByte; 1485 1485 nByte = sizeof(Fts5ExprNearset) + SZALLOC * sizeof(Fts5ExprPhrase*); 1486 1486 pRet = sqlite3_malloc64(nByte); 1487 1487 if( pRet==0 ){ 1488 1488 pParse->rc = SQLITE_NOMEM; 1489 1489 }else{ 1490 - memset(pRet, 0, nByte); 1490 + memset(pRet, 0, (size_t)nByte); 1491 1491 } 1492 1492 }else if( (pNear->nPhrase % SZALLOC)==0 ){ 1493 1493 int nNew = pNear->nPhrase + SZALLOC; 1494 1494 sqlite3_int64 nByte; 1495 1495 1496 1496 nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*); 1497 1497 pRet = (Fts5ExprNearset*)sqlite3_realloc64(pNear, nByte); ................................................................................ 1559 1559 if( pPhrase && pPhrase->nTerm>0 && (tflags & FTS5_TOKEN_COLOCATED) ){ 1560 1560 Fts5ExprTerm *pSyn; 1561 1561 sqlite3_int64 nByte = sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer) + nToken+1; 1562 1562 pSyn = (Fts5ExprTerm*)sqlite3_malloc64(nByte); 1563 1563 if( pSyn==0 ){ 1564 1564 rc = SQLITE_NOMEM; 1565 1565 }else{ 1566 - memset(pSyn, 0, nByte); 1566 + memset(pSyn, 0, (size_t)nByte); 1567 1567 pSyn->zTerm = ((char*)pSyn) + sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer); 1568 1568 memcpy(pSyn->zTerm, pToken, nToken); 1569 1569 pSyn->pSynonym = pPhrase->aTerm[pPhrase->nTerm-1].pSynonym; 1570 1570 pPhrase->aTerm[pPhrase->nTerm-1].pSynonym = pSyn; 1571 1571 } 1572 1572 }else{ 1573 1573 Fts5ExprTerm *pTerm; ................................................................................ 1719 1719 Fts5Colset *pColsetOrig = pOrig->pNode->pNear->pColset; 1720 1720 if( pColsetOrig ){ 1721 1721 sqlite3_int64 nByte; 1722 1722 Fts5Colset *pColset; 1723 1723 nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int); 1724 1724 pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&rc, nByte); 1725 1725 if( pColset ){ 1726 - memcpy(pColset, pColsetOrig, nByte); 1726 + memcpy(pColset, pColsetOrig, (size_t)nByte); 1727 1727 } 1728 1728 pNew->pRoot->pNear->pColset = pColset; 1729 1729 } 1730 1730 } 1731 1731 1732 1732 if( pOrig->nTerm ){ 1733 1733 int i; /* Used to iterate through phrase terms */ ................................................................................ 1936 1936 */ 1937 1937 static Fts5Colset *fts5CloneColset(int *pRc, Fts5Colset *pOrig){ 1938 1938 Fts5Colset *pRet; 1939 1939 if( pOrig ){ 1940 1940 sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int); 1941 1941 pRet = (Fts5Colset*)sqlite3Fts5MallocZero(pRc, nByte); 1942 1942 if( pRet ){ 1943 - memcpy(pRet, pOrig, nByte); 1943 + memcpy(pRet, pOrig, (size_t)nByte); 1944 1944 } 1945 1945 }else{ 1946 1946 pRet = 0; 1947 1947 } 1948 1948 return pRet; 1949 1949 } 1950 1950
Changes to ext/fts5/fts5_hash.c.
99 99 nByte = sizeof(Fts5HashEntry*) * pNew->nSlot; 100 100 pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte); 101 101 if( pNew->aSlot==0 ){ 102 102 sqlite3_free(pNew); 103 103 *ppNew = 0; 104 104 rc = SQLITE_NOMEM; 105 105 }else{ 106 - memset(pNew->aSlot, 0, nByte); 106 + memset(pNew->aSlot, 0, (size_t)nByte); 107 107 } 108 108 } 109 109 return rc; 110 110 } 111 111 112 112 /* 113 113 ** Free a hash table object. ................................................................................ 280 280 iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken); 281 281 } 282 282 283 283 /* Allocate new Fts5HashEntry and add it to the hash table. */ 284 284 p = (Fts5HashEntry*)sqlite3_malloc64(nByte); 285 285 if( !p ) return SQLITE_NOMEM; 286 286 memset(p, 0, sizeof(Fts5HashEntry)); 287 - p->nAlloc = nByte; 287 + p->nAlloc = (int)nByte; 288 288 zKey = fts5EntryKey(p); 289 289 zKey[0] = bByte; 290 290 memcpy(&zKey[1], pToken, nToken); 291 291 assert( iHash==fts5HashKey(pHash->nSlot, (u8*)zKey, nToken+1) ); 292 292 p->nKey = nToken; 293 293 zKey[nToken+1] = '\0'; 294 294 p->nData = nToken+1 + 1 + sizeof(Fts5HashEntry);
Changes to ext/fts5/fts5_main.c.
629 629 630 630 rc = fts5NewTransaction(pTab); 631 631 if( rc==SQLITE_OK ){ 632 632 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int); 633 633 pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte); 634 634 if( pCsr ){ 635 635 Fts5Global *pGlobal = pTab->pGlobal; 636 - memset(pCsr, 0, nByte); 636 + memset(pCsr, 0, (size_t)nByte); 637 637 pCsr->aColumnSize = (int*)&pCsr[1]; 638 638 pCsr->pNext = pGlobal->pCsr; 639 639 pGlobal->pCsr = pCsr; 640 640 pCsr->iCsrId = ++pGlobal->iNextId; 641 641 }else{ 642 642 rc = SQLITE_NOMEM; 643 643 } ................................................................................ 910 910 const char *zRank = pCsr->zRank; 911 911 const char *zRankArgs = pCsr->zRankArgs; 912 912 913 913 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr); 914 914 nByte = sizeof(Fts5Sorter) + sizeof(int) * (nPhrase-1); 915 915 pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte); 916 916 if( pSorter==0 ) return SQLITE_NOMEM; 917 - memset(pSorter, 0, nByte); 917 + memset(pSorter, 0, (size_t)nByte); 918 918 pSorter->nIdx = nPhrase; 919 919 920 920 /* TODO: It would be better to have some system for reusing statement 921 921 ** handles here, rather than preparing a new one for each query. But that 922 922 ** is not possible as SQLite reference counts the virtual table objects. 923 923 ** And since the statement required here reads from this very virtual 924 924 ** table, saving it creates a circular reference.
Changes to ext/fts5/fts5_storage.c.
285 285 sqlite3_int64 nByte; /* Bytes of space to allocate */ 286 286 287 287 nByte = sizeof(Fts5Storage) /* Fts5Storage object */ 288 288 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */ 289 289 *pp = p = (Fts5Storage*)sqlite3_malloc64(nByte); 290 290 if( !p ) return SQLITE_NOMEM; 291 291 292 - memset(p, 0, nByte); 292 + memset(p, 0, (size_t)nByte); 293 293 p->aTotalSize = (i64*)&p[1]; 294 294 p->pConfig = pConfig; 295 295 p->pIndex = pIndex; 296 296 297 297 if( bCreate ){ 298 298 if( pConfig->eContent==FTS5_CONTENT_NORMAL ){ 299 299 int nDefn = 32 + pConfig->nCol*10;
Changes to ext/fts5/fts5_unicode2.c.
765 765 void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){ 766 766 int i = 0; 767 767 int iTbl = 0; 768 768 while( i<128 ){ 769 769 int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ]; 770 770 int n = (aFts5UnicodeData[iTbl] >> 5) + i; 771 771 for(; i<128 && i<n; i++){ 772 - aAscii[i] = bToken; 772 + aAscii[i] = (u8)bToken; 773 773 } 774 774 iTbl++; 775 775 } 776 776 }
Changes to ext/misc/amatch.c.
743 743 744 744 nIn = strlen(zIn); 745 745 zOut = sqlite3_malloc64(nIn+1); 746 746 if( zOut ){ 747 747 char q = zIn[0]; /* Quote character (if any ) */ 748 748 749 749 if( q!='[' && q!= '\'' && q!='"' && q!='`' ){ 750 - memcpy(zOut, zIn, nIn+1); 750 + memcpy(zOut, zIn, (size_t)(nIn+1)); 751 751 }else{ 752 752 int iOut = 0; /* Index of next byte to write to output */ 753 753 int iIn; /* Index of next byte to read from input */ 754 754 755 755 if( q=='[' ) q = ']'; 756 756 for(iIn=1; iIn<nIn; iIn++){ 757 757 if( zIn[iIn]==q ) iIn++;
Changes to ext/misc/closure.c.
427 427 428 428 nIn = strlen(zIn); 429 429 zOut = sqlite3_malloc64(nIn+1); 430 430 if( zOut ){ 431 431 char q = zIn[0]; /* Quote character (if any ) */ 432 432 433 433 if( q!='[' && q!= '\'' && q!='"' && q!='`' ){ 434 - memcpy(zOut, zIn, nIn+1); 434 + memcpy(zOut, zIn, (size_t)(nIn+1)); 435 435 }else{ 436 436 int iOut = 0; /* Index of next byte to write to output */ 437 437 int iIn; /* Index of next byte to read from input */ 438 438 439 439 if( q=='[' ) q = ']'; 440 440 for(iIn=1; iIn<nIn; iIn++){ 441 441 if( zIn[iIn]==q ) iIn++;
Changes to ext/misc/fileio.c.
154 154 } 155 155 pBuf = sqlite3_malloc64( nIn ? nIn : 1 ); 156 156 if( pBuf==0 ){ 157 157 sqlite3_result_error_nomem(ctx); 158 158 fclose(in); 159 159 return; 160 160 } 161 - if( nIn==fread(pBuf, 1, nIn, in) ){ 161 + if( nIn==fread(pBuf, 1, (size_t)nIn, in) ){ 162 162 sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free); 163 163 }else{ 164 164 sqlite3_result_error_code(ctx, SQLITE_IOERR); 165 165 sqlite3_free(pBuf); 166 166 } 167 167 fclose(in); 168 168 } ................................................................................ 289 289 #endif 290 290 } 291 291 292 292 /* 293 293 ** Argument zFile is the name of a file that will be created and/or written 294 294 ** by SQL function writefile(). This function ensures that the directory 295 295 ** zFile will be written to exists, creating it if required. The permissions 296 -** for any path components created by this function are set to (mode&0777). 296 +** for any path components created by this function are set in accordance 297 +** with the current umask. 297 298 ** 298 299 ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise, 299 300 ** SQLITE_OK is returned if the directory is successfully created, or 300 301 ** SQLITE_ERROR otherwise. 301 302 */ 302 303 static int makeDirectory( 303 - const char *zFile, 304 - mode_t mode 304 + const char *zFile 305 305 ){ 306 306 char *zCopy = sqlite3_mprintf("%s", zFile); 307 307 int rc = SQLITE_OK; 308 308 309 309 if( zCopy==0 ){ 310 310 rc = SQLITE_NOMEM; 311 311 }else{ ................................................................................ 318 318 319 319 for(; zCopy[i]!='/' && i<nCopy; i++); 320 320 if( i==nCopy ) break; 321 321 zCopy[i] = '\0'; 322 322 323 323 rc2 = fileStat(zCopy, &sStat); 324 324 if( rc2!=0 ){ 325 - if( mkdir(zCopy, mode & 0777) ) rc = SQLITE_ERROR; 325 + if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR; 326 326 }else{ 327 327 if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR; 328 328 } 329 329 zCopy[i] = '/'; 330 330 i++; 331 331 } 332 332 ................................................................................ 476 476 } 477 477 if( argc==4 ){ 478 478 mtime = sqlite3_value_int64(argv[3]); 479 479 } 480 480 481 481 res = writeFile(context, zFile, argv[1], mode, mtime); 482 482 if( res==1 && errno==ENOENT ){ 483 - if( makeDirectory(zFile, mode)==SQLITE_OK ){ 483 + if( makeDirectory(zFile)==SQLITE_OK ){ 484 484 res = writeFile(context, zFile, argv[1], mode, mtime); 485 485 } 486 486 } 487 487 488 488 if( argc>2 && res!=0 ){ 489 489 if( S_ISLNK(mode) ){ 490 490 ctxErrorMsg(context, "failed to create symlink: %s", zFile);
Changes to ext/misc/fuzzer.c.
452 452 453 453 nIn = strlen(zIn); 454 454 zOut = sqlite3_malloc64(nIn+1); 455 455 if( zOut ){ 456 456 char q = zIn[0]; /* Quote character (if any ) */ 457 457 458 458 if( q!='[' && q!= '\'' && q!='"' && q!='`' ){ 459 - memcpy(zOut, zIn, nIn+1); 459 + memcpy(zOut, zIn, (size_t)(nIn+1)); 460 460 }else{ 461 461 int iOut = 0; /* Index of next byte to write to output */ 462 462 int iIn; /* Index of next byte to read from input */ 463 463 464 464 if( q=='[' ) q = ']'; 465 465 for(iIn=1; iIn<nIn; iIn++){ 466 466 if( zIn[iIn]==q ) iIn++; ................................................................................ 520 520 if( pNew==0 ){ 521 521 rc = SQLITE_NOMEM; 522 522 }else{ 523 523 char *zTab; /* Dequoted name of fuzzer data table */ 524 524 525 525 memset(pNew, 0, sizeof(*pNew)); 526 526 pNew->zClassName = (char*)&pNew[1]; 527 - memcpy(pNew->zClassName, zModule, nModule+1); 527 + memcpy(pNew->zClassName, zModule, (size_t)(nModule+1)); 528 528 529 529 zTab = fuzzerDequote(argv[3]); 530 530 if( zTab==0 ){ 531 531 rc = SQLITE_NOMEM; 532 532 }else{ 533 533 rc = fuzzerLoadRules(db, pNew, zDb, zTab, pzErr); 534 534 sqlite3_free(zTab);
Changes to ext/misc/unionvtab.c.
252 252 */ 253 253 static void *unionMalloc(int *pRc, sqlite3_int64 nByte){ 254 254 void *pRet; 255 255 assert( nByte>0 ); 256 256 if( *pRc==SQLITE_OK ){ 257 257 pRet = sqlite3_malloc64(nByte); 258 258 if( pRet ){ 259 - memset(pRet, 0, nByte); 259 + memset(pRet, 0, (size_t)nByte); 260 260 }else{ 261 261 *pRc = SQLITE_NOMEM; 262 262 } 263 263 }else{ 264 264 pRet = 0; 265 265 } 266 266 return pRet; ................................................................................ 275 275 */ 276 276 static char *unionStrdup(int *pRc, const char *zIn){ 277 277 char *zRet = 0; 278 278 if( zIn ){ 279 279 sqlite3_int64 nByte = strlen(zIn) + 1; 280 280 zRet = unionMalloc(pRc, nByte); 281 281 if( zRet ){ 282 - memcpy(zRet, zIn, nByte); 282 + memcpy(zRet, zIn, (size_t)nByte); 283 283 } 284 284 } 285 285 return zRet; 286 286 } 287 287 288 288 /* 289 289 ** If the first character of the string passed as the only argument to this
Changes to ext/rtree/rtree.c.
3752 3752 ** 3753 3753 ** The human readable string takes the form of a Tcl list with one 3754 3754 ** entry for each cell in the r-tree node. Each entry is itself a 3755 3755 ** list, containing the 8-byte rowid/pageno followed by the 3756 3756 ** <num-dimension>*2 coordinates. 3757 3757 */ 3758 3758 static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){ 3759 - char *zText = 0; 3760 3759 RtreeNode node; 3761 3760 Rtree tree; 3762 3761 int ii; 3762 + int nData; 3763 + int errCode; 3764 + sqlite3_str *pOut; 3763 3765 3764 3766 UNUSED_PARAMETER(nArg); 3765 3767 memset(&node, 0, sizeof(RtreeNode)); 3766 3768 memset(&tree, 0, sizeof(Rtree)); 3767 3769 tree.nDim = (u8)sqlite3_value_int(apArg[0]); 3770 + if( tree.nDim<1 || tree.nDim>5 ) return; 3768 3771 tree.nDim2 = tree.nDim*2; 3769 3772 tree.nBytesPerCell = 8 + 8 * tree.nDim; 3770 3773 node.zData = (u8 *)sqlite3_value_blob(apArg[1]); 3774 + nData = sqlite3_value_bytes(apArg[1]); 3775 + if( nData<4 ) return; 3776 + if( nData<NCELL(&node)*tree.nBytesPerCell ) return; 3771 3777 3778 + pOut = sqlite3_str_new(0); 3772 3779 for(ii=0; ii<NCELL(&node); ii++){ 3773 - char zCell[512]; 3774 - int nCell = 0; 3775 3780 RtreeCell cell; 3776 3781 int jj; 3777 3782 3778 3783 nodeGetCell(&tree, &node, ii, &cell); 3779 - sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid); 3780 - nCell = (int)strlen(zCell); 3784 + if( ii>0 ) sqlite3_str_append(pOut, " ", 1); 3785 + sqlite3_str_appendf(pOut, "{%lld", cell.iRowid); 3781 3786 for(jj=0; jj<tree.nDim2; jj++){ 3782 3787 #ifndef SQLITE_RTREE_INT_ONLY 3783 - sqlite3_snprintf(512-nCell,&zCell[nCell], " %g", 3784 - (double)cell.aCoord[jj].f); 3788 + sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f); 3785 3789 #else 3786 - sqlite3_snprintf(512-nCell,&zCell[nCell], " %d", 3787 - cell.aCoord[jj].i); 3790 + sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i); 3788 3791 #endif 3789 - nCell = (int)strlen(zCell); 3790 3792 } 3791 - 3792 - if( zText ){ 3793 - char *zTextNew = sqlite3_mprintf("%s {%s}", zText, zCell); 3794 - sqlite3_free(zText); 3795 - zText = zTextNew; 3796 - }else{ 3797 - zText = sqlite3_mprintf("{%s}", zCell); 3798 - } 3793 + sqlite3_str_append(pOut, "}", 1); 3799 3794 } 3800 - 3801 - sqlite3_result_text(ctx, zText, -1, sqlite3_free); 3795 + errCode = sqlite3_str_errcode(pOut); 3796 + sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free); 3797 + sqlite3_result_error_code(ctx, errCode); 3802 3798 } 3803 3799 3804 3800 /* This routine implements an SQL function that returns the "depth" parameter 3805 3801 ** from the front of a blob that is an r-tree node. For example: 3806 3802 ** 3807 3803 ** SELECT rtreedepth(data) FROM rt_node WHERE nodeno=1; 3808 3804 **
Changes to ext/session/changeset.c.
51 51 } 52 52 fseek(f, 0, SEEK_END); 53 53 sz = ftell(f); 54 54 rewind(f); 55 55 pBuf = sqlite3_malloc64( sz ? sz : 1 ); 56 56 if( pBuf==0 ){ 57 57 fprintf(stderr, "cannot allocate %d to hold content of \"%s\"\n", 58 - sz, zFilename); 58 + (int)sz, zFilename); 59 59 exit(1); 60 60 } 61 61 if( sz>0 ){ 62 - if( fread(pBuf, sz, 1, f)!=1 ){ 63 - fprintf(stderr, "cannot read all %d bytes of \"%s\"\n", sz, zFilename); 62 + if( fread(pBuf, (size_t)sz, 1, f)!=1 ){ 63 + fprintf(stderr, "cannot read all %d bytes of \"%s\"\n", 64 + (int)sz, zFilename); 64 65 exit(1); 65 66 } 66 67 fclose(f); 67 68 } 68 - *pSz = sz; 69 + *pSz = (int)sz; 69 70 *ppBuf = pBuf; 70 71 } 71 72 72 73 /* Array for converting from half-bytes (nybbles) into ASCII hex 73 74 ** digits. */ 74 75 static const char hexdigits[] = { 75 76 '0', '1', '2', '3', '4', '5', '6', '7',
Changes to src/btree.c.
1457 1457 } 1458 1458 if( iFree2 ){ 1459 1459 if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage); 1460 1460 sz2 = get2byte(&data[iFree2+2]); 1461 1461 if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage); 1462 1462 memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz)); 1463 1463 sz += sz2; 1464 + }else if( iFree+sz>usableSize ){ 1465 + return SQLITE_CORRUPT_PAGE(pPage); 1464 1466 } 1467 + 1465 1468 cbrk = top+sz; 1466 1469 assert( cbrk+(iFree-top) <= usableSize ); 1467 1470 memmove(&data[cbrk], &data[top], iFree-top); 1468 1471 for(pAddr=&data[cellOffset]; pAddr<pEnd; pAddr+=2){ 1469 1472 pc = get2byte(pAddr); 1470 1473 if( pc<iFree ){ put2byte(pAddr, pc+sz); } 1471 1474 else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); } ................................................................................ 2015 2018 } 2016 2019 testcase( pPage->nCell==MX_CELL(pBt) ); 2017 2020 /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only 2018 2021 ** possible for a root page of a table that contains no rows) then the 2019 2022 ** offset to the cell content area will equal the page size minus the 2020 2023 ** bytes of reserved space. */ 2021 2024 assert( pPage->nCell>0 2022 - || get2byteNotZero(&data[5])==pBt->usableSize 2025 + || get2byteNotZero(&data[5])==(int)pBt->usableSize 2023 2026 || CORRUPT_DB ); 2024 2027 pPage->nFree = -1; /* Indicate that this value is yet uncomputed */ 2025 2028 pPage->isInit = 1; 2026 2029 if( pBt->db->flags & SQLITE_CellSizeCk ){ 2027 2030 return btreeCellSizeCheck(pPage); 2028 2031 } 2029 2032 return SQLITE_OK; ................................................................................ 6192 6195 int rc; /* Return Code */ 6193 6196 int nFree; /* Initial number of pages on free-list */ 6194 6197 6195 6198 assert( sqlite3_mutex_held(pBt->mutex) ); 6196 6199 assert( CORRUPT_DB || iPage>1 ); 6197 6200 assert( !pMemPage || pMemPage->pgno==iPage ); 6198 6201 6199 - if( iPage<2 ) return SQLITE_CORRUPT_BKPT; 6202 + if( iPage<2 || iPage>pBt->nPage ){ 6203 + return SQLITE_CORRUPT_BKPT; 6204 + } 6200 6205 if( pMemPage ){ 6201 6206 pPage = pMemPage; 6202 6207 sqlite3PagerRef(pPage->pDbPage); 6203 6208 }else{ 6204 6209 pPage = btreePageLookup(pBt, iPage); 6205 6210 } 6206 6211 ................................................................................ 8165 8170 ** by smaller than the child due to the database header, and so all the 8166 8171 ** free space needs to be up front. 8167 8172 */ 8168 8173 assert( nNew==1 || CORRUPT_DB ); 8169 8174 rc = defragmentPage(apNew[0], -1); 8170 8175 testcase( rc!=SQLITE_OK ); 8171 8176 assert( apNew[0]->nFree == 8172 - (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2) 8177 + (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset 8178 + - apNew[0]->nCell*2) 8173 8179 || rc!=SQLITE_OK 8174 8180 ); 8175 8181 copyNodeContent(apNew[0], pParent, &rc); 8176 8182 freePage(apNew[0], &rc); 8177 8183 }else if( ISAUTOVACUUM && !leafCorrection ){ 8178 8184 /* Fix the pointer map entries associated with the right-child of each 8179 8185 ** sibling page. All other pointer map entries have already been taken
Changes to src/build.c.
1400 1400 } 1401 1401 if( nTerm==1 1402 1402 && pCol 1403 1403 && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0 1404 1404 && sortOrder!=SQLITE_SO_DESC 1405 1405 ){ 1406 1406 if( IN_RENAME_OBJECT && pList ){ 1407 - sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pList->a[0].pExpr); 1407 + Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr); 1408 + sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr); 1408 1409 } 1409 1410 pTab->iPKey = iCol; 1410 1411 pTab->keyConf = (u8)onError; 1411 1412 assert( autoInc==0 || autoInc==1 ); 1412 1413 pTab->tabFlags |= autoInc*TF_Autoincrement; 1413 1414 if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder; 1414 1415 }else if( autoInc ){ ................................................................................ 3149 3150 } 3150 3151 pDb = &db->aDb[iDb]; 3151 3152 3152 3153 assert( pTab!=0 ); 3153 3154 assert( pParse->nErr==0 ); 3154 3155 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 3155 3156 && db->init.busy==0 3157 + && pTblName!=0 3156 3158 #if SQLITE_USER_AUTHENTICATION 3157 3159 && sqlite3UserAuthTable(pTab->zName)==0 3158 3160 #endif 3159 3161 #ifdef SQLITE_ALLOW_SQLITE_MASTER_INDEX 3160 3162 && sqlite3StrICmp(&pTab->zName[7],"master")!=0 3161 3163 #endif 3162 - && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 3163 3164 ){ 3164 3165 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName); 3165 3166 goto exit_create_index; 3166 3167 } 3167 3168 #ifndef SQLITE_OMIT_VIEW 3168 3169 if( pTab->pSelect ){ 3169 3170 sqlite3ErrorMsg(pParse, "views may not be indexed");
Changes to src/main.c.
842 842 { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer }, 843 843 { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension }, 844 844 { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_NoCkptOnClose }, 845 845 { SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_EnableQPSG }, 846 846 { SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_TriggerEQP }, 847 847 { SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_ResetDatabase }, 848 848 { SQLITE_DBCONFIG_DEFENSIVE, SQLITE_Defensive }, 849 + { SQLITE_DBCONFIG_WRITABLE_SCHEMA, SQLITE_WriteSchema| 850 + SQLITE_NoSchemaError }, 849 851 }; 850 852 unsigned int i; 851 853 rc = SQLITE_ERROR; /* IMP: R-42790-23372 */ 852 854 for(i=0; i<ArraySize(aFlagOp); i++){ 853 855 if( aFlagOp[i].op==op ){ 854 856 int onoff = va_arg(ap, int); 855 857 int *pRes = va_arg(ap, int*);
Changes to src/shell.c.in.
2743 2743 sqlite3SelectTrace = savedSelectTrace; 2744 2744 #endif 2745 2745 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) 2746 2746 sqlite3WhereTrace = savedWhereTrace; 2747 2747 #endif 2748 2748 } 2749 2749 2750 -/* Name of the TEMP table that holds bind parameter values */ 2751 -#define BIND_PARAM_TABLE "$Parameters" 2752 - 2753 2750 /* Create the TEMP table used to store parameter bindings */ 2754 2751 static void bind_table_init(ShellState *p){ 2752 + int wrSchema = 0; 2753 + sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema); 2754 + sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0); 2755 2755 sqlite3_exec(p->db, 2756 - "CREATE TABLE IF NOT EXISTS temp.[" BIND_PARAM_TABLE "](\n" 2756 + "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n" 2757 2757 " key TEXT PRIMARY KEY,\n" 2758 2758 " value ANY\n" 2759 2759 ") WITHOUT ROWID;", 2760 2760 0, 0, 0); 2761 + sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0); 2761 2762 } 2762 2763 2763 2764 /* 2764 2765 ** Bind parameters on a prepared statement. 2765 2766 ** 2766 2767 ** Parameter bindings are taken from a TEMP table of the form: 2767 2768 ** 2768 -** CREATE TEMP TABLE "$Parameters"(key TEXT PRIMARY KEY, value) 2769 +** CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value) 2769 2770 ** WITHOUT ROWID; 2770 2771 ** 2771 2772 ** No bindings occur if this table does not exist. The special character '$' 2772 2773 ** is included in the table name to help prevent collisions with actual tables. 2773 2774 ** The table must be in the TEMP schema. 2774 2775 */ 2775 2776 static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){ ................................................................................ 2776 2777 int nVar; 2777 2778 int i; 2778 2779 int rc; 2779 2780 sqlite3_stmt *pQ = 0; 2780 2781 2781 2782 nVar = sqlite3_bind_parameter_count(pStmt); 2782 2783 if( nVar==0 ) return; /* Nothing to do */ 2783 - if( sqlite3_table_column_metadata(pArg->db, "TEMP", BIND_PARAM_TABLE, 2784 + if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters", 2784 2785 "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){ 2785 2786 return; /* Parameter table does not exist */ 2786 2787 } 2787 2788 rc = sqlite3_prepare_v2(pArg->db, 2788 - "SELECT value FROM temp.\"" BIND_PARAM_TABLE "\"" 2789 + "SELECT value FROM temp.sqlite_parameters" 2789 2790 " WHERE key=?1", -1, &pQ, 0); 2790 2791 if( rc || pQ==0 ) return; 2791 2792 for(i=1; i<=nVar; i++){ 2792 2793 char zNum[30]; 2793 2794 const char *zVar = sqlite3_bind_parameter_name(pStmt, i); 2794 2795 if( zVar==0 ){ 2795 2796 sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i); ................................................................................ 3448 3449 ** start of the description of what that command does. 3449 3450 */ 3450 3451 static const char *(azHelp[]) = { 3451 3452 #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) 3452 3453 ".archive ... Manage SQL archives", 3453 3454 " Each command must have exactly one of the following options:", 3454 3455 " -c, --create Create a new archive", 3455 - " -u, --update Update or add files to an existing archive", 3456 + " -u, --update Add files or update files with changed mtime", 3457 + " -i, --insert Like -u but always add even if mtime unchanged", 3456 3458 " -t, --list List contents of archive", 3457 3459 " -x, --extract Extract files from archive", 3458 3460 " Optional arguments:", 3459 3461 " -v, --verbose Print each filename as it is processed", 3460 3462 " -f FILE, --file FILE Operate on archive FILE (default is current db)", 3461 3463 " -a FILE, --append FILE Operate on FILE opened using the apndvfs VFS", 3462 3464 " -C DIR, --directory DIR Change to directory DIR to read/extract files", ................................................................................ 4769 4771 { "number of triggers:", 4770 4772 "SELECT count(*) FROM %s WHERE type='trigger'" }, 4771 4773 { "number of views:", 4772 4774 "SELECT count(*) FROM %s WHERE type='view'" }, 4773 4775 { "schema size:", 4774 4776 "SELECT total(length(sql)) FROM %s" }, 4775 4777 }; 4776 - int i; 4778 + int i, rc; 4777 4779 unsigned iDataVersion; 4778 4780 char *zSchemaTab; 4779 4781 char *zDb = nArg>=2 ? azArg[1] : "main"; 4780 4782 sqlite3_stmt *pStmt = 0; 4781 4783 unsigned char aHdr[100]; 4782 4784 open_db(p, 0); 4783 4785 if( p->db==0 ) return 1; 4784 - sqlite3_prepare_v2(p->db,"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1", 4785 - -1, &pStmt, 0); 4786 + rc = sqlite3_prepare_v2(p->db, 4787 + "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1", 4788 + -1, &pStmt, 0); 4789 + if( rc ){ 4790 + if( !sqlite3_compileoption_used("ENABLE_DBPAGE_VTAB") ){ 4791 + utf8_printf(stderr, "the \".dbinfo\" command requires the " 4792 + "-DSQLITE_ENABLE_DBPAGE_VTAB compile-time options\n"); 4793 + }else{ 4794 + utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db)); 4795 + } 4796 + sqlite3_finalize(pStmt); 4797 + return 1; 4798 + } 4786 4799 sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC); 4787 4800 if( sqlite3_step(pStmt)==SQLITE_ROW 4788 4801 && sqlite3_column_bytes(pStmt,0)>100 4789 4802 ){ 4790 4803 memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100); 4791 4804 sqlite3_finalize(pStmt); 4792 4805 }else{ ................................................................................ 5372 5385 return SQLITE_ERROR; 5373 5386 } 5374 5387 5375 5388 /* 5376 5389 ** Values for ArCommand.eCmd. 5377 5390 */ 5378 5391 #define AR_CMD_CREATE 1 5379 -#define AR_CMD_EXTRACT 2 5380 -#define AR_CMD_LIST 3 5381 -#define AR_CMD_UPDATE 4 5382 -#define AR_CMD_HELP 5 5392 +#define AR_CMD_UPDATE 2 5393 +#define AR_CMD_INSERT 3 5394 +#define AR_CMD_EXTRACT 4 5395 +#define AR_CMD_LIST 5 5396 +#define AR_CMD_HELP 6 5383 5397 5384 5398 /* 5385 5399 ** Other (non-command) switches. 5386 5400 */ 5387 -#define AR_SWITCH_VERBOSE 6 5388 -#define AR_SWITCH_FILE 7 5389 -#define AR_SWITCH_DIRECTORY 8 5390 -#define AR_SWITCH_APPEND 9 5391 -#define AR_SWITCH_DRYRUN 10 5401 +#define AR_SWITCH_VERBOSE 7 5402 +#define AR_SWITCH_FILE 8 5403 +#define AR_SWITCH_DIRECTORY 9 5404 +#define AR_SWITCH_APPEND 10 5405 +#define AR_SWITCH_DRYRUN 11 5392 5406 5393 5407 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){ 5394 5408 switch( eSwitch ){ 5395 5409 case AR_CMD_CREATE: 5396 5410 case AR_CMD_EXTRACT: 5397 5411 case AR_CMD_LIST: 5398 5412 case AR_CMD_UPDATE: 5413 + case AR_CMD_INSERT: 5399 5414 case AR_CMD_HELP: 5400 5415 if( pAr->eCmd ){ 5401 5416 return arErrorMsg(pAr, "multiple command options"); 5402 5417 } 5403 5418 pAr->eCmd = eSwitch; 5404 5419 break; 5405 5420 ................................................................................ 5438 5453 const char *zLong; 5439 5454 char cShort; 5440 5455 u8 eSwitch; 5441 5456 u8 bArg; 5442 5457 } aSwitch[] = { 5443 5458 { "create", 'c', AR_CMD_CREATE, 0 }, 5444 5459 { "extract", 'x', AR_CMD_EXTRACT, 0 }, 5460 + { "insert", 'i', AR_CMD_INSERT, 0 }, 5445 5461 { "list", 't', AR_CMD_LIST, 0 }, 5446 5462 { "update", 'u', AR_CMD_UPDATE, 0 }, 5447 5463 { "help", 'h', AR_CMD_HELP, 0 }, 5448 5464 { "verbose", 'v', AR_SWITCH_VERBOSE, 0 }, 5449 5465 { "file", 'f', AR_SWITCH_FILE, 1 }, 5450 5466 { "append", 'a', AR_SWITCH_APPEND, 1 }, 5451 5467 { "directory", 'C', AR_SWITCH_DIRECTORY, 1 }, ................................................................................ 5773 5789 } 5774 5790 } 5775 5791 return rc; 5776 5792 } 5777 5793 5778 5794 5779 5795 /* 5780 -** Implementation of .ar "create" and "update" commands. 5796 +** Implementation of .ar "create", "insert", and "update" commands. 5797 +** 5798 +** create -> Create a new SQL archive 5799 +** insert -> Insert or reinsert all files listed 5800 +** update -> Insert files that have changed or that were not 5801 +** previously in the archive 5781 5802 ** 5782 5803 ** Create the "sqlar" table in the database if it does not already exist. 5783 5804 ** Then add each file in the azFile[] array to the archive. Directories 5784 5805 ** are added recursively. If argument bVerbose is non-zero, a message is 5785 5806 ** printed on stdout for each file archived. 5786 5807 ** 5787 5808 ** The create command is the same as update, except that it drops 5788 -** any existing "sqlar" table before beginning. 5809 +** any existing "sqlar" table before beginning. The "insert" command 5810 +** always overwrites every file named on the command-line, where as 5811 +** "update" only overwrites if the size or mtime or mode has changed. 5789 5812 */ 5790 5813 static int arCreateOrUpdateCommand( 5791 5814 ArCommand *pAr, /* Command arguments and options */ 5792 - int bUpdate /* true for a --create. false for --update */ 5815 + int bUpdate, /* true for a --create. */ 5816 + int bOnlyIfChanged /* Only update if file has changed */ 5793 5817 ){ 5794 5818 const char *zCreate = 5795 5819 "CREATE TABLE IF NOT EXISTS sqlar(\n" 5796 5820 " name TEXT PRIMARY KEY, -- name of the file\n" 5797 5821 " mode INT, -- access permissions\n" 5798 5822 " mtime INT, -- last modification time\n" 5799 5823 " sz INT, -- original file size\n" ................................................................................ 5807 5831 " mode,\n" 5808 5832 " mtime,\n" 5809 5833 " CASE substr(lsmode(mode),1,1)\n" 5810 5834 " WHEN '-' THEN length(data)\n" 5811 5835 " WHEN 'd' THEN 0\n" 5812 5836 " ELSE -1 END,\n" 5813 5837 " sqlar_compress(data)\n" 5814 - " FROM fsdir(%Q,%Q)\n" 5815 - " WHERE lsmode(mode) NOT LIKE '?%%';", 5838 + " FROM fsdir(%Q,%Q) AS disk\n" 5839 + " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 5840 + , 5816 5841 "REPLACE INTO %s(name,mode,mtime,data)\n" 5817 5842 " SELECT\n" 5818 5843 " %s,\n" 5819 5844 " mode,\n" 5820 5845 " mtime,\n" 5821 5846 " data\n" 5822 - " FROM fsdir(%Q,%Q)\n" 5823 - " WHERE lsmode(mode) NOT LIKE '?%%';" 5847 + " FROM fsdir(%Q,%Q) AS disk\n" 5848 + " WHERE lsmode(mode) NOT LIKE '?%%'%s;" 5824 5849 }; 5825 5850 int i; /* For iterating through azFile[] */ 5826 5851 int rc; /* Return code */ 5827 5852 const char *zTab = 0; /* SQL table into which to insert */ 5828 5853 char *zSql; 5829 5854 char zTemp[50]; 5855 + char *zExists = 0; 5830 5856 5831 5857 arExecSql(pAr, "PRAGMA page_size=512"); 5832 5858 rc = arExecSql(pAr, "SAVEPOINT ar;"); 5833 5859 if( rc!=SQLITE_OK ) return rc; 5834 5860 zTemp[0] = 0; 5835 5861 if( pAr->bZip ){ 5836 5862 /* Initialize the zipfile virtual table, if necessary */ ................................................................................ 5853 5879 zTab = "sqlar"; 5854 5880 if( bUpdate==0 ){ 5855 5881 rc = arExecSql(pAr, zDrop); 5856 5882 if( rc!=SQLITE_OK ) goto end_ar_transaction; 5857 5883 } 5858 5884 rc = arExecSql(pAr, zCreate); 5859 5885 } 5886 + if( bOnlyIfChanged ){ 5887 + zExists = sqlite3_mprintf( 5888 + " AND NOT EXISTS(" 5889 + "SELECT 1 FROM %s AS mem" 5890 + " WHERE mem.name=disk.name" 5891 + " AND mem.mtime=disk.mtime" 5892 + " AND mem.mode=disk.mode)", zTab); 5893 + }else{ 5894 + zExists = sqlite3_mprintf(""); 5895 + } 5896 + if( zExists==0 ) rc = SQLITE_NOMEM; 5860 5897 for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){ 5861 5898 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab, 5862 5899 pAr->bVerbose ? "shell_putsnl(name)" : "name", 5863 - pAr->azArg[i], pAr->zDir); 5900 + pAr->azArg[i], pAr->zDir, zExists); 5864 5901 rc = arExecSql(pAr, zSql2); 5865 5902 sqlite3_free(zSql2); 5866 5903 } 5867 5904 end_ar_transaction: 5868 5905 if( rc!=SQLITE_OK ){ 5869 5906 sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0); 5870 5907 }else{ ................................................................................ 5871 5908 rc = arExecSql(pAr, "RELEASE ar;"); 5872 5909 if( pAr->bZip && pAr->zFile ){ 5873 5910 zSql = sqlite3_mprintf("DROP TABLE %s", zTemp); 5874 5911 arExecSql(pAr, zSql); 5875 5912 sqlite3_free(zSql); 5876 5913 } 5877 5914 } 5915 + sqlite3_free(zExists); 5878 5916 return rc; 5879 5917 } 5880 5918 5881 5919 /* 5882 5920 ** Implementation of ".ar" dot command. 5883 5921 */ 5884 5922 static int arDotCommand( ................................................................................ 5909 5947 cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile); 5910 5948 } 5911 5949 } 5912 5950 cmd.bZip = 1; 5913 5951 }else if( cmd.zFile ){ 5914 5952 int flags; 5915 5953 if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS; 5916 - if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_UPDATE ){ 5954 + if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT 5955 + || cmd.eCmd==AR_CMD_UPDATE ){ 5917 5956 flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; 5918 5957 }else{ 5919 5958 flags = SQLITE_OPEN_READONLY; 5920 5959 } 5921 5960 cmd.db = 0; 5922 5961 if( cmd.bDryRun ){ 5923 5962 utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile, ................................................................................ 5946 5985 goto end_ar_command; 5947 5986 } 5948 5987 cmd.zSrcTable = sqlite3_mprintf("sqlar"); 5949 5988 } 5950 5989 5951 5990 switch( cmd.eCmd ){ 5952 5991 case AR_CMD_CREATE: 5953 - rc = arCreateOrUpdateCommand(&cmd, 0); 5992 + rc = arCreateOrUpdateCommand(&cmd, 0, 0); 5954 5993 break; 5955 5994 5956 5995 case AR_CMD_EXTRACT: 5957 5996 rc = arExtractCommand(&cmd); 5958 5997 break; 5959 5998 5960 5999 case AR_CMD_LIST: ................................................................................ 5961 6000 rc = arListCommand(&cmd); 5962 6001 break; 5963 6002 5964 6003 case AR_CMD_HELP: 5965 6004 arUsage(pState->out); 5966 6005 break; 5967 6006 6007 + case AR_CMD_INSERT: 6008 + rc = arCreateOrUpdateCommand(&cmd, 1, 0); 6009 + break; 6010 + 5968 6011 default: 5969 6012 assert( cmd.eCmd==AR_CMD_UPDATE ); 5970 - rc = arCreateOrUpdateCommand(&cmd, 1); 6013 + rc = arCreateOrUpdateCommand(&cmd, 1, 1); 5971 6014 break; 5972 6015 } 5973 6016 } 5974 6017 end_ar_command: 5975 6018 if( cmd.db!=pState->db ){ 5976 6019 close_db(cmd.db); 5977 6020 } ................................................................................ 7096 7139 open_db(p,0); 7097 7140 if( nArg<=1 ) goto parameter_syntax_error; 7098 7141 7099 7142 /* .parameter clear 7100 7143 ** Clear all bind parameters by dropping the TEMP table that holds them. 7101 7144 */ 7102 7145 if( nArg==2 && strcmp(azArg[1],"clear")==0 ){ 7103 - sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.[" BIND_PARAM_TABLE "];", 7146 + int wrSchema = 0; 7147 + sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema); 7148 + sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0); 7149 + sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;", 7104 7150 0, 0, 0); 7151 + sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0); 7105 7152 }else 7106 7153 7107 7154 /* .parameter list 7108 7155 ** List all bind parameters. 7109 7156 */ 7110 7157 if( nArg==2 && strcmp(azArg[1],"list")==0 ){ 7111 7158 sqlite3_stmt *pStmt = 0; 7112 7159 int rx; 7113 7160 int len = 0; 7114 7161 rx = sqlite3_prepare_v2(p->db, 7115 7162 "SELECT max(length(key)) " 7116 - "FROM temp.[" BIND_PARAM_TABLE "];", -1, &pStmt, 0); 7163 + "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 7117 7164 if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ 7118 7165 len = sqlite3_column_int(pStmt, 0); 7119 7166 if( len>40 ) len = 40; 7120 7167 } 7121 7168 sqlite3_finalize(pStmt); 7122 7169 pStmt = 0; 7123 7170 if( len ){ 7124 7171 rx = sqlite3_prepare_v2(p->db, 7125 7172 "SELECT key, quote(value) " 7126 - "FROM temp.[" BIND_PARAM_TABLE "];", -1, &pStmt, 0); 7173 + "FROM temp.sqlite_parameters;", -1, &pStmt, 0); 7127 7174 while( sqlite3_step(pStmt)==SQLITE_ROW ){ 7128 7175 utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0), 7129 7176 sqlite3_column_text(pStmt,1)); 7130 7177 } 7131 7178 sqlite3_finalize(pStmt); 7132 7179 } 7133 7180 }else ................................................................................ 7150 7197 int rx; 7151 7198 char *zSql; 7152 7199 sqlite3_stmt *pStmt; 7153 7200 const char *zKey = azArg[2]; 7154 7201 const char *zValue = azArg[3]; 7155 7202 bind_table_init(p); 7156 7203 zSql = sqlite3_mprintf( 7157 - "REPLACE INTO temp.[" BIND_PARAM_TABLE "](key,value)" 7204 + "REPLACE INTO temp.sqlite_parameters(key,value)" 7158 7205 "VALUES(%Q,%s);", zKey, zValue); 7159 7206 if( zSql==0 ) shell_out_of_memory(); 7160 7207 pStmt = 0; 7161 7208 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 7162 7209 sqlite3_free(zSql); 7163 7210 if( rx!=SQLITE_OK ){ 7164 7211 sqlite3_finalize(pStmt); 7165 7212 pStmt = 0; 7166 7213 zSql = sqlite3_mprintf( 7167 - "REPLACE INTO temp.[" BIND_PARAM_TABLE "](key,value)" 7214 + "REPLACE INTO temp.sqlite_parameters(key,value)" 7168 7215 "VALUES(%Q,%Q);", zKey, zValue); 7169 7216 if( zSql==0 ) shell_out_of_memory(); 7170 7217 rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); 7171 7218 sqlite3_free(zSql); 7172 7219 if( rx!=SQLITE_OK ){ 7173 7220 utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db)); 7174 7221 sqlite3_finalize(pStmt); ................................................................................ 7182 7229 7183 7230 /* .parameter unset NAME 7184 7231 ** Remove the NAME binding from the parameter binding table, if it 7185 7232 ** exists. 7186 7233 */ 7187 7234 if( nArg==3 && strcmp(azArg[1],"unset")==0 ){ 7188 7235 char *zSql = sqlite3_mprintf( 7189 - "DELETE FROM temp.[" BIND_PARAM_TABLE "] WHERE key=%Q", azArg[2]); 7236 + "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]); 7190 7237 if( zSql==0 ) shell_out_of_memory(); 7191 7238 sqlite3_exec(p->db, zSql, 0, 0, 0); 7192 7239 sqlite3_free(zSql); 7193 7240 }else 7194 7241 /* If no command name matches, show a syntax error */ 7195 7242 parameter_syntax_error: 7196 7243 showHelp(p->out, "parameter");
Changes to src/sqlite.h.in.
2196 2196 ** features include but are not limited to the following: 2197 2197 ** <ul> 2198 2198 ** <li> The [PRAGMA writable_schema=ON] statement. 2199 2199 ** <li> Writes to the [sqlite_dbpage] virtual table. 2200 2200 ** <li> Direct writes to [shadow tables]. 2201 2201 ** </ul> 2202 2202 ** </dd> 2203 +** 2204 +** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt> 2205 +** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the 2206 +** "writable_schema" flag. This has the same effect and is logically equivalent 2207 +** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF]. 2208 +** The first argument to this setting is an integer which is 0 to disable 2209 +** the writable_schema, positive to enable writable_schema, or negative to 2210 +** leave the setting unchanged. The second parameter is a pointer to an 2211 +** integer into which is written 0 or 1 to indicate whether the writable_schema 2212 +** is enabled or disabled following this call. 2213 +** </dd> 2203 2214 ** </dl> 2204 2215 */ 2205 2216 #define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */ 2206 2217 #define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ 2207 2218 #define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ 2208 2219 #define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ 2209 2220 #define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */ 2210 2221 #define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */ 2211 2222 #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */ 2212 2223 #define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */ 2213 2224 #define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */ 2214 2225 #define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */ 2215 2226 #define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */ 2216 -#define SQLITE_DBCONFIG_MAX 1010 /* Largest DBCONFIG */ 2227 +#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */ 2228 +#define SQLITE_DBCONFIG_MAX 1011 /* Largest DBCONFIG */ 2217 2229 2218 2230 /* 2219 2231 ** CAPI3REF: Enable Or Disable Extended Result Codes 2220 2232 ** METHOD: sqlite3 2221 2233 ** 2222 2234 ** ^The sqlite3_extended_result_codes() routine enables or disables the 2223 2235 ** [extended result codes] feature of SQLite. ^The extended result
Changes to src/test_fs.c.
233 233 ** Skip the cursor to the next entry. 234 234 */ 235 235 static int fsdirNext(sqlite3_vtab_cursor *cur){ 236 236 FsdirCsr *pCsr = (FsdirCsr*)cur; 237 237 238 238 if( pCsr->pDir ){ 239 239 struct DIRENT *pRes = 0; 240 -#if defined(__MINGW_H) 241 240 pRes = readdir(pCsr->pDir); 242 241 if( pRes!=0 ){ 243 242 memcpy(&pCsr->entry, pRes, sizeof(struct DIRENT)); 244 243 } 245 -#else 246 - readdir_r(pCsr->pDir, &pCsr->entry, &pRes); 247 -#endif 248 244 if( pRes==0 ){ 249 245 closedir(pCsr->pDir); 250 246 pCsr->pDir = 0; 251 247 } 252 248 pCsr->iRowid++; 253 249 } 254 250
Changes to test/altertab3.test.
109 109 } {1 {error in trigger tr1: no such table: main.t2}} 110 110 do_execsql_test 4.2.2 { 111 111 COMMIT; 112 112 } 113 113 do_execsql_test 4.2.3 { 114 114 SELECT * FROM sqlite_master WHERE type='table' AND name!='t1'; 115 115 } {table t3 t3 3 {CREATE TABLE t3(e, f)}} 116 + 117 +#------------------------------------------------------------------------- 118 +reset_db 119 +do_execsql_test 5.0 { 120 + CREATE TABLE t1 ( 121 + c1 integer, c2, PRIMARY KEY(c1 collate rtrim), 122 + UNIQUE(c2) 123 + ) 124 +} 125 +do_execsql_test 5.1 { 126 + ALTER TABLE t1 RENAME c1 TO c3; 127 +} 128 + 129 +#------------------------------------------------------------------------- 130 +reset_db 131 +do_execsql_test 6.0 { 132 + CREATE TEMPORARY TABLE Table0 ( 133 + Col0 INTEGER, 134 + PRIMARY KEY(Col0 COLLATE RTRIM), 135 + FOREIGN KEY (Col0) REFERENCES Table0 136 + ); 137 +} 138 + 139 +do_execsql_test 6.1 { 140 + ALTER TABLE Table0 RENAME Col0 TO Col0; 141 +} 116 142 117 143 finish_test 118 144 119 145
Changes to test/corruptL.test.
722 722 | 0: 0d 00 00 00 00 10 00 00 00 00 00 00 00 00 00 00 ................ 723 723 | end crash-8391315d75edff.db 724 724 }]} {} 725 725 726 726 do_catchsql_test 7.1 { 727 727 SELECT * FROM sqlite_master; 728 728 } {1 {malformed database schema (t1x1) - invalid rootpage}} 729 + 730 +#------------------------------------------------------------------------- 731 +reset_db 732 +do_test 8.0 { 733 + sqlite3 db {} 734 + db deserialize [decode_hexdb { 735 +| size 2048 pagesize 512 filename a.db 736 +| page 1 offset 0 737 +| 0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00 SQLite format 3. 738 +| 16: 02 00 01 01 00 40 20 20 ff ff 00 0c 00 00 00 07 .....@ ........ 739 +| 32: 0b 00 00 00 00 00 00 00 00 00 00 08 9c 00 00 04 ................ 740 +| 48: 00 00 00 e0 09 00 00 01 00 00 00 01 00 00 00 00 ................ 741 +| 64: 00 00 00 00 f2 ff 00 00 00 00 00 00 00 00 00 00 ................ 742 +| 80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0c ................ 743 +| 96: 00 2e 2c 50 0d 00 00 00 06 01 06 00 01 da 01 b0 ..,P............ 744 +| 112: 05 56 01 86 01 2a 01 06 00 00 00 00 00 06 00 00 .V...*.......... 745 +| 128: 00 ff 00 00 ff ff ff e1 00 00 00 00 00 00 00 00 ................ 746 +| 144: 00 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 ................ 747 +| 160: 00 00 00 00 00 00 00 00 f2 00 00 00 00 00 00 00 ................ 748 +| 176: 00 00 f9 ff ff ff ff ff ff ff 00 00 00 5f 00 fb ............._.. 749 +| 192: 00 00 00 00 00 00 00 00 00 e1 ff 00 00 00 00 00 ................ 750 +| 208: 00 00 10 00 00 00 00 00 1e 00 00 00 fe 00 00 00 ................ 751 +| 224: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ca 00 ................ 752 +| 240: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 35 ...............5 753 +| 256: 00 00 00 00 ef ff 22 07 06 17 11 11 01 30 39 38 .............098 754 +| 272: 62 6c 65 74 38 38 74 04 43 52 45 41 54 45 20 54 blet88t.CREATE T 755 +| 288: 41 42 4c 45 20 74 34 28 87 29 2a 06 06 17 13 11 ABLE t4(.)*..... 756 +| 304: 01 3f 69 4f 64 65 78 74 33 78 74 40 05 43 52 45 .?iOdext3xt@.CRE 757 +| 320: 41 54 45 20 49 6e 44 45 58 20 74 33 78 20 4f 4e ATE InDEX t3x ON 758 +| 336: 20 74 33 28 78 29 2e 04 06 17 15 11 01 45 69 6e t3(x).......Ein 759 +| 352: 00 04 00 00 34 63 64 74 3d 05 43 52 45 41 54 45 ....4cdt=.CREATE 760 +| 368: 20 49 4e 44 45 58 20 63 74 64 32 20 4f 4e 20 74 INDEX ctd2 ON t 761 +| 384: 32 28 0a 0c 44 29 28 05 06 17 11 11 01 3d 74 6c 2(..D)(......=tl 762 +| 400: 62 61 d4 65 33 74 33 04 43 52 45 41 54 45 20 54 ba.e3t3.CREATE T 763 +| 416: 41 42 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29 ABLE t3(c,x,e,f) 764 +| 432: 28 02 06 17 11 11 01 3d 74 61 62 6c 65 74 32 74 (......=tablet2t 765 +| 448: 32 03 43 52 45 41 54 45 20 54 41 42 4c 45 20 74 2.CREATE TABLE t 766 +| 464: 32 28 63 2c 64 2c 65 2c 66 29 24 01 06 17 11 11 2(c,d,e,f)$..... 767 +| 480: 01 35 74 60 62 6c 65 74 31 74 31 02 43 52 45 41 .5t`blet1t1.CREA 768 +| 496: 54 45 20 54 41 42 4c 45 20 74 30 28 61 2c 62 29 TE TABLE t0(a,b) 769 +| page 2 offset 512 770 +| 0: 0d 00 ff 11 04 01 cf 80 01 fa 01 09 00 de 01 cf ................ 771 +| 16: 00 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 ................ 772 +| 32: 00 00 08 00 00 00 00 00 00 11 00 00 00 00 00 13 ................ 773 +| 48: 00 00 00 00 00 00 00 00 00 00 00 01 00 e0 ff ff ................ 774 +| 64: ff d2 ff ff ff 00 f8 ff ff ff 00 00 00 00 00 00 ................ 775 +| 80: 00 ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ 776 +| 96: 00 00 00 00 ff de 00 00 00 00 00 00 00 00 00 00 ................ 777 +| 112: 00 00 00 00 00 00 00 00 00 00 00 00 00 40 00 00 .............@.. 778 +| 128: 2a 00 00 00 00 00 00 00 00 f7 00 00 00 00 00 00 *............... 779 +| 144: 00 00 00 00 00 21 00 00 00 00 00 00 00 00 00 00 .....!.......... 780 +| 160: 01 64 00 00 00 00 04 80 ff ff ff 00 00 00 00 00 .d.............. 781 +| 176: 00 00 00 00 00 00 00 00 1f 00 00 00 00 00 00 00 ................ 782 +| 192: 00 00 40 00 00 00 00 00 00 00 00 00 00 00 00 00 ..@............. 783 +| 208: b5 00 00 00 00 00 00 40 00 00 00 00 00 00 00 00 .......@........ 784 +| 224: 00 00 00 f6 00 ee ff ff ff 00 00 00 00 00 00 00 ................ 785 +| 272: f2 00 00 00 00 00 00 00 00 00 f9 ff ff ff ff ff ................ 786 +| 288: ff ff 00 00 00 5f 00 fb 00 00 00 00 00 00 00 00 ....._.......... 787 +| 320: 1e 00 00 00 fe 00 00 00 00 00 00 00 00 00 00 00 ................ 788 +| 336: 00 00 00 00 00 00 ca 00 00 00 00 00 00 00 ff ec ................ 789 +| 352: 00 00 00 00 00 00 00 32 00 00 00 00 ef ff 22 07 .......2........ 790 +| 368: 06 17 11 11 01 30 74 61 62 6c 65 74 38 38 74 04 .....0tablet88t. 791 +| 384: 43 52 45 41 54 45 20 54 41 42 4c 45 20 8c cb d7 CREATE TABLE ... 792 +| 400: 78 d6 d5 f9 f9 17 13 11 01 3f 69 4f 64 65 78 74 x........?iOdext 793 +| 416: 33 78 74 33 05 43 52 45 41 54 45 26 49 6e 44 45 3xt3.CREATE&InDE 794 +| 432: 58 20 74 33 78 00 00 00 00 00 00 00 00 00 00 00 X t3x........... 795 +| 464: 00 00 00 00 00 13 76 65 6e 65 69 67 68 74 13 03 ......veneight.. 796 +| 480: 03 40 07 07 15 00 54 45 20 49 4e 44 45 58 20 74 .@....TE INDEX t 797 +| 496: 31 63 64 20 4f 4e 20 74 ce d7 f5 f0 44 09 01 02 1cd ON t....D... 798 +| page 3 offset 1024 799 +| 0: 0d 00 00 00 48 01 54 00 01 f6 e2 ec 01 c5 01 aa ....H.T......... 800 +| 16: 30 34 28 87 29 32 06 f5 16 13 11 01 8e 61 24 64 04(.)2.......a$d 801 +| 32: 65 78 74 37 78 1f 33 6d 6d 6d 6d 6d 00 00 04 06 ext7x.3mmmmm.... 802 +| 48: 6d 41 6d 6d 6e 6d 6d 00 00 02 00 6d 6d 6d 6d 6d mAmmnmm....mmmmm 803 +| 64: 15 11 01 45 45 45 45 45 45 45 45 45 45 45 45 45 ...EEEEEEEEEEEEE 804 +| 80: 45 45 45 45 45 45 45 45 45 45 45 00 45 63 74 64 EEEEEEEEEEE.Ectd 805 +| 96: 34 20 4f 4e 20 61 62 6c 5d 74 38 38 74 04 43 52 4 ON abl]t88t.CR 806 +| 112: 45 41 54 45 20 54 41 42 4c 45 20 74 34 28 87 29 EATE TABLE t4(.) 807 +| 128: 2a 06 06 13 13 01 00 00 00 4f 64 6e 78 74 33 44 *........Odnxt3D 808 +| 144: 74 13 05 43 52 45 41 54 45 20 49 6e 44 45 00 00 t..CREATE InDE.. 809 +| 160: 00 00 00 00 00 00 00 f9 ff ff ff ff ff ff ff 00 ................ 810 +| 176: 00 00 5f 00 fb 00 00 2d 00 00 00 00 00 00 00 00 .._....-........ 811 +| 192: 00 00 00 00 00 00 00 00 00 00 00 00 00 1e 00 00 ................ 812 +| 208: 00 fe 00 00 00 00 17 15 11 01 45 69 6e 64 65 2e ..........Einde. 813 +| 224: 5b 38 63 64 74 3d 05 43 52 45 41 54 45 20 49 4e [8cdt=.CREATE IN 814 +| 240: 44 45 58 20 63 20 64 32 20 4f 4e 20 74 32 28 0a DEX c d2 ON t2(. 815 +| 256: 0c 44 32 05 00 10 00 00 11 11 3d 74 6c 62 61 d4 .D2.......=tlba. 816 +| 272: 65 33 74 33 04 43 52 45 41 54 45 20 54 41 42 4c e3t3.CREATE TABL 817 +| 288: 45 20 74 36 ff ff 7f ff 43 52 45 41 54 45 20 49 E t6....CREATE I 818 +| 304: 73 71 6c 69 74 65 5f 73 65 71 75 65 6e 63 65 28 sqlite_sequence( 819 +| 320: 0a 0c 44 29 28 05 06 17 11 11 01 3d 74 6c 62 61 ..D)(......=tlba 820 +| 336: 20 00 00 00 33 04 43 52 45 41 54 45 20 54 41 42 ...3.CREATE TAB 821 +| 352: 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29 28 02 LE t3(c,x,e,f)(. 822 +| 368: 06 00 00 7f ff 40 41 54 45 20 49 6e 44 45 58 20 .....@ATE InDEX 823 +| 384: 74 33 78 20 4f 4e 20 74 31 28 78 29 2e 04 06 17 t3x ON t1(x).... 824 +| 400: 15 11 01 45 69 6e 64 65 2e 74 34 63 64 74 3d 05 ...Einde.t4cdt=. 825 +| 416: 00 00 00 00 00 00 00 00 00 00 00 4d 00 00 00 00 ...........M.... 826 +| 432: 01 00 00 00 00 00 00 05 00 00 10 00 00 00 00 00 ................ 827 +| 448: 00 01 00 00 00 00 01 00 00 00 00 07 40 14 00 00 ............@... 828 +| 464: 00 00 21 00 40 18 00 00 00 00 00 00 40 1c 00 00 ..!.@.......@... 829 +| 480: 00 00 ff ff ff 00 00 00 5f 00 fb 00 00 2d 00 00 ........_....-.. 830 +| 496: 00 00 00 1e 00 00 00 fe 00 00 64 00 00 ff fb 02 ..........d..... 831 +| page 4 offset 1536 832 +| 0: 0d 00 39 00 00 02 00 00 00 00 00 00 00 00 00 00 ..9............. 833 +| end a.db 834 +}]} {} 835 + 836 + 837 +do_catchsql_test 8.1 { 838 + INSERT INTO t3 SELECT * FROM t2; 839 +} {1 {database disk image is malformed}} 729 840 730 841 finish_test
Changes to test/dbfuzz2.c.
70 70 71 71 /* True to activate PRAGMA vdbe_debug=on */ 72 72 static int bVdbeDebug = 0; 73 73 74 74 /* Maximum size of the in-memory database file */ 75 75 static sqlite3_int64 szMax = 104857600; 76 76 77 +/* Progress handler callback data */ 78 +static int nCb = 0; /* Number of callbacks seen so far */ 79 +static int mxCb = 250000; /* Maximum allowed callbacks */ 80 + 77 81 /***** Copy/paste from ext/misc/memtrace.c ***************************/ 78 82 /* The original memory allocation routines */ 79 83 static sqlite3_mem_methods memtraceBase; 80 84 static FILE *memtraceOut; 81 85 82 86 /* Methods that trace memory allocations */ 83 87 static void *memtraceMalloc(int n){ ................................................................................ 152 156 memset(&memtraceBase, 0, sizeof(memtraceBase)); 153 157 } 154 158 } 155 159 memtraceOut = 0; 156 160 return rc; 157 161 } 158 162 /***** End copy/paste from ext/misc/memtrace.c ***************************/ 163 + 164 +/* 165 +** Progress handler callback 166 +** 167 +** Count the number of callbacks and cause an abort once the limit is 168 +** reached. 169 +*/ 170 +static int progress_handler(void *pNotUsed){ 171 + nCb++; 172 + if( nCb<mxCb ) return 0; 173 + if( eVerbosity>=1 ){ 174 + printf("-- Progress limit of %d reached\n", mxCb); 175 + } 176 + return 1; 177 +} 159 178 160 179 /* libFuzzer invokes this routine with fuzzed database files (in aData). 161 180 ** This routine run SQLite against the malformed database to see if it 162 181 ** can provoke a failure or malfunction. 163 182 */ 164 183 int LLVMFuzzerTestOneInput(const uint8_t *aData, size_t nByte){ 165 184 unsigned char *a; ................................................................................ 185 204 x = szMax; 186 205 #ifdef SQLITE_FCNTL_SIZE_LIMIT 187 206 sqlite3_file_control(db, "main", SQLITE_FCNTL_SIZE_LIMIT, &x); 188 207 #endif 189 208 if( bVdbeDebug ){ 190 209 sqlite3_exec(db, "PRAGMA vdbe_debug=ON", 0, 0, 0); 191 210 } 211 + if( mxCb>0 ){ 212 + sqlite3_progress_handler(db, 10, progress_handler, 0); 213 + } 192 214 for(i=0; i<sizeof(azSql)/sizeof(azSql[0]); i++){ 193 215 if( eVerbosity>=1 ){ 194 216 printf("%s\n", azSql[i]); 195 217 fflush(stdout); 196 218 } 197 219 zErr = 0; 220 + nCb = 0; 198 221 rc = sqlite3_exec(db, azSql[i], 0, 0, &zErr); 199 222 if( rc && eVerbosity>=1 ){ 200 223 printf("-- rc=%d zErr=%s\n", rc, zErr); 201 224 } 202 225 sqlite3_free(zErr); 203 226 } 204 227 rc = sqlite3_close(db); ................................................................................ 244 267 if( z[0]=='v' && (n = numberOfVChar(z))>0 ){ 245 268 eVerbosity += n; 246 269 continue; 247 270 } 248 271 if( strcmp(z,"vdbe-debug")==0 ){ 249 272 bVdbeDebug = 1; 250 273 continue; 274 + } 275 + if( strcmp(z,"limit")==0 ){ 276 + if( i+1==argc ){ 277 + fprintf(stderr, "missing argument to %s\n", argv[i]); 278 + exit(1); 279 + } 280 + mxCb = strtol(argv[++i], 0, 0); 281 + continue; 251 282 } 252 283 if( strcmp(z,"memtrace")==0 ){ 253 284 sqlite3MemTraceActivate(stdout); 254 285 continue; 255 286 } 256 287 if( strcmp(z,"mem")==0 ){ 257 288 bVdbeDebug = 1;
Changes to test/fuzzcheck.c.
527 527 if( nIn<4 ) return -1; 528 528 n = (unsigned int)nIn; 529 529 a = sqlite3_malloc64( nAlloc ); 530 530 if( a==0 ){ 531 531 fprintf(stderr, "Out of memory!\n"); 532 532 exit(1); 533 533 } 534 - memset(a, 0, nAlloc); 534 + memset(a, 0, (size_t)nAlloc); 535 535 for(i=k=0; i<n; i++){ 536 536 unsigned char c = (unsigned char)zIn[i]; 537 537 if( isxdigit(c) ){ 538 538 k++; 539 539 if( k & 1 ){ 540 540 b = hexToInt(c)*16; 541 541 }else{ ................................................................................ 564 564 } 565 565 a = sqlite3_realloc64( a, newSize ); 566 566 if( a==0 ){ 567 567 fprintf(stderr, "Out of memory!\n"); 568 568 exit(1); 569 569 } 570 570 assert( newSize > nAlloc ); 571 - memset(a+nAlloc, 0, newSize - nAlloc); 571 + memset(a+nAlloc, 0, (size_t)(newSize - nAlloc)); 572 572 nAlloc = newSize; 573 573 } 574 574 if( j>=(unsigned)mx ){ 575 575 mx = (j + 4095)&~4095; 576 576 if( mx>MX_FILE_SZ ) mx = MX_FILE_SZ; 577 577 } 578 578 assert( j<nAlloc );
Changes to test/fuzzdata7.db.
cannot compute difference between binary files