| | @@ -1,8 +1,8 @@ |
| 1 | 1 | /****************************************************************************** |
| 2 | 2 | ** This file is an amalgamation of many separate C source files from SQLite |
| 3 | | -** version 3.6.23. By combining all the individual C code files into this |
| 3 | +** version 3.6.23.1. By combining all the individual C code files into this |
| 4 | 4 | ** single large file, the entire code can be compiled as a one translation |
| 5 | 5 | ** unit. This allows many compilers to do optimizations that would not be |
| 6 | 6 | ** possible if the files were compiled separately. Performance improvements |
| 7 | 7 | ** of 5% are more are commonly seen when SQLite is compiled as a single |
| 8 | 8 | ** translation unit. |
| | @@ -626,13 +626,13 @@ |
| 626 | 626 | ** |
| 627 | 627 | ** See also: [sqlite3_libversion()], |
| 628 | 628 | ** [sqlite3_libversion_number()], [sqlite3_sourceid()], |
| 629 | 629 | ** [sqlite_version()] and [sqlite_source_id()]. |
| 630 | 630 | */ |
| 631 | | -#define SQLITE_VERSION "3.6.23" |
| 631 | +#define SQLITE_VERSION "3.6.23.1" |
| 632 | 632 | #define SQLITE_VERSION_NUMBER 3006023 |
| 633 | | -#define SQLITE_SOURCE_ID "2010-03-05 13:53:23 27413fc8dd52b754b4be9344a66bb9e0d752d48e" |
| 633 | +#define SQLITE_SOURCE_ID "2010-03-26 22:28:06 ex-b078b588d617e07886ad156e9f54ade6d823568e" |
| 634 | 634 | |
| 635 | 635 | /* |
| 636 | 636 | ** CAPI3REF: Run-Time Library Version Numbers |
| 637 | 637 | ** KEYWORDS: sqlite3_version, sqlite3_sourceid |
| 638 | 638 | ** |
| | @@ -10425,11 +10425,11 @@ |
| 10425 | 10425 | SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8); |
| 10426 | 10426 | SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, |
| 10427 | 10427 | void(*)(void*)); |
| 10428 | 10428 | SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*); |
| 10429 | 10429 | SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *); |
| 10430 | | -SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int); |
| 10430 | +SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8); |
| 10431 | 10431 | #ifdef SQLITE_ENABLE_STAT2 |
| 10432 | 10432 | SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *, u8, char *, int, int *); |
| 10433 | 10433 | #endif |
| 10434 | 10434 | SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **); |
| 10435 | 10435 | SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8); |
| | @@ -10866,10 +10866,397 @@ |
| 10866 | 10866 | ** the vdbe.c file. |
| 10867 | 10867 | */ |
| 10868 | 10868 | SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER; |
| 10869 | 10869 | |
| 10870 | 10870 | /************** End of global.c **********************************************/ |
| 10871 | +/************** Begin file ctime.c *******************************************/ |
| 10872 | +/* |
| 10873 | +** 2010 February 23 |
| 10874 | +** |
| 10875 | +** The author disclaims copyright to this source code. In place of |
| 10876 | +** a legal notice, here is a blessing: |
| 10877 | +** |
| 10878 | +** May you do good and not evil. |
| 10879 | +** May you find forgiveness for yourself and forgive others. |
| 10880 | +** May you share freely, never taking more than you give. |
| 10881 | +** |
| 10882 | +************************************************************************* |
| 10883 | +** |
| 10884 | +** This file implements routines used to report what compile-time options |
| 10885 | +** SQLite was built with. |
| 10886 | +*/ |
| 10887 | + |
| 10888 | +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS |
| 10889 | + |
| 10890 | + |
| 10891 | +/* |
| 10892 | +** An array of names of all compile-time options. This array should |
| 10893 | +** be sorted A-Z. |
| 10894 | +** |
| 10895 | +** This array looks large, but in a typical installation actually uses |
| 10896 | +** only a handful of compile-time options, so most times this array is usually |
| 10897 | +** rather short and uses little memory space. |
| 10898 | +*/ |
| 10899 | +static const char * const azCompileOpt[] = { |
| 10900 | + |
| 10901 | +/* These macros are provided to "stringify" the value of the define |
| 10902 | +** for those options in which the value is meaningful. */ |
| 10903 | +#define CTIMEOPT_VAL_(opt) #opt |
| 10904 | +#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) |
| 10905 | + |
| 10906 | +#ifdef SQLITE_32BIT_ROWID |
| 10907 | + "32BIT_ROWID", |
| 10908 | +#endif |
| 10909 | +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC |
| 10910 | + "4_BYTE_ALIGNED_MALLOC", |
| 10911 | +#endif |
| 10912 | +#ifdef SQLITE_CASE_SENSITIVE_LIKE |
| 10913 | + "CASE_SENSITIVE_LIKE", |
| 10914 | +#endif |
| 10915 | +#ifdef SQLITE_CHECK_PAGES |
| 10916 | + "CHECK_PAGES", |
| 10917 | +#endif |
| 10918 | +#ifdef SQLITE_COVERAGE_TEST |
| 10919 | + "COVERAGE_TEST", |
| 10920 | +#endif |
| 10921 | +#ifdef SQLITE_DEBUG |
| 10922 | + "DEBUG", |
| 10923 | +#endif |
| 10924 | +#ifdef SQLITE_DEFAULT_LOCKING_MODE |
| 10925 | + "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE), |
| 10926 | +#endif |
| 10927 | +#ifdef SQLITE_DISABLE_DIRSYNC |
| 10928 | + "DISABLE_DIRSYNC", |
| 10929 | +#endif |
| 10930 | +#ifdef SQLITE_DISABLE_LFS |
| 10931 | + "DISABLE_LFS", |
| 10932 | +#endif |
| 10933 | +#ifdef SQLITE_ENABLE_ATOMIC_WRITE |
| 10934 | + "ENABLE_ATOMIC_WRITE", |
| 10935 | +#endif |
| 10936 | +#ifdef SQLITE_ENABLE_CEROD |
| 10937 | + "ENABLE_CEROD", |
| 10938 | +#endif |
| 10939 | +#ifdef SQLITE_ENABLE_COLUMN_METADATA |
| 10940 | + "ENABLE_COLUMN_METADATA", |
| 10941 | +#endif |
| 10942 | +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT |
| 10943 | + "ENABLE_EXPENSIVE_ASSERT", |
| 10944 | +#endif |
| 10945 | +#ifdef SQLITE_ENABLE_FTS1 |
| 10946 | + "ENABLE_FTS1", |
| 10947 | +#endif |
| 10948 | +#ifdef SQLITE_ENABLE_FTS2 |
| 10949 | + "ENABLE_FTS2", |
| 10950 | +#endif |
| 10951 | +#ifdef SQLITE_ENABLE_FTS3 |
| 10952 | + "ENABLE_FTS3", |
| 10953 | +#endif |
| 10954 | +#ifdef SQLITE_ENABLE_FTS3_PARENTHESIS |
| 10955 | + "ENABLE_FTS3_PARENTHESIS", |
| 10956 | +#endif |
| 10957 | +#ifdef SQLITE_ENABLE_FTS4 |
| 10958 | + "ENABLE_FTS4", |
| 10959 | +#endif |
| 10960 | +#ifdef SQLITE_ENABLE_ICU |
| 10961 | + "ENABLE_ICU", |
| 10962 | +#endif |
| 10963 | +#ifdef SQLITE_ENABLE_IOTRACE |
| 10964 | + "ENABLE_IOTRACE", |
| 10965 | +#endif |
| 10966 | +#ifdef SQLITE_ENABLE_LOAD_EXTENSION |
| 10967 | + "ENABLE_LOAD_EXTENSION", |
| 10968 | +#endif |
| 10969 | +#ifdef SQLITE_ENABLE_LOCKING_STYLE |
| 10970 | + "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), |
| 10971 | +#endif |
| 10972 | +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT |
| 10973 | + "ENABLE_MEMORY_MANAGEMENT", |
| 10974 | +#endif |
| 10975 | +#ifdef SQLITE_ENABLE_MEMSYS3 |
| 10976 | + "ENABLE_MEMSYS3", |
| 10977 | +#endif |
| 10978 | +#ifdef SQLITE_ENABLE_MEMSYS5 |
| 10979 | + "ENABLE_MEMSYS5", |
| 10980 | +#endif |
| 10981 | +#ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK |
| 10982 | + "ENABLE_OVERSIZE_CELL_CHECK", |
| 10983 | +#endif |
| 10984 | +#ifdef SQLITE_ENABLE_RTREE |
| 10985 | + "ENABLE_RTREE", |
| 10986 | +#endif |
| 10987 | +#ifdef SQLITE_ENABLE_STAT2 |
| 10988 | + "ENABLE_STAT2", |
| 10989 | +#endif |
| 10990 | +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY |
| 10991 | + "ENABLE_UNLOCK_NOTIFY", |
| 10992 | +#endif |
| 10993 | +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT |
| 10994 | + "ENABLE_UPDATE_DELETE_LIMIT", |
| 10995 | +#endif |
| 10996 | +#ifdef SQLITE_HAS_CODEC |
| 10997 | + "HAS_CODEC", |
| 10998 | +#endif |
| 10999 | +#ifdef SQLITE_HAVE_ISNAN |
| 11000 | + "HAVE_ISNAN", |
| 11001 | +#endif |
| 11002 | +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX |
| 11003 | + "HOMEGROWN_RECURSIVE_MUTEX", |
| 11004 | +#endif |
| 11005 | +#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS |
| 11006 | + "IGNORE_AFP_LOCK_ERRORS", |
| 11007 | +#endif |
| 11008 | +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS |
| 11009 | + "IGNORE_FLOCK_LOCK_ERRORS", |
| 11010 | +#endif |
| 11011 | +#ifdef SQLITE_INT64_TYPE |
| 11012 | + "INT64_TYPE", |
| 11013 | +#endif |
| 11014 | +#ifdef SQLITE_LOCK_TRACE |
| 11015 | + "LOCK_TRACE", |
| 11016 | +#endif |
| 11017 | +#ifdef SQLITE_MEMDEBUG |
| 11018 | + "MEMDEBUG", |
| 11019 | +#endif |
| 11020 | +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT |
| 11021 | + "MIXED_ENDIAN_64BIT_FLOAT", |
| 11022 | +#endif |
| 11023 | +#ifdef SQLITE_NO_SYNC |
| 11024 | + "NO_SYNC", |
| 11025 | +#endif |
| 11026 | +#ifdef SQLITE_OMIT_ALTERTABLE |
| 11027 | + "OMIT_ALTERTABLE", |
| 11028 | +#endif |
| 11029 | +#ifdef SQLITE_OMIT_ANALYZE |
| 11030 | + "OMIT_ANALYZE", |
| 11031 | +#endif |
| 11032 | +#ifdef SQLITE_OMIT_ATTACH |
| 11033 | + "OMIT_ATTACH", |
| 11034 | +#endif |
| 11035 | +#ifdef SQLITE_OMIT_AUTHORIZATION |
| 11036 | + "OMIT_AUTHORIZATION", |
| 11037 | +#endif |
| 11038 | +#ifdef SQLITE_OMIT_AUTOINCREMENT |
| 11039 | + "OMIT_AUTOINCREMENT", |
| 11040 | +#endif |
| 11041 | +#ifdef SQLITE_OMIT_AUTOINIT |
| 11042 | + "OMIT_AUTOINIT", |
| 11043 | +#endif |
| 11044 | +#ifdef SQLITE_OMIT_AUTOVACUUM |
| 11045 | + "OMIT_AUTOVACUUM", |
| 11046 | +#endif |
| 11047 | +#ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION |
| 11048 | + "OMIT_BETWEEN_OPTIMIZATION", |
| 11049 | +#endif |
| 11050 | +#ifdef SQLITE_OMIT_BLOB_LITERAL |
| 11051 | + "OMIT_BLOB_LITERAL", |
| 11052 | +#endif |
| 11053 | +#ifdef SQLITE_OMIT_BTREECOUNT |
| 11054 | + "OMIT_BTREECOUNT", |
| 11055 | +#endif |
| 11056 | +#ifdef SQLITE_OMIT_BUILTIN_TEST |
| 11057 | + "OMIT_BUILTIN_TEST", |
| 11058 | +#endif |
| 11059 | +#ifdef SQLITE_OMIT_CAST |
| 11060 | + "OMIT_CAST", |
| 11061 | +#endif |
| 11062 | +#ifdef SQLITE_OMIT_CHECK |
| 11063 | + "OMIT_CHECK", |
| 11064 | +#endif |
| 11065 | +#ifdef SQLITE_OMIT_COMPILEOPTION_DIAGS |
| 11066 | + "OMIT_COMPILEOPTION_DIAGS", |
| 11067 | +#endif |
| 11068 | +#ifdef SQLITE_OMIT_COMPLETE |
| 11069 | + "OMIT_COMPLETE", |
| 11070 | +#endif |
| 11071 | +#ifdef SQLITE_OMIT_COMPOUND_SELECT |
| 11072 | + "OMIT_COMPOUND_SELECT", |
| 11073 | +#endif |
| 11074 | +#ifdef SQLITE_OMIT_DATETIME_FUNCS |
| 11075 | + "OMIT_DATETIME_FUNCS", |
| 11076 | +#endif |
| 11077 | +#ifdef SQLITE_OMIT_DECLTYPE |
| 11078 | + "OMIT_DECLTYPE", |
| 11079 | +#endif |
| 11080 | +#ifdef SQLITE_OMIT_DEPRECATED |
| 11081 | + "OMIT_DEPRECATED", |
| 11082 | +#endif |
| 11083 | +#ifdef SQLITE_OMIT_DISKIO |
| 11084 | + "OMIT_DISKIO", |
| 11085 | +#endif |
| 11086 | +#ifdef SQLITE_OMIT_EXPLAIN |
| 11087 | + "OMIT_EXPLAIN", |
| 11088 | +#endif |
| 11089 | +#ifdef SQLITE_OMIT_FLAG_PRAGMAS |
| 11090 | + "OMIT_FLAG_PRAGMAS", |
| 11091 | +#endif |
| 11092 | +#ifdef SQLITE_OMIT_FLOATING_POINT |
| 11093 | + "OMIT_FLOATING_POINT", |
| 11094 | +#endif |
| 11095 | +#ifdef SQLITE_OMIT_FOREIGN_KEY |
| 11096 | + "OMIT_FOREIGN_KEY", |
| 11097 | +#endif |
| 11098 | +#ifdef SQLITE_OMIT_GET_TABLE |
| 11099 | + "OMIT_GET_TABLE", |
| 11100 | +#endif |
| 11101 | +#ifdef SQLITE_OMIT_GLOBALRECOVER |
| 11102 | + "OMIT_GLOBALRECOVER", |
| 11103 | +#endif |
| 11104 | +#ifdef SQLITE_OMIT_INCRBLOB |
| 11105 | + "OMIT_INCRBLOB", |
| 11106 | +#endif |
| 11107 | +#ifdef SQLITE_OMIT_INTEGRITY_CHECK |
| 11108 | + "OMIT_INTEGRITY_CHECK", |
| 11109 | +#endif |
| 11110 | +#ifdef SQLITE_OMIT_LIKE_OPTIMIZATION |
| 11111 | + "OMIT_LIKE_OPTIMIZATION", |
| 11112 | +#endif |
| 11113 | +#ifdef SQLITE_OMIT_LOAD_EXTENSION |
| 11114 | + "OMIT_LOAD_EXTENSION", |
| 11115 | +#endif |
| 11116 | +#ifdef SQLITE_OMIT_LOCALTIME |
| 11117 | + "OMIT_LOCALTIME", |
| 11118 | +#endif |
| 11119 | +#ifdef SQLITE_OMIT_LOOKASIDE |
| 11120 | + "OMIT_LOOKASIDE", |
| 11121 | +#endif |
| 11122 | +#ifdef SQLITE_OMIT_MEMORYDB |
| 11123 | + "OMIT_MEMORYDB", |
| 11124 | +#endif |
| 11125 | +#ifdef SQLITE_OMIT_OR_OPTIMIZATION |
| 11126 | + "OMIT_OR_OPTIMIZATION", |
| 11127 | +#endif |
| 11128 | +#ifdef SQLITE_OMIT_PAGER_PRAGMAS |
| 11129 | + "OMIT_PAGER_PRAGMAS", |
| 11130 | +#endif |
| 11131 | +#ifdef SQLITE_OMIT_PRAGMA |
| 11132 | + "OMIT_PRAGMA", |
| 11133 | +#endif |
| 11134 | +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK |
| 11135 | + "OMIT_PROGRESS_CALLBACK", |
| 11136 | +#endif |
| 11137 | +#ifdef SQLITE_OMIT_QUICKBALANCE |
| 11138 | + "OMIT_QUICKBALANCE", |
| 11139 | +#endif |
| 11140 | +#ifdef SQLITE_OMIT_REINDEX |
| 11141 | + "OMIT_REINDEX", |
| 11142 | +#endif |
| 11143 | +#ifdef SQLITE_OMIT_SCHEMA_PRAGMAS |
| 11144 | + "OMIT_SCHEMA_PRAGMAS", |
| 11145 | +#endif |
| 11146 | +#ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS |
| 11147 | + "OMIT_SCHEMA_VERSION_PRAGMAS", |
| 11148 | +#endif |
| 11149 | +#ifdef SQLITE_OMIT_SHARED_CACHE |
| 11150 | + "OMIT_SHARED_CACHE", |
| 11151 | +#endif |
| 11152 | +#ifdef SQLITE_OMIT_SUBQUERY |
| 11153 | + "OMIT_SUBQUERY", |
| 11154 | +#endif |
| 11155 | +#ifdef SQLITE_OMIT_TCL_VARIABLE |
| 11156 | + "OMIT_TCL_VARIABLE", |
| 11157 | +#endif |
| 11158 | +#ifdef SQLITE_OMIT_TEMPDB |
| 11159 | + "OMIT_TEMPDB", |
| 11160 | +#endif |
| 11161 | +#ifdef SQLITE_OMIT_TRACE |
| 11162 | + "OMIT_TRACE", |
| 11163 | +#endif |
| 11164 | +#ifdef SQLITE_OMIT_TRIGGER |
| 11165 | + "OMIT_TRIGGER", |
| 11166 | +#endif |
| 11167 | +#ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION |
| 11168 | + "OMIT_TRUNCATE_OPTIMIZATION", |
| 11169 | +#endif |
| 11170 | +#ifdef SQLITE_OMIT_UTF16 |
| 11171 | + "OMIT_UTF16", |
| 11172 | +#endif |
| 11173 | +#ifdef SQLITE_OMIT_VACUUM |
| 11174 | + "OMIT_VACUUM", |
| 11175 | +#endif |
| 11176 | +#ifdef SQLITE_OMIT_VIEW |
| 11177 | + "OMIT_VIEW", |
| 11178 | +#endif |
| 11179 | +#ifdef SQLITE_OMIT_VIRTUALTABLE |
| 11180 | + "OMIT_VIRTUALTABLE", |
| 11181 | +#endif |
| 11182 | +#ifdef SQLITE_OMIT_WSD |
| 11183 | + "OMIT_WSD", |
| 11184 | +#endif |
| 11185 | +#ifdef SQLITE_OMIT_XFER_OPT |
| 11186 | + "OMIT_XFER_OPT", |
| 11187 | +#endif |
| 11188 | +#ifdef SQLITE_PERFORMANCE_TRACE |
| 11189 | + "PERFORMANCE_TRACE", |
| 11190 | +#endif |
| 11191 | +#ifdef SQLITE_PROXY_DEBUG |
| 11192 | + "PROXY_DEBUG", |
| 11193 | +#endif |
| 11194 | +#ifdef SQLITE_SECURE_DELETE |
| 11195 | + "SECURE_DELETE", |
| 11196 | +#endif |
| 11197 | +#ifdef SQLITE_SMALL_STACK |
| 11198 | + "SMALL_STACK", |
| 11199 | +#endif |
| 11200 | +#ifdef SQLITE_SOUNDEX |
| 11201 | + "SOUNDEX", |
| 11202 | +#endif |
| 11203 | +#ifdef SQLITE_TCL |
| 11204 | + "TCL", |
| 11205 | +#endif |
| 11206 | +#ifdef SQLITE_TEMP_STORE |
| 11207 | + "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE), |
| 11208 | +#endif |
| 11209 | +#ifdef SQLITE_TEST |
| 11210 | + "TEST", |
| 11211 | +#endif |
| 11212 | +#ifdef SQLITE_THREADSAFE |
| 11213 | + "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE), |
| 11214 | +#endif |
| 11215 | +#ifdef SQLITE_USE_ALLOCA |
| 11216 | + "USE_ALLOCA", |
| 11217 | +#endif |
| 11218 | +#ifdef SQLITE_ZERO_MALLOC |
| 11219 | + "ZERO_MALLOC" |
| 11220 | +#endif |
| 11221 | +}; |
| 11222 | + |
| 11223 | +/* |
| 11224 | +** Given the name of a compile-time option, return true if that option |
| 11225 | +** was used and false if not. |
| 11226 | +** |
| 11227 | +** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix |
| 11228 | +** is not required for a match. |
| 11229 | +*/ |
| 11230 | +SQLITE_API int sqlite3_compileoption_used(const char *zOptName){ |
| 11231 | + int i, n; |
| 11232 | + if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7; |
| 11233 | + n = sqlite3Strlen30(zOptName); |
| 11234 | + |
| 11235 | + /* Since ArraySize(azCompileOpt) is normally in single digits, a |
| 11236 | + ** linear search is adequate. No need for a binary search. */ |
| 11237 | + for(i=0; i<ArraySize(azCompileOpt); i++){ |
| 11238 | + if( (sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0) |
| 11239 | + && ( (azCompileOpt[i][n]==0) || (azCompileOpt[i][n]=='=') ) ) return 1; |
| 11240 | + } |
| 11241 | + return 0; |
| 11242 | +} |
| 11243 | + |
| 11244 | +/* |
| 11245 | +** Return the N-th compile-time option string. If N is out of range, |
| 11246 | +** return a NULL pointer. |
| 11247 | +*/ |
| 11248 | +SQLITE_API const char *sqlite3_compileoption_get(int N){ |
| 11249 | + if( N>=0 && N<ArraySize(azCompileOpt) ){ |
| 11250 | + return azCompileOpt[N]; |
| 11251 | + } |
| 11252 | + return 0; |
| 11253 | +} |
| 11254 | + |
| 11255 | +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ |
| 11256 | + |
| 11257 | +/************** End of ctime.c ***********************************************/ |
| 10871 | 11258 | /************** Begin file status.c ******************************************/ |
| 10872 | 11259 | /* |
| 10873 | 11260 | ** 2008 June 18 |
| 10874 | 11261 | ** |
| 10875 | 11262 | ** The author disclaims copyright to this source code. In place of |
| | @@ -12996,11 +13383,12 @@ |
| 12996 | 13383 | */ |
| 12997 | 13384 | static void sqlite3MemFree(void *pPrior){ |
| 12998 | 13385 | struct MemBlockHdr *pHdr; |
| 12999 | 13386 | void **pBt; |
| 13000 | 13387 | char *z; |
| 13001 | | - assert( sqlite3GlobalConfig.bMemstat || mem.mutex!=0 ); |
| 13388 | + assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 |
| 13389 | + || mem.mutex!=0 ); |
| 13002 | 13390 | pHdr = sqlite3MemsysGetHeader(pPrior); |
| 13003 | 13391 | pBt = (void**)pHdr; |
| 13004 | 13392 | pBt -= pHdr->nBacktraceSlots; |
| 13005 | 13393 | sqlite3_mutex_enter(mem.mutex); |
| 13006 | 13394 | if( pHdr->pPrev ){ |
| | @@ -15623,11 +16011,13 @@ |
| 15623 | 16011 | printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); |
| 15624 | 16012 | } |
| 15625 | 16013 | #endif |
| 15626 | 16014 | } |
| 15627 | 16015 | static int winMutexTry(sqlite3_mutex *p){ |
| 16016 | +#ifndef NDEBUG |
| 15628 | 16017 | DWORD tid = GetCurrentThreadId(); |
| 16018 | +#endif |
| 15629 | 16019 | int rc = SQLITE_BUSY; |
| 15630 | 16020 | assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); |
| 15631 | 16021 | /* |
| 15632 | 16022 | ** The sqlite3_mutex_try() routine is very rarely used, and when it |
| 15633 | 16023 | ** is used it is merely an optimization. So it is OK for it to always |
| | @@ -15661,11 +16051,13 @@ |
| 15661 | 16051 | ** previously entered by the same thread. The behavior |
| 15662 | 16052 | ** is undefined if the mutex is not currently entered or |
| 15663 | 16053 | ** is not currently allocated. SQLite will never do either. |
| 15664 | 16054 | */ |
| 15665 | 16055 | static void winMutexLeave(sqlite3_mutex *p){ |
| 15666 | | - DWORD tid = GetCurrentThreadId(); |
| 16056 | +#ifndef NDEBUG |
| 16057 | + DWORD tid = GetCurrentThreadId(); |
| 16058 | +#endif |
| 15667 | 16059 | assert( p->nRef>0 ); |
| 15668 | 16060 | assert( p->owner==tid ); |
| 15669 | 16061 | p->nRef--; |
| 15670 | 16062 | assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); |
| 15671 | 16063 | LeaveCriticalSection(&p->mutex); |
| | @@ -18422,23 +18814,25 @@ |
| 18422 | 18814 | ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must |
| 18423 | 18815 | ** be freed by the calling function. |
| 18424 | 18816 | ** |
| 18425 | 18817 | ** NULL is returned if there is an allocation error. |
| 18426 | 18818 | */ |
| 18427 | | -SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){ |
| 18819 | +SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){ |
| 18428 | 18820 | Mem m; |
| 18429 | 18821 | memset(&m, 0, sizeof(m)); |
| 18430 | 18822 | m.db = db; |
| 18431 | | - sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC); |
| 18823 | + sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC); |
| 18432 | 18824 | sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8); |
| 18433 | 18825 | if( db->mallocFailed ){ |
| 18434 | 18826 | sqlite3VdbeMemRelease(&m); |
| 18435 | 18827 | m.z = 0; |
| 18436 | 18828 | } |
| 18437 | 18829 | assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); |
| 18438 | 18830 | assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); |
| 18439 | | - return (m.flags & MEM_Dyn)!=0 ? m.z : sqlite3DbStrDup(db, m.z); |
| 18831 | + assert( (m.flags & MEM_Dyn)!=0 || db->mallocFailed ); |
| 18832 | + assert( m.z || db->mallocFailed ); |
| 18833 | + return m.z; |
| 18440 | 18834 | } |
| 18441 | 18835 | |
| 18442 | 18836 | /* |
| 18443 | 18837 | ** Convert a UTF-8 string to the UTF-16 encoding specified by parameter |
| 18444 | 18838 | ** enc. A pointer to the new string is returned, and the value of *pnOut |
| | @@ -19236,11 +19630,11 @@ |
| 19236 | 19630 | return 2; |
| 19237 | 19631 | } |
| 19238 | 19632 | |
| 19239 | 19633 | /* Verify that constants are precomputed correctly */ |
| 19240 | 19634 | assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); |
| 19241 | | - assert( SLOT_4_2_0 == ((0xf<<28) | (0x7f<<14) | (0x7f)) ); |
| 19635 | + assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); |
| 19242 | 19636 | |
| 19243 | 19637 | p++; |
| 19244 | 19638 | a = a<<14; |
| 19245 | 19639 | a |= *p; |
| 19246 | 19640 | /* a: p0<<14 | p2 (unmasked) */ |
| | @@ -25761,11 +26155,13 @@ |
| 25761 | 26155 | flags |= SQLITE_OPEN_READONLY; |
| 25762 | 26156 | openFlags |= O_RDONLY; |
| 25763 | 26157 | fd = open(zName, openFlags, openMode); |
| 25764 | 26158 | } |
| 25765 | 26159 | if( fd<0 ){ |
| 25766 | | - rc = SQLITE_CANTOPEN_BKPT; |
| 26160 | + sqlite3_log(SQLITE_CANTOPEN, "cannot open file [%s]: %s", zName, |
| 26161 | + strerror(errno)); |
| 26162 | + rc = SQLITE_CANTOPEN; |
| 25767 | 26163 | goto open_finished; |
| 25768 | 26164 | } |
| 25769 | 26165 | } |
| 25770 | 26166 | assert( fd>=0 ); |
| 25771 | 26167 | if( pOutFlags ){ |
| | @@ -33815,10 +34211,13 @@ |
| 33815 | 34211 | if( rc==SQLITE_OK ){ |
| 33816 | 34212 | zMaster = pPager->pTmpSpace; |
| 33817 | 34213 | rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); |
| 33818 | 34214 | testcase( rc!=SQLITE_OK ); |
| 33819 | 34215 | } |
| 34216 | + if( rc==SQLITE_OK && pPager->noSync==0 && pPager->state>=PAGER_EXCLUSIVE ){ |
| 34217 | + rc = sqlite3OsSync(pPager->fd, pPager->sync_flags); |
| 34218 | + } |
| 33820 | 34219 | if( rc==SQLITE_OK ){ |
| 33821 | 34220 | rc = pager_end_transaction(pPager, zMaster[0]!='\0'); |
| 33822 | 34221 | testcase( rc!=SQLITE_OK ); |
| 33823 | 34222 | } |
| 33824 | 34223 | if( rc==SQLITE_OK && zMaster[0] && res ){ |
| | @@ -35135,10 +35534,11 @@ |
| 35135 | 35534 | } |
| 35136 | 35535 | /* pPager->xBusyHandler = 0; */ |
| 35137 | 35536 | /* pPager->pBusyHandlerArg = 0; */ |
| 35138 | 35537 | pPager->xReiniter = xReinit; |
| 35139 | 35538 | /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ |
| 35539 | + |
| 35140 | 35540 | *ppPager = pPager; |
| 35141 | 35541 | return SQLITE_OK; |
| 35142 | 35542 | } |
| 35143 | 35543 | |
| 35144 | 35544 | |
| | @@ -35284,12 +35684,28 @@ |
| 35284 | 35684 | rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset); |
| 35285 | 35685 | if( rc==SQLITE_IOERR_SHORT_READ ){ |
| 35286 | 35686 | rc = SQLITE_OK; |
| 35287 | 35687 | } |
| 35288 | 35688 | if( pgno==1 ){ |
| 35289 | | - u8 *dbFileVers = &((u8*)pPg->pData)[24]; |
| 35290 | | - memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers)); |
| 35689 | + if( rc ){ |
| 35690 | + /* If the read is unsuccessful, set the dbFileVers[] to something |
| 35691 | + ** that will never be a valid file version. dbFileVers[] is a copy |
| 35692 | + ** of bytes 24..39 of the database. Bytes 28..31 should always be |
| 35693 | + ** zero. Bytes 32..35 and 35..39 should be page numbers which are |
| 35694 | + ** never 0xffffffff. So filling pPager->dbFileVers[] with all 0xff |
| 35695 | + ** bytes should suffice. |
| 35696 | + ** |
| 35697 | + ** For an encrypted database, the situation is more complex: bytes |
| 35698 | + ** 24..39 of the database are white noise. But the probability of |
| 35699 | + ** white noising equaling 16 bytes of 0xff is vanishingly small so |
| 35700 | + ** we should still be ok. |
| 35701 | + */ |
| 35702 | + memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers)); |
| 35703 | + }else{ |
| 35704 | + u8 *dbFileVers = &((u8*)pPg->pData)[24]; |
| 35705 | + memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers)); |
| 35706 | + } |
| 35291 | 35707 | } |
| 35292 | 35708 | CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM); |
| 35293 | 35709 | |
| 35294 | 35710 | PAGER_INCR(sqlite3_pager_readdb_count); |
| 35295 | 35711 | PAGER_INCR(pPager->nRead); |
| | @@ -36786,10 +37202,11 @@ |
| 36786 | 37202 | if( op==SAVEPOINT_RELEASE ){ |
| 36787 | 37203 | if( nNew==0 && isOpen(pPager->sjfd) ){ |
| 36788 | 37204 | /* Only truncate if it is an in-memory sub-journal. */ |
| 36789 | 37205 | if( sqlite3IsMemJournal(pPager->sjfd) ){ |
| 36790 | 37206 | rc = sqlite3OsTruncate(pPager->sjfd, 0); |
| 37207 | + assert( rc==SQLITE_OK ); |
| 36791 | 37208 | } |
| 36792 | 37209 | pPager->nSubRec = 0; |
| 36793 | 37210 | } |
| 36794 | 37211 | } |
| 36795 | 37212 | /* Else this is a rollback operation, playback the specified savepoint. |
| | @@ -43199,11 +43616,11 @@ |
| 43199 | 43616 | if( nOvfl ){ |
| 43200 | 43617 | rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext); |
| 43201 | 43618 | if( rc ) return rc; |
| 43202 | 43619 | } |
| 43203 | 43620 | |
| 43204 | | - if( (pOvfl || (pOvfl = btreePageLookup(pBt, ovflPgno))) |
| 43621 | + if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) ) |
| 43205 | 43622 | && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1 |
| 43206 | 43623 | ){ |
| 43207 | 43624 | /* There is no reason any cursor should have an outstanding reference |
| 43208 | 43625 | ** to an overflow page belonging to a cell that is being deleted/updated. |
| 43209 | 43626 | ** So if there exists more than one reference to this page, then it |
| | @@ -43952,11 +44369,11 @@ |
| 43952 | 44369 | ** the dropCell() routine will overwrite the entire cell with zeroes. |
| 43953 | 44370 | ** In this case, temporarily copy the cell into the aOvflSpace[] |
| 43954 | 44371 | ** buffer. It will be copied out again as soon as the aSpace[] buffer |
| 43955 | 44372 | ** is allocated. */ |
| 43956 | 44373 | if( pBt->secureDelete ){ |
| 43957 | | - int iOff = apDiv[i] - pParent->aData; |
| 44374 | + int iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData); |
| 43958 | 44375 | if( (iOff+szNew[i])>pBt->usableSize ){ |
| 43959 | 44376 | rc = SQLITE_CORRUPT_BKPT; |
| 43960 | 44377 | memset(apOld, 0, (i+1)*sizeof(MemPage*)); |
| 43961 | 44378 | goto balance_cleanup; |
| 43962 | 44379 | }else{ |
| | @@ -47321,11 +47738,11 @@ |
| 47321 | 47738 | SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){ |
| 47322 | 47739 | assert( (pFrom->flags & MEM_RowSet)==0 ); |
| 47323 | 47740 | sqlite3VdbeMemReleaseExternal(pTo); |
| 47324 | 47741 | memcpy(pTo, pFrom, MEMCELLSIZE); |
| 47325 | 47742 | pTo->xDel = 0; |
| 47326 | | - if( (pFrom->flags&MEM_Dyn)!=0 || pFrom->z==pFrom->zMalloc ){ |
| 47743 | + if( (pFrom->flags&MEM_Static)==0 ){ |
| 47327 | 47744 | pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem); |
| 47328 | 47745 | assert( srcType==MEM_Ephem || srcType==MEM_Static ); |
| 47329 | 47746 | pTo->flags |= srcType; |
| 47330 | 47747 | } |
| 47331 | 47748 | } |
| | @@ -49953,16 +50370,21 @@ |
| 49953 | 50370 | } |
| 49954 | 50371 | |
| 49955 | 50372 | /* If eStatementOp is non-zero, then a statement transaction needs to |
| 49956 | 50373 | ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to |
| 49957 | 50374 | ** do so. If this operation returns an error, and the current statement |
| 49958 | | - ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then set the error |
| 49959 | | - ** code to the new value. |
| 50375 | + ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the |
| 50376 | + ** current statement error code. |
| 50377 | + ** |
| 50378 | + ** Note that sqlite3VdbeCloseStatement() can only fail if eStatementOp |
| 50379 | + ** is SAVEPOINT_ROLLBACK. But if p->rc==SQLITE_OK then eStatementOp |
| 50380 | + ** must be SAVEPOINT_RELEASE. Hence the NEVER(p->rc==SQLITE_OK) in |
| 50381 | + ** the following code. |
| 49960 | 50382 | */ |
| 49961 | 50383 | if( eStatementOp ){ |
| 49962 | 50384 | rc = sqlite3VdbeCloseStatement(p, eStatementOp); |
| 49963 | | - if( rc && (p->rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT) ){ |
| 50385 | + if( rc && (NEVER(p->rc==SQLITE_OK) || p->rc==SQLITE_CONSTRAINT) ){ |
| 49964 | 50386 | p->rc = rc; |
| 49965 | 50387 | sqlite3DbFree(db, p->zErrMsg); |
| 49966 | 50388 | p->zErrMsg = 0; |
| 49967 | 50389 | } |
| 49968 | 50390 | } |
| | @@ -52577,21 +52999,34 @@ |
| 52577 | 52999 | ** look like a number, leave it alone. |
| 52578 | 53000 | */ |
| 52579 | 53001 | static void applyNumericAffinity(Mem *pRec){ |
| 52580 | 53002 | if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){ |
| 52581 | 53003 | int realnum; |
| 53004 | + u8 enc = pRec->enc; |
| 52582 | 53005 | sqlite3VdbeMemNulTerminate(pRec); |
| 52583 | | - if( (pRec->flags&MEM_Str) |
| 52584 | | - && sqlite3IsNumber(pRec->z, &realnum, pRec->enc) ){ |
| 53006 | + if( (pRec->flags&MEM_Str) && sqlite3IsNumber(pRec->z, &realnum, enc) ){ |
| 52585 | 53007 | i64 value; |
| 52586 | | - sqlite3VdbeChangeEncoding(pRec, SQLITE_UTF8); |
| 52587 | | - if( !realnum && sqlite3Atoi64(pRec->z, &value) ){ |
| 53008 | + char *zUtf8 = pRec->z; |
| 53009 | +#ifndef SQLITE_OMIT_UTF16 |
| 53010 | + if( enc!=SQLITE_UTF8 ){ |
| 53011 | + assert( pRec->db ); |
| 53012 | + zUtf8 = sqlite3Utf16to8(pRec->db, pRec->z, pRec->n, enc); |
| 53013 | + if( !zUtf8 ) return; |
| 53014 | + } |
| 53015 | +#endif |
| 53016 | + if( !realnum && sqlite3Atoi64(zUtf8, &value) ){ |
| 52588 | 53017 | pRec->u.i = value; |
| 52589 | 53018 | MemSetTypeFlag(pRec, MEM_Int); |
| 52590 | 53019 | }else{ |
| 52591 | | - sqlite3VdbeMemRealify(pRec); |
| 53020 | + sqlite3AtoF(zUtf8, &pRec->r); |
| 53021 | + MemSetTypeFlag(pRec, MEM_Real); |
| 52592 | 53022 | } |
| 53023 | +#ifndef SQLITE_OMIT_UTF16 |
| 53024 | + if( enc!=SQLITE_UTF8 ){ |
| 53025 | + sqlite3DbFree(pRec->db, zUtf8); |
| 53026 | + } |
| 53027 | +#endif |
| 52593 | 53028 | } |
| 52594 | 53029 | } |
| 52595 | 53030 | } |
| 52596 | 53031 | |
| 52597 | 53032 | /* |
| | @@ -53039,10 +53474,12 @@ |
| 53039 | 53474 | i64 b; |
| 53040 | 53475 | } ah; |
| 53041 | 53476 | struct OP_Ge_stack_vars { |
| 53042 | 53477 | int res; /* Result of the comparison of pIn1 against pIn3 */ |
| 53043 | 53478 | char affinity; /* Affinity to use for comparison */ |
| 53479 | + u16 flags1; /* Copy of initial value of pIn1->flags */ |
| 53480 | + u16 flags3; /* Copy of initial value of pIn3->flags */ |
| 53044 | 53481 | } ai; |
| 53045 | 53482 | struct OP_Compare_stack_vars { |
| 53046 | 53483 | int n; |
| 53047 | 53484 | int i; |
| 53048 | 53485 | int p1; |
| | @@ -54573,14 +55010,18 @@ |
| 54573 | 55010 | case OP_Gt: /* same as TK_GT, jump, in1, in3 */ |
| 54574 | 55011 | case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ |
| 54575 | 55012 | #if 0 /* local variables moved into u.ai */ |
| 54576 | 55013 | int res; /* Result of the comparison of pIn1 against pIn3 */ |
| 54577 | 55014 | char affinity; /* Affinity to use for comparison */ |
| 55015 | + u16 flags1; /* Copy of initial value of pIn1->flags */ |
| 55016 | + u16 flags3; /* Copy of initial value of pIn3->flags */ |
| 54578 | 55017 | #endif /* local variables moved into u.ai */ |
| 54579 | 55018 | |
| 54580 | 55019 | pIn1 = &aMem[pOp->p1]; |
| 54581 | 55020 | pIn3 = &aMem[pOp->p3]; |
| 55021 | + u.ai.flags1 = pIn1->flags; |
| 55022 | + u.ai.flags3 = pIn3->flags; |
| 54582 | 55023 | if( (pIn1->flags | pIn3->flags)&MEM_Null ){ |
| 54583 | 55024 | /* One or both operands are NULL */ |
| 54584 | 55025 | if( pOp->p5 & SQLITE_NULLEQ ){ |
| 54585 | 55026 | /* If SQLITE_NULLEQ is set (which will only happen if the operator is |
| 54586 | 55027 | ** OP_Eq or OP_Ne) then take the jump or not depending on whether |
| | @@ -54631,10 +55072,14 @@ |
| 54631 | 55072 | pOut->u.i = u.ai.res; |
| 54632 | 55073 | REGISTER_TRACE(pOp->p2, pOut); |
| 54633 | 55074 | }else if( u.ai.res ){ |
| 54634 | 55075 | pc = pOp->p2-1; |
| 54635 | 55076 | } |
| 55077 | + |
| 55078 | + /* Undo any changes made by applyAffinity() to the input registers. */ |
| 55079 | + pIn1->flags = (pIn1->flags&~MEM_TypeMask) | (u.ai.flags1&MEM_TypeMask); |
| 55080 | + pIn3->flags = (pIn3->flags&~MEM_TypeMask) | (u.ai.flags3&MEM_TypeMask); |
| 54636 | 55081 | break; |
| 54637 | 55082 | } |
| 54638 | 55083 | |
| 54639 | 55084 | /* Opcode: Permutation * * * P4 * |
| 54640 | 55085 | ** |
| | @@ -61176,14 +61621,10 @@ |
| 61176 | 61621 | p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight); |
| 61177 | 61622 | p5 = binaryCompareP5(pLeft, pRight, jumpIfNull); |
| 61178 | 61623 | addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1, |
| 61179 | 61624 | (void*)p4, P4_COLLSEQ); |
| 61180 | 61625 | sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5); |
| 61181 | | - if( (p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_NONE ){ |
| 61182 | | - sqlite3ExprCacheAffinityChange(pParse, in1, 1); |
| 61183 | | - sqlite3ExprCacheAffinityChange(pParse, in2, 1); |
| 61184 | | - } |
| 61185 | 61626 | return addr; |
| 61186 | 61627 | } |
| 61187 | 61628 | |
| 61188 | 61629 | #if SQLITE_MAX_EXPR_DEPTH>0 |
| 61189 | 61630 | /* |
| | @@ -71076,397 +71517,10 @@ |
| 71076 | 71517 | } |
| 71077 | 71518 | return p; |
| 71078 | 71519 | } |
| 71079 | 71520 | |
| 71080 | 71521 | /************** End of callback.c ********************************************/ |
| 71081 | | -/************** Begin file ctime.c *******************************************/ |
| 71082 | | -/* |
| 71083 | | -** 2010 February 23 |
| 71084 | | -** |
| 71085 | | -** The author disclaims copyright to this source code. In place of |
| 71086 | | -** a legal notice, here is a blessing: |
| 71087 | | -** |
| 71088 | | -** May you do good and not evil. |
| 71089 | | -** May you find forgiveness for yourself and forgive others. |
| 71090 | | -** May you share freely, never taking more than you give. |
| 71091 | | -** |
| 71092 | | -************************************************************************* |
| 71093 | | -** |
| 71094 | | -** This file implements routines used to report what compile-time options |
| 71095 | | -** SQLite was built with. |
| 71096 | | -*/ |
| 71097 | | - |
| 71098 | | -#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS |
| 71099 | | - |
| 71100 | | - |
| 71101 | | -/* |
| 71102 | | -** An array of names of all compile-time options. This array should |
| 71103 | | -** be sorted A-Z. |
| 71104 | | -** |
| 71105 | | -** This array looks large, but in a typical installation actually uses |
| 71106 | | -** only a handful of compile-time options, so most times this array is usually |
| 71107 | | -** rather short and uses little memory space. |
| 71108 | | -*/ |
| 71109 | | -static const char * const azCompileOpt[] = { |
| 71110 | | - |
| 71111 | | -/* These macros are provided to "stringify" the value of the define |
| 71112 | | -** for those options in which the value is meaningful. */ |
| 71113 | | -#define CTIMEOPT_VAL_(opt) #opt |
| 71114 | | -#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) |
| 71115 | | - |
| 71116 | | -#ifdef SQLITE_32BIT_ROWID |
| 71117 | | - "32BIT_ROWID", |
| 71118 | | -#endif |
| 71119 | | -#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC |
| 71120 | | - "4_BYTE_ALIGNED_MALLOC", |
| 71121 | | -#endif |
| 71122 | | -#ifdef SQLITE_CASE_SENSITIVE_LIKE |
| 71123 | | - "CASE_SENSITIVE_LIKE", |
| 71124 | | -#endif |
| 71125 | | -#ifdef SQLITE_CHECK_PAGES |
| 71126 | | - "CHECK_PAGES", |
| 71127 | | -#endif |
| 71128 | | -#ifdef SQLITE_COVERAGE_TEST |
| 71129 | | - "COVERAGE_TEST", |
| 71130 | | -#endif |
| 71131 | | -#ifdef SQLITE_DEBUG |
| 71132 | | - "DEBUG", |
| 71133 | | -#endif |
| 71134 | | -#ifdef SQLITE_DEFAULT_LOCKING_MODE |
| 71135 | | - "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE), |
| 71136 | | -#endif |
| 71137 | | -#ifdef SQLITE_DISABLE_DIRSYNC |
| 71138 | | - "DISABLE_DIRSYNC", |
| 71139 | | -#endif |
| 71140 | | -#ifdef SQLITE_DISABLE_LFS |
| 71141 | | - "DISABLE_LFS", |
| 71142 | | -#endif |
| 71143 | | -#ifdef SQLITE_ENABLE_ATOMIC_WRITE |
| 71144 | | - "ENABLE_ATOMIC_WRITE", |
| 71145 | | -#endif |
| 71146 | | -#ifdef SQLITE_ENABLE_CEROD |
| 71147 | | - "ENABLE_CEROD", |
| 71148 | | -#endif |
| 71149 | | -#ifdef SQLITE_ENABLE_COLUMN_METADATA |
| 71150 | | - "ENABLE_COLUMN_METADATA", |
| 71151 | | -#endif |
| 71152 | | -#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT |
| 71153 | | - "ENABLE_EXPENSIVE_ASSERT", |
| 71154 | | -#endif |
| 71155 | | -#ifdef SQLITE_ENABLE_FTS1 |
| 71156 | | - "ENABLE_FTS1", |
| 71157 | | -#endif |
| 71158 | | -#ifdef SQLITE_ENABLE_FTS2 |
| 71159 | | - "ENABLE_FTS2", |
| 71160 | | -#endif |
| 71161 | | -#ifdef SQLITE_ENABLE_FTS3 |
| 71162 | | - "ENABLE_FTS3", |
| 71163 | | -#endif |
| 71164 | | -#ifdef SQLITE_ENABLE_FTS3_PARENTHESIS |
| 71165 | | - "ENABLE_FTS3_PARENTHESIS", |
| 71166 | | -#endif |
| 71167 | | -#ifdef SQLITE_ENABLE_FTS4 |
| 71168 | | - "ENABLE_FTS4", |
| 71169 | | -#endif |
| 71170 | | -#ifdef SQLITE_ENABLE_ICU |
| 71171 | | - "ENABLE_ICU", |
| 71172 | | -#endif |
| 71173 | | -#ifdef SQLITE_ENABLE_IOTRACE |
| 71174 | | - "ENABLE_IOTRACE", |
| 71175 | | -#endif |
| 71176 | | -#ifdef SQLITE_ENABLE_LOAD_EXTENSION |
| 71177 | | - "ENABLE_LOAD_EXTENSION", |
| 71178 | | -#endif |
| 71179 | | -#ifdef SQLITE_ENABLE_LOCKING_STYLE |
| 71180 | | - "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), |
| 71181 | | -#endif |
| 71182 | | -#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT |
| 71183 | | - "ENABLE_MEMORY_MANAGEMENT", |
| 71184 | | -#endif |
| 71185 | | -#ifdef SQLITE_ENABLE_MEMSYS3 |
| 71186 | | - "ENABLE_MEMSYS3", |
| 71187 | | -#endif |
| 71188 | | -#ifdef SQLITE_ENABLE_MEMSYS5 |
| 71189 | | - "ENABLE_MEMSYS5", |
| 71190 | | -#endif |
| 71191 | | -#ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK |
| 71192 | | - "ENABLE_OVERSIZE_CELL_CHECK", |
| 71193 | | -#endif |
| 71194 | | -#ifdef SQLITE_ENABLE_RTREE |
| 71195 | | - "ENABLE_RTREE", |
| 71196 | | -#endif |
| 71197 | | -#ifdef SQLITE_ENABLE_STAT2 |
| 71198 | | - "ENABLE_STAT2", |
| 71199 | | -#endif |
| 71200 | | -#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY |
| 71201 | | - "ENABLE_UNLOCK_NOTIFY", |
| 71202 | | -#endif |
| 71203 | | -#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT |
| 71204 | | - "ENABLE_UPDATE_DELETE_LIMIT", |
| 71205 | | -#endif |
| 71206 | | -#ifdef SQLITE_HAS_CODEC |
| 71207 | | - "HAS_CODEC", |
| 71208 | | -#endif |
| 71209 | | -#ifdef SQLITE_HAVE_ISNAN |
| 71210 | | - "HAVE_ISNAN", |
| 71211 | | -#endif |
| 71212 | | -#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX |
| 71213 | | - "HOMEGROWN_RECURSIVE_MUTEX", |
| 71214 | | -#endif |
| 71215 | | -#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS |
| 71216 | | - "IGNORE_AFP_LOCK_ERRORS", |
| 71217 | | -#endif |
| 71218 | | -#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS |
| 71219 | | - "IGNORE_FLOCK_LOCK_ERRORS", |
| 71220 | | -#endif |
| 71221 | | -#ifdef SQLITE_INT64_TYPE |
| 71222 | | - "INT64_TYPE", |
| 71223 | | -#endif |
| 71224 | | -#ifdef SQLITE_LOCK_TRACE |
| 71225 | | - "LOCK_TRACE", |
| 71226 | | -#endif |
| 71227 | | -#ifdef SQLITE_MEMDEBUG |
| 71228 | | - "MEMDEBUG", |
| 71229 | | -#endif |
| 71230 | | -#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT |
| 71231 | | - "MIXED_ENDIAN_64BIT_FLOAT", |
| 71232 | | -#endif |
| 71233 | | -#ifdef SQLITE_NO_SYNC |
| 71234 | | - "NO_SYNC", |
| 71235 | | -#endif |
| 71236 | | -#ifdef SQLITE_OMIT_ALTERTABLE |
| 71237 | | - "OMIT_ALTERTABLE", |
| 71238 | | -#endif |
| 71239 | | -#ifdef SQLITE_OMIT_ANALYZE |
| 71240 | | - "OMIT_ANALYZE", |
| 71241 | | -#endif |
| 71242 | | -#ifdef SQLITE_OMIT_ATTACH |
| 71243 | | - "OMIT_ATTACH", |
| 71244 | | -#endif |
| 71245 | | -#ifdef SQLITE_OMIT_AUTHORIZATION |
| 71246 | | - "OMIT_AUTHORIZATION", |
| 71247 | | -#endif |
| 71248 | | -#ifdef SQLITE_OMIT_AUTOINCREMENT |
| 71249 | | - "OMIT_AUTOINCREMENT", |
| 71250 | | -#endif |
| 71251 | | -#ifdef SQLITE_OMIT_AUTOINIT |
| 71252 | | - "OMIT_AUTOINIT", |
| 71253 | | -#endif |
| 71254 | | -#ifdef SQLITE_OMIT_AUTOVACUUM |
| 71255 | | - "OMIT_AUTOVACUUM", |
| 71256 | | -#endif |
| 71257 | | -#ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION |
| 71258 | | - "OMIT_BETWEEN_OPTIMIZATION", |
| 71259 | | -#endif |
| 71260 | | -#ifdef SQLITE_OMIT_BLOB_LITERAL |
| 71261 | | - "OMIT_BLOB_LITERAL", |
| 71262 | | -#endif |
| 71263 | | -#ifdef SQLITE_OMIT_BTREECOUNT |
| 71264 | | - "OMIT_BTREECOUNT", |
| 71265 | | -#endif |
| 71266 | | -#ifdef SQLITE_OMIT_BUILTIN_TEST |
| 71267 | | - "OMIT_BUILTIN_TEST", |
| 71268 | | -#endif |
| 71269 | | -#ifdef SQLITE_OMIT_CAST |
| 71270 | | - "OMIT_CAST", |
| 71271 | | -#endif |
| 71272 | | -#ifdef SQLITE_OMIT_CHECK |
| 71273 | | - "OMIT_CHECK", |
| 71274 | | -#endif |
| 71275 | | -#ifdef SQLITE_OMIT_COMPILEOPTION_DIAGS |
| 71276 | | - "OMIT_COMPILEOPTION_DIAGS", |
| 71277 | | -#endif |
| 71278 | | -#ifdef SQLITE_OMIT_COMPLETE |
| 71279 | | - "OMIT_COMPLETE", |
| 71280 | | -#endif |
| 71281 | | -#ifdef SQLITE_OMIT_COMPOUND_SELECT |
| 71282 | | - "OMIT_COMPOUND_SELECT", |
| 71283 | | -#endif |
| 71284 | | -#ifdef SQLITE_OMIT_DATETIME_FUNCS |
| 71285 | | - "OMIT_DATETIME_FUNCS", |
| 71286 | | -#endif |
| 71287 | | -#ifdef SQLITE_OMIT_DECLTYPE |
| 71288 | | - "OMIT_DECLTYPE", |
| 71289 | | -#endif |
| 71290 | | -#ifdef SQLITE_OMIT_DEPRECATED |
| 71291 | | - "OMIT_DEPRECATED", |
| 71292 | | -#endif |
| 71293 | | -#ifdef SQLITE_OMIT_DISKIO |
| 71294 | | - "OMIT_DISKIO", |
| 71295 | | -#endif |
| 71296 | | -#ifdef SQLITE_OMIT_EXPLAIN |
| 71297 | | - "OMIT_EXPLAIN", |
| 71298 | | -#endif |
| 71299 | | -#ifdef SQLITE_OMIT_FLAG_PRAGMAS |
| 71300 | | - "OMIT_FLAG_PRAGMAS", |
| 71301 | | -#endif |
| 71302 | | -#ifdef SQLITE_OMIT_FLOATING_POINT |
| 71303 | | - "OMIT_FLOATING_POINT", |
| 71304 | | -#endif |
| 71305 | | -#ifdef SQLITE_OMIT_FOREIGN_KEY |
| 71306 | | - "OMIT_FOREIGN_KEY", |
| 71307 | | -#endif |
| 71308 | | -#ifdef SQLITE_OMIT_GET_TABLE |
| 71309 | | - "OMIT_GET_TABLE", |
| 71310 | | -#endif |
| 71311 | | -#ifdef SQLITE_OMIT_GLOBALRECOVER |
| 71312 | | - "OMIT_GLOBALRECOVER", |
| 71313 | | -#endif |
| 71314 | | -#ifdef SQLITE_OMIT_INCRBLOB |
| 71315 | | - "OMIT_INCRBLOB", |
| 71316 | | -#endif |
| 71317 | | -#ifdef SQLITE_OMIT_INTEGRITY_CHECK |
| 71318 | | - "OMIT_INTEGRITY_CHECK", |
| 71319 | | -#endif |
| 71320 | | -#ifdef SQLITE_OMIT_LIKE_OPTIMIZATION |
| 71321 | | - "OMIT_LIKE_OPTIMIZATION", |
| 71322 | | -#endif |
| 71323 | | -#ifdef SQLITE_OMIT_LOAD_EXTENSION |
| 71324 | | - "OMIT_LOAD_EXTENSION", |
| 71325 | | -#endif |
| 71326 | | -#ifdef SQLITE_OMIT_LOCALTIME |
| 71327 | | - "OMIT_LOCALTIME", |
| 71328 | | -#endif |
| 71329 | | -#ifdef SQLITE_OMIT_LOOKASIDE |
| 71330 | | - "OMIT_LOOKASIDE", |
| 71331 | | -#endif |
| 71332 | | -#ifdef SQLITE_OMIT_MEMORYDB |
| 71333 | | - "OMIT_MEMORYDB", |
| 71334 | | -#endif |
| 71335 | | -#ifdef SQLITE_OMIT_OR_OPTIMIZATION |
| 71336 | | - "OMIT_OR_OPTIMIZATION", |
| 71337 | | -#endif |
| 71338 | | -#ifdef SQLITE_OMIT_PAGER_PRAGMAS |
| 71339 | | - "OMIT_PAGER_PRAGMAS", |
| 71340 | | -#endif |
| 71341 | | -#ifdef SQLITE_OMIT_PRAGMA |
| 71342 | | - "OMIT_PRAGMA", |
| 71343 | | -#endif |
| 71344 | | -#ifdef SQLITE_OMIT_PROGRESS_CALLBACK |
| 71345 | | - "OMIT_PROGRESS_CALLBACK", |
| 71346 | | -#endif |
| 71347 | | -#ifdef SQLITE_OMIT_QUICKBALANCE |
| 71348 | | - "OMIT_QUICKBALANCE", |
| 71349 | | -#endif |
| 71350 | | -#ifdef SQLITE_OMIT_REINDEX |
| 71351 | | - "OMIT_REINDEX", |
| 71352 | | -#endif |
| 71353 | | -#ifdef SQLITE_OMIT_SCHEMA_PRAGMAS |
| 71354 | | - "OMIT_SCHEMA_PRAGMAS", |
| 71355 | | -#endif |
| 71356 | | -#ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS |
| 71357 | | - "OMIT_SCHEMA_VERSION_PRAGMAS", |
| 71358 | | -#endif |
| 71359 | | -#ifdef SQLITE_OMIT_SHARED_CACHE |
| 71360 | | - "OMIT_SHARED_CACHE", |
| 71361 | | -#endif |
| 71362 | | -#ifdef SQLITE_OMIT_SUBQUERY |
| 71363 | | - "OMIT_SUBQUERY", |
| 71364 | | -#endif |
| 71365 | | -#ifdef SQLITE_OMIT_TCL_VARIABLE |
| 71366 | | - "OMIT_TCL_VARIABLE", |
| 71367 | | -#endif |
| 71368 | | -#ifdef SQLITE_OMIT_TEMPDB |
| 71369 | | - "OMIT_TEMPDB", |
| 71370 | | -#endif |
| 71371 | | -#ifdef SQLITE_OMIT_TRACE |
| 71372 | | - "OMIT_TRACE", |
| 71373 | | -#endif |
| 71374 | | -#ifdef SQLITE_OMIT_TRIGGER |
| 71375 | | - "OMIT_TRIGGER", |
| 71376 | | -#endif |
| 71377 | | -#ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION |
| 71378 | | - "OMIT_TRUNCATE_OPTIMIZATION", |
| 71379 | | -#endif |
| 71380 | | -#ifdef SQLITE_OMIT_UTF16 |
| 71381 | | - "OMIT_UTF16", |
| 71382 | | -#endif |
| 71383 | | -#ifdef SQLITE_OMIT_VACUUM |
| 71384 | | - "OMIT_VACUUM", |
| 71385 | | -#endif |
| 71386 | | -#ifdef SQLITE_OMIT_VIEW |
| 71387 | | - "OMIT_VIEW", |
| 71388 | | -#endif |
| 71389 | | -#ifdef SQLITE_OMIT_VIRTUALTABLE |
| 71390 | | - "OMIT_VIRTUALTABLE", |
| 71391 | | -#endif |
| 71392 | | -#ifdef SQLITE_OMIT_WSD |
| 71393 | | - "OMIT_WSD", |
| 71394 | | -#endif |
| 71395 | | -#ifdef SQLITE_OMIT_XFER_OPT |
| 71396 | | - "OMIT_XFER_OPT", |
| 71397 | | -#endif |
| 71398 | | -#ifdef SQLITE_PERFORMANCE_TRACE |
| 71399 | | - "PERFORMANCE_TRACE", |
| 71400 | | -#endif |
| 71401 | | -#ifdef SQLITE_PROXY_DEBUG |
| 71402 | | - "PROXY_DEBUG", |
| 71403 | | -#endif |
| 71404 | | -#ifdef SQLITE_SECURE_DELETE |
| 71405 | | - "SECURE_DELETE", |
| 71406 | | -#endif |
| 71407 | | -#ifdef SQLITE_SMALL_STACK |
| 71408 | | - "SMALL_STACK", |
| 71409 | | -#endif |
| 71410 | | -#ifdef SQLITE_SOUNDEX |
| 71411 | | - "SOUNDEX", |
| 71412 | | -#endif |
| 71413 | | -#ifdef SQLITE_TCL |
| 71414 | | - "TCL", |
| 71415 | | -#endif |
| 71416 | | -#ifdef SQLITE_TEMP_STORE |
| 71417 | | - "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE), |
| 71418 | | -#endif |
| 71419 | | -#ifdef SQLITE_TEST |
| 71420 | | - "TEST", |
| 71421 | | -#endif |
| 71422 | | -#ifdef SQLITE_THREADSAFE |
| 71423 | | - "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE), |
| 71424 | | -#endif |
| 71425 | | -#ifdef SQLITE_USE_ALLOCA |
| 71426 | | - "USE_ALLOCA", |
| 71427 | | -#endif |
| 71428 | | -#ifdef SQLITE_ZERO_MALLOC |
| 71429 | | - "ZERO_MALLOC" |
| 71430 | | -#endif |
| 71431 | | -}; |
| 71432 | | - |
| 71433 | | -/* |
| 71434 | | -** Given the name of a compile-time option, return true if that option |
| 71435 | | -** was used and false if not. |
| 71436 | | -** |
| 71437 | | -** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix |
| 71438 | | -** is not required for a match. |
| 71439 | | -*/ |
| 71440 | | -SQLITE_API int sqlite3_compileoption_used(const char *zOptName){ |
| 71441 | | - int i, n; |
| 71442 | | - if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7; |
| 71443 | | - n = sqlite3Strlen30(zOptName); |
| 71444 | | - |
| 71445 | | - /* Since ArraySize(azCompileOpt) is normally in single digits, a |
| 71446 | | - ** linear search is adequate. No need for a binary search. */ |
| 71447 | | - for(i=0; i<ArraySize(azCompileOpt); i++){ |
| 71448 | | - if( (sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0) |
| 71449 | | - && ( (azCompileOpt[i][n]==0) || (azCompileOpt[i][n]=='=') ) ) return 1; |
| 71450 | | - } |
| 71451 | | - return 0; |
| 71452 | | -} |
| 71453 | | - |
| 71454 | | -/* |
| 71455 | | -** Return the N-th compile-time option string. If N is out of range, |
| 71456 | | -** return a NULL pointer. |
| 71457 | | -*/ |
| 71458 | | -SQLITE_API const char *sqlite3_compileoption_get(int N){ |
| 71459 | | - if( N>=0 && N<ArraySize(azCompileOpt) ){ |
| 71460 | | - return azCompileOpt[N]; |
| 71461 | | - } |
| 71462 | | - return 0; |
| 71463 | | -} |
| 71464 | | - |
| 71465 | | -#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ |
| 71466 | | - |
| 71467 | | -/************** End of ctime.c ***********************************************/ |
| 71468 | 71522 | /************** Begin file delete.c ******************************************/ |
| 71469 | 71523 | /* |
| 71470 | 71524 | ** 2001 September 15 |
| 71471 | 71525 | ** |
| 71472 | 71526 | ** The author disclaims copyright to this source code. In place of |
| | @@ -80134,11 +80188,11 @@ |
| 80134 | 80188 | *ppStmt = 0; |
| 80135 | 80189 | if( !sqlite3SafetyCheckOk(db) ){ |
| 80136 | 80190 | return SQLITE_MISUSE_BKPT; |
| 80137 | 80191 | } |
| 80138 | 80192 | sqlite3_mutex_enter(db->mutex); |
| 80139 | | - zSql8 = sqlite3Utf16to8(db, zSql, nBytes); |
| 80193 | + zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); |
| 80140 | 80194 | if( zSql8 ){ |
| 80141 | 80195 | rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8); |
| 80142 | 80196 | } |
| 80143 | 80197 | |
| 80144 | 80198 | if( zTail8 && pzTail ){ |
| | @@ -97459,11 +97513,11 @@ |
| 97459 | 97513 | ){ |
| 97460 | 97514 | int rc; |
| 97461 | 97515 | char *zFunc8; |
| 97462 | 97516 | sqlite3_mutex_enter(db->mutex); |
| 97463 | 97517 | assert( !db->mallocFailed ); |
| 97464 | | - zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1); |
| 97518 | + zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE); |
| 97465 | 97519 | rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal); |
| 97466 | 97520 | sqlite3DbFree(db, zFunc8); |
| 97467 | 97521 | rc = sqlite3ApiExit(db, rc); |
| 97468 | 97522 | sqlite3_mutex_leave(db->mutex); |
| 97469 | 97523 | return rc; |
| | @@ -98282,11 +98336,11 @@ |
| 98282 | 98336 | ){ |
| 98283 | 98337 | int rc = SQLITE_OK; |
| 98284 | 98338 | char *zName8; |
| 98285 | 98339 | sqlite3_mutex_enter(db->mutex); |
| 98286 | 98340 | assert( !db->mallocFailed ); |
| 98287 | | - zName8 = sqlite3Utf16to8(db, zName, -1); |
| 98341 | + zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE); |
| 98288 | 98342 | if( zName8 ){ |
| 98289 | 98343 | rc = createCollation(db, zName8, (u8)enc, SQLITE_COLL_USER, pCtx, xCompare, 0); |
| 98290 | 98344 | sqlite3DbFree(db, zName8); |
| 98291 | 98345 | } |
| 98292 | 98346 | rc = sqlite3ApiExit(db, rc); |
| | @@ -100273,10 +100327,18 @@ |
| 100273 | 100327 | p->zDb, p->zName |
| 100274 | 100328 | ); |
| 100275 | 100329 | } |
| 100276 | 100330 | return rc; |
| 100277 | 100331 | } |
| 100332 | + |
| 100333 | +/* |
| 100334 | +** An sqlite3_exec() callback for fts3TableExists. |
| 100335 | +*/ |
| 100336 | +static int fts3TableExistsCallback(void *pArg, int n, char **pp1, char **pp2){ |
| 100337 | + *(int*)pArg = 1; |
| 100338 | + return 1; |
| 100339 | +} |
| 100278 | 100340 | |
| 100279 | 100341 | /* |
| 100280 | 100342 | ** Determine if a table currently exists in the database. |
| 100281 | 100343 | */ |
| 100282 | 100344 | static void fts3TableExists( |
| | @@ -100286,14 +100348,21 @@ |
| 100286 | 100348 | const char *zName, /* Name of the FTS3 table */ |
| 100287 | 100349 | const char *zSuffix, /* Shadow table extension */ |
| 100288 | 100350 | u8 *pResult /* Write results here */ |
| 100289 | 100351 | ){ |
| 100290 | 100352 | int rc = SQLITE_OK; |
| 100353 | + int res = 0; |
| 100354 | + char *zSql; |
| 100291 | 100355 | if( *pRc ) return; |
| 100292 | | - fts3DbExec(&rc, db, "SELECT 1 FROM %Q.'%q%s'", zDb, zName, zSuffix); |
| 100293 | | - *pResult = (rc==SQLITE_OK) ? 1 : 0; |
| 100294 | | - if( rc!=SQLITE_ERROR ) *pRc = rc; |
| 100356 | + zSql = sqlite3_mprintf( |
| 100357 | + "SELECT 1 FROM %Q.sqlite_master WHERE name='%q%s'", |
| 100358 | + zDb, zName, zSuffix |
| 100359 | + ); |
| 100360 | + rc = sqlite3_exec(db, zSql, fts3TableExistsCallback, &res, 0); |
| 100361 | + sqlite3_free(zSql); |
| 100362 | + *pResult = res & 0xff; |
| 100363 | + if( rc!=SQLITE_ABORT ) *pRc = rc; |
| 100295 | 100364 | } |
| 100296 | 100365 | |
| 100297 | 100366 | /* |
| 100298 | 100367 | ** This function is the implementation of both the xConnect and xCreate |
| 100299 | 100368 | ** methods of the FTS3 virtual table. |
| | @@ -100711,11 +100780,16 @@ |
| 100711 | 100780 | *piPrev = iVal; |
| 100712 | 100781 | } |
| 100713 | 100782 | |
| 100714 | 100783 | /* |
| 100715 | 100784 | ** When this function is called, *ppPoslist is assumed to point to the |
| 100716 | | -** start of a position-list. |
| 100785 | +** start of a position-list. After it returns, *ppPoslist points to the |
| 100786 | +** first byte after the position-list. |
| 100787 | +** |
| 100788 | +** If pp is not NULL, then the contents of the position list are copied |
| 100789 | +** to *pp. *pp is set to point to the first byte past the last byte copied |
| 100790 | +** before this function returns. |
| 100717 | 100791 | */ |
| 100718 | 100792 | static void fts3PoslistCopy(char **pp, char **ppPoslist){ |
| 100719 | 100793 | char *pEnd = *ppPoslist; |
| 100720 | 100794 | char c = 0; |
| 100721 | 100795 | |
| | @@ -101702,11 +101776,17 @@ |
| 101702 | 101776 | } |
| 101703 | 101777 | |
| 101704 | 101778 | rc = sqlite3Fts3ExprParse(p->pTokenizer, p->azColumn, p->nColumn, |
| 101705 | 101779 | iCol, zQuery, -1, &pCsr->pExpr |
| 101706 | 101780 | ); |
| 101707 | | - if( rc!=SQLITE_OK ) return rc; |
| 101781 | + if( rc!=SQLITE_OK ){ |
| 101782 | + if( rc==SQLITE_ERROR ){ |
| 101783 | + p->base.zErrMsg = sqlite3_mprintf("malformed MATCH expression: [%s]", |
| 101784 | + zQuery); |
| 101785 | + } |
| 101786 | + return rc; |
| 101787 | + } |
| 101708 | 101788 | |
| 101709 | 101789 | rc = evalFts3Expr(p, pCsr->pExpr, &pCsr->aDoclist, &pCsr->nDoclist, 0); |
| 101710 | 101790 | pCsr->pNextId = pCsr->aDoclist; |
| 101711 | 101791 | pCsr->iPrevId = 0; |
| 101712 | 101792 | } |
| | @@ -101855,11 +101935,13 @@ |
| 101855 | 101935 | |
| 101856 | 101936 | assert( pCsr ); |
| 101857 | 101937 | while( pCsr<pEnd ){ |
| 101858 | 101938 | if( pExpr->iCurrent<iDocid ){ |
| 101859 | 101939 | fts3PoslistCopy(0, &pCsr); |
| 101860 | | - fts3GetDeltaVarint(&pCsr, &pExpr->iCurrent); |
| 101940 | + if( pCsr<pEnd ){ |
| 101941 | + fts3GetDeltaVarint(&pCsr, &pExpr->iCurrent); |
| 101942 | + } |
| 101861 | 101943 | pExpr->pCurrent = pCsr; |
| 101862 | 101944 | }else{ |
| 101863 | 101945 | if( pExpr->iCurrent==iDocid ){ |
| 101864 | 101946 | int iThis = 0; |
| 101865 | 101947 | if( iCol<0 ){ |
| | @@ -105105,13 +105187,13 @@ |
| 105105 | 105187 | /* 3 */ "DELETE FROM %Q.'%q_segments'", |
| 105106 | 105188 | /* 4 */ "DELETE FROM %Q.'%q_segdir'", |
| 105107 | 105189 | /* 5 */ "DELETE FROM %Q.'%q_docsize'", |
| 105108 | 105190 | /* 6 */ "DELETE FROM %Q.'%q_stat'", |
| 105109 | 105191 | /* 7 */ "SELECT * FROM %Q.'%q_content' WHERE rowid=?", |
| 105110 | | -/* 8 */ "SELECT coalesce(max(idx)+1, 0) FROM %Q.'%q_segdir' WHERE level=?", |
| 105192 | +/* 8 */ "SELECT (SELECT max(idx) FROM %Q.'%q_segdir' WHERE level = ?) + 1", |
| 105111 | 105193 | /* 9 */ "INSERT INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)", |
| 105112 | | -/* 10 */ "SELECT coalesce(max(blockid)+1, 1) FROM %Q.'%q_segments'", |
| 105194 | +/* 10 */ "SELECT coalesce((SELECT max(blockid) FROM %Q.'%q_segments') + 1, 1)", |
| 105113 | 105195 | /* 11 */ "INSERT INTO %Q.'%q_segdir' VALUES(?,?,?,?,?,?)", |
| 105114 | 105196 | |
| 105115 | 105197 | /* Return segments in order from oldest to newest.*/ |
| 105116 | 105198 | /* 12 */ "SELECT idx, start_block, leaves_end_block, end_block, root " |
| 105117 | 105199 | "FROM %Q.'%q_segdir' WHERE level = ? ORDER BY idx ASC", |
| | @@ -108666,15 +108748,17 @@ |
| 108666 | 108748 | char aBuffer[64]; |
| 108667 | 108749 | sqlite3_snprintf(sizeof(aBuffer), aBuffer, |
| 108668 | 108750 | "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart |
| 108669 | 108751 | ); |
| 108670 | 108752 | rc = fts3StringAppend(&res, aBuffer, -1); |
| 108753 | + }else if( rc==SQLITE_DONE ){ |
| 108754 | + rc = SQLITE_CORRUPT; |
| 108671 | 108755 | } |
| 108672 | 108756 | } |
| 108673 | 108757 | } |
| 108674 | 108758 | if( rc==SQLITE_DONE ){ |
| 108675 | | - rc = SQLITE_CORRUPT; |
| 108759 | + rc = SQLITE_OK; |
| 108676 | 108760 | } |
| 108677 | 108761 | |
| 108678 | 108762 | pMod->xClose(pC); |
| 108679 | 108763 | if( rc!=SQLITE_OK ) goto offsets_out; |
| 108680 | 108764 | } |
| 108681 | 108765 | |