/db/sqlite3/src/sqlite3.c
http://github.com/zpao/v8monkey · C · 26292 lines · 13021 code · 1482 blank · 11789 comment · 1247 complexity · 5a0bcd447240768779afd76ca74478d0 MD5 · raw file
- /******************************************************************************
- ** This file is an amalgamation of many separate C source files from SQLite
- ** version 3.7.10. By combining all the individual C code files into this
- ** single large file, the entire code can be compiled as a single translation
- ** unit. This allows many compilers to do optimizations that would not be
- ** possible if the files were compiled separately. Performance improvements
- ** of 5% or more are commonly seen when SQLite is compiled as a single
- ** translation unit.
- **
- ** This file is all you need to compile SQLite. To use SQLite in other
- ** programs, you need this file and the "sqlite3.h" header file that defines
- ** the programming interface to the SQLite library. (If you do not have
- ** the "sqlite3.h" header file at hand, you will find a copy embedded within
- ** the text of this file. Search for "Begin file sqlite3.h" to find the start
- ** of the embedded sqlite3.h header file.) Additional code files may be needed
- ** if you want a wrapper to interface SQLite with your choice of programming
- ** language. The code for the "sqlite3" command-line shell is also in a
- ** separate file. This file contains only code for the core SQLite library.
- */
- #define SQLITE_CORE 1
- #define SQLITE_AMALGAMATION 1
- #ifndef SQLITE_PRIVATE
- # define SQLITE_PRIVATE static
- #endif
- #ifndef SQLITE_API
- # define SQLITE_API
- #endif
- /************** Begin file sqliteInt.h ***************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** Internal interface definitions for SQLite.
- **
- */
- #ifndef _SQLITEINT_H_
- #define _SQLITEINT_H_
- /*
- ** These #defines should enable >2GB file support on POSIX if the
- ** underlying operating system supports it. If the OS lacks
- ** large file support, or if the OS is windows, these should be no-ops.
- **
- ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
- ** system #includes. Hence, this block of code must be the very first
- ** code in all source files.
- **
- ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
- ** on the compiler command line. This is necessary if you are compiling
- ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
- ** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
- ** without this option, LFS is enable. But LFS does not exist in the kernel
- ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
- ** portability you should omit LFS.
- **
- ** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
- */
- #ifndef SQLITE_DISABLE_LFS
- # define _LARGE_FILE 1
- # ifndef _FILE_OFFSET_BITS
- # define _FILE_OFFSET_BITS 64
- # endif
- # define _LARGEFILE_SOURCE 1
- #endif
- /*
- ** Include the configuration header output by 'configure' if we're using the
- ** autoconf-based build
- */
- #ifdef _HAVE_SQLITE_CONFIG_H
- #include "config.h"
- #endif
- /************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/
- /************** Begin file sqliteLimit.h *************************************/
- /*
- ** 2007 May 7
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file defines various limits of what SQLite can process.
- */
- /*
- ** The maximum length of a TEXT or BLOB in bytes. This also
- ** limits the size of a row in a table or index.
- **
- ** The hard limit is the ability of a 32-bit signed integer
- ** to count the size: 2^31-1 or 2147483647.
- */
- #ifndef SQLITE_MAX_LENGTH
- # define SQLITE_MAX_LENGTH 1000000000
- #endif
- /*
- ** This is the maximum number of
- **
- ** * Columns in a table
- ** * Columns in an index
- ** * Columns in a view
- ** * Terms in the SET clause of an UPDATE statement
- ** * Terms in the result set of a SELECT statement
- ** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
- ** * Terms in the VALUES clause of an INSERT statement
- **
- ** The hard upper limit here is 32676. Most database people will
- ** tell you that in a well-normalized database, you usually should
- ** not have more than a dozen or so columns in any table. And if
- ** that is the case, there is no point in having more than a few
- ** dozen values in any of the other situations described above.
- */
- #ifndef SQLITE_MAX_COLUMN
- # define SQLITE_MAX_COLUMN 2000
- #endif
- /*
- ** The maximum length of a single SQL statement in bytes.
- **
- ** It used to be the case that setting this value to zero would
- ** turn the limit off. That is no longer true. It is not possible
- ** to turn this limit off.
- */
- #ifndef SQLITE_MAX_SQL_LENGTH
- # define SQLITE_MAX_SQL_LENGTH 1000000000
- #endif
- /*
- ** The maximum depth of an expression tree. This is limited to
- ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might
- ** want to place more severe limits on the complexity of an
- ** expression.
- **
- ** A value of 0 used to mean that the limit was not enforced.
- ** But that is no longer true. The limit is now strictly enforced
- ** at all times.
- */
- #ifndef SQLITE_MAX_EXPR_DEPTH
- # define SQLITE_MAX_EXPR_DEPTH 1000
- #endif
- /*
- ** The maximum number of terms in a compound SELECT statement.
- ** The code generator for compound SELECT statements does one
- ** level of recursion for each term. A stack overflow can result
- ** if the number of terms is too large. In practice, most SQL
- ** never has more than 3 or 4 terms. Use a value of 0 to disable
- ** any limit on the number of terms in a compount SELECT.
- */
- #ifndef SQLITE_MAX_COMPOUND_SELECT
- # define SQLITE_MAX_COMPOUND_SELECT 500
- #endif
- /*
- ** The maximum number of opcodes in a VDBE program.
- ** Not currently enforced.
- */
- #ifndef SQLITE_MAX_VDBE_OP
- # define SQLITE_MAX_VDBE_OP 25000
- #endif
- /*
- ** The maximum number of arguments to an SQL function.
- */
- #ifndef SQLITE_MAX_FUNCTION_ARG
- # define SQLITE_MAX_FUNCTION_ARG 127
- #endif
- /*
- ** The maximum number of in-memory pages to use for the main database
- ** table and for temporary tables. The SQLITE_DEFAULT_CACHE_SIZE
- */
- #ifndef SQLITE_DEFAULT_CACHE_SIZE
- # define SQLITE_DEFAULT_CACHE_SIZE 2000
- #endif
- #ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
- # define SQLITE_DEFAULT_TEMP_CACHE_SIZE 500
- #endif
- /*
- ** The default number of frames to accumulate in the log file before
- ** checkpointing the database in WAL mode.
- */
- #ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
- # define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000
- #endif
- /*
- ** The maximum number of attached databases. This must be between 0
- ** and 62. The upper bound on 62 is because a 64-bit integer bitmap
- ** is used internally to track attached databases.
- */
- #ifndef SQLITE_MAX_ATTACHED
- # define SQLITE_MAX_ATTACHED 10
- #endif
- /*
- ** The maximum value of a ?nnn wildcard that the parser will accept.
- */
- #ifndef SQLITE_MAX_VARIABLE_NUMBER
- # define SQLITE_MAX_VARIABLE_NUMBER 999
- #endif
- /* Maximum page size. The upper bound on this value is 65536. This a limit
- ** imposed by the use of 16-bit offsets within each page.
- **
- ** Earlier versions of SQLite allowed the user to change this value at
- ** compile time. This is no longer permitted, on the grounds that it creates
- ** a library that is technically incompatible with an SQLite library
- ** compiled with a different limit. If a process operating on a database
- ** with a page-size of 65536 bytes crashes, then an instance of SQLite
- ** compiled with the default page-size limit will not be able to rollback
- ** the aborted transaction. This could lead to database corruption.
- */
- #ifdef SQLITE_MAX_PAGE_SIZE
- # undef SQLITE_MAX_PAGE_SIZE
- #endif
- #define SQLITE_MAX_PAGE_SIZE 65536
- /*
- ** The default size of a database page.
- */
- #ifndef SQLITE_DEFAULT_PAGE_SIZE
- # define SQLITE_DEFAULT_PAGE_SIZE 1024
- #endif
- #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
- # undef SQLITE_DEFAULT_PAGE_SIZE
- # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
- #endif
- /*
- ** Ordinarily, if no value is explicitly provided, SQLite creates databases
- ** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain
- ** device characteristics (sector-size and atomic write() support),
- ** SQLite may choose a larger value. This constant is the maximum value
- ** SQLite will choose on its own.
- */
- #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE
- # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192
- #endif
- #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
- # undef SQLITE_MAX_DEFAULT_PAGE_SIZE
- # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
- #endif
- /*
- ** Maximum number of pages in one database file.
- **
- ** This is really just the default value for the max_page_count pragma.
- ** This value can be lowered (or raised) at run-time using that the
- ** max_page_count macro.
- */
- #ifndef SQLITE_MAX_PAGE_COUNT
- # define SQLITE_MAX_PAGE_COUNT 1073741823
- #endif
- /*
- ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
- ** operator.
- */
- #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
- # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
- #endif
- /*
- ** Maximum depth of recursion for triggers.
- **
- ** A value of 1 means that a trigger program will not be able to itself
- ** fire any triggers. A value of 0 means that no trigger programs at all
- ** may be executed.
- */
- #ifndef SQLITE_MAX_TRIGGER_DEPTH
- # define SQLITE_MAX_TRIGGER_DEPTH 1000
- #endif
- /************** End of sqliteLimit.h *****************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /* Disable nuisance warnings on Borland compilers */
- #if defined(__BORLANDC__)
- #pragma warn -rch /* unreachable code */
- #pragma warn -ccc /* Condition is always true or false */
- #pragma warn -aus /* Assigned value is never used */
- #pragma warn -csu /* Comparing signed and unsigned */
- #pragma warn -spa /* Suspicious pointer arithmetic */
- #endif
- /* Needed for various definitions... */
- #ifndef _GNU_SOURCE
- # define _GNU_SOURCE
- #endif
- /*
- ** Include standard header files as necessary
- */
- #ifdef HAVE_STDINT_H
- #include <stdint.h>
- #endif
- #ifdef HAVE_INTTYPES_H
- #include <inttypes.h>
- #endif
- /*
- ** The following macros are used to cast pointers to integers and
- ** integers to pointers. The way you do this varies from one compiler
- ** to the next, so we have developed the following set of #if statements
- ** to generate appropriate macros for a wide range of compilers.
- **
- ** The correct "ANSI" way to do this is to use the intptr_t type.
- ** Unfortunately, that typedef is not available on all compilers, or
- ** if it is available, it requires an #include of specific headers
- ** that vary from one machine to the next.
- **
- ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
- ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
- ** So we have to define the macros in different ways depending on the
- ** compiler.
- */
- #if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */
- # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
- # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
- #elif !defined(__GNUC__) /* Works for compilers other than LLVM */
- # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
- # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
- #elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
- # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
- # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
- #else /* Generates a warning - but it always works */
- # define SQLITE_INT_TO_PTR(X) ((void*)(X))
- # define SQLITE_PTR_TO_INT(X) ((int)(X))
- #endif
- /*
- ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
- ** 0 means mutexes are permanently disable and the library is never
- ** threadsafe. 1 means the library is serialized which is the highest
- ** level of threadsafety. 2 means the libary is multithreaded - multiple
- ** threads can use SQLite as long as no two threads try to use the same
- ** database connection at the same time.
- **
- ** Older versions of SQLite used an optional THREADSAFE macro.
- ** We support that for legacy.
- */
- #if !defined(SQLITE_THREADSAFE)
- #if defined(THREADSAFE)
- # define SQLITE_THREADSAFE THREADSAFE
- #else
- # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
- #endif
- #endif
- /*
- ** Powersafe overwrite is on by default. But can be turned off using
- ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
- */
- #ifndef SQLITE_POWERSAFE_OVERWRITE
- # define SQLITE_POWERSAFE_OVERWRITE 1
- #endif
- /*
- ** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.
- ** It determines whether or not the features related to
- ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
- ** be overridden at runtime using the sqlite3_config() API.
- */
- #if !defined(SQLITE_DEFAULT_MEMSTATUS)
- # define SQLITE_DEFAULT_MEMSTATUS 1
- #endif
- /*
- ** Exactly one of the following macros must be defined in order to
- ** specify which memory allocation subsystem to use.
- **
- ** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
- ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
- ** SQLITE_MEMDEBUG // Debugging version of system malloc()
- **
- ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
- ** assert() macro is enabled, each call into the Win32 native heap subsystem
- ** will cause HeapValidate to be called. If heap validation should fail, an
- ** assertion will be triggered.
- **
- ** (Historical note: There used to be several other options, but we've
- ** pared it down to just these three.)
- **
- ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
- ** the default.
- */
- #if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)>1
- # error "At most one of the following compile-time configuration options\
- is allows: SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG"
- #endif
- #if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)==0
- # define SQLITE_SYSTEM_MALLOC 1
- #endif
- /*
- ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
- ** sizes of memory allocations below this value where possible.
- */
- #if !defined(SQLITE_MALLOC_SOFT_LIMIT)
- # define SQLITE_MALLOC_SOFT_LIMIT 1024
- #endif
- /*
- ** We need to define _XOPEN_SOURCE as follows in order to enable
- ** recursive mutexes on most Unix systems. But Mac OS X is different.
- ** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,
- ** so it is omitted there. See ticket #2673.
- **
- ** Later we learn that _XOPEN_SOURCE is poorly or incorrectly
- ** implemented on some systems. So we avoid defining it at all
- ** if it is already defined or if it is unneeded because we are
- ** not doing a threadsafe build. Ticket #2681.
- **
- ** See also ticket #2741.
- */
- #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE
- # define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */
- #endif
- /*
- ** The TCL headers are only needed when compiling the TCL bindings.
- */
- #if defined(SQLITE_TCL) || defined(TCLSH)
- # include <tcl.h>
- #endif
- /*
- ** Many people are failing to set -DNDEBUG=1 when compiling SQLite.
- ** Setting NDEBUG makes the code smaller and run faster. So the following
- ** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1
- ** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out
- ** feature.
- */
- #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
- # define NDEBUG 1
- #endif
- /*
- ** The testcase() macro is used to aid in coverage testing. When
- ** doing coverage testing, the condition inside the argument to
- ** testcase() must be evaluated both true and false in order to
- ** get full branch coverage. The testcase() macro is inserted
- ** to help ensure adequate test coverage in places where simple
- ** condition/decision coverage is inadequate. For example, testcase()
- ** can be used to make sure boundary values are tested. For
- ** bitmask tests, testcase() can be used to make sure each bit
- ** is significant and used at least once. On switch statements
- ** where multiple cases go to the same block of code, testcase()
- ** can insure that all cases are evaluated.
- **
- */
- #ifdef SQLITE_COVERAGE_TEST
- SQLITE_PRIVATE void sqlite3Coverage(int);
- # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
- #else
- # define testcase(X)
- #endif
- /*
- ** The TESTONLY macro is used to enclose variable declarations or
- ** other bits of code that are needed to support the arguments
- ** within testcase() and assert() macros.
- */
- #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
- # define TESTONLY(X) X
- #else
- # define TESTONLY(X)
- #endif
- /*
- ** Sometimes we need a small amount of code such as a variable initialization
- ** to setup for a later assert() statement. We do not want this code to
- ** appear when assert() is disabled. The following macro is therefore
- ** used to contain that setup code. The "VVA" acronym stands for
- ** "Verification, Validation, and Accreditation". In other words, the
- ** code within VVA_ONLY() will only run during verification processes.
- */
- #ifndef NDEBUG
- # define VVA_ONLY(X) X
- #else
- # define VVA_ONLY(X)
- #endif
- /*
- ** The ALWAYS and NEVER macros surround boolean expressions which
- ** are intended to always be true or false, respectively. Such
- ** expressions could be omitted from the code completely. But they
- ** are included in a few cases in order to enhance the resilience
- ** of SQLite to unexpected behavior - to make the code "self-healing"
- ** or "ductile" rather than being "brittle" and crashing at the first
- ** hint of unplanned behavior.
- **
- ** In other words, ALWAYS and NEVER are added for defensive code.
- **
- ** When doing coverage testing ALWAYS and NEVER are hard-coded to
- ** be true and false so that the unreachable code then specify will
- ** not be counted as untested code.
- */
- #if defined(SQLITE_COVERAGE_TEST)
- # define ALWAYS(X) (1)
- # define NEVER(X) (0)
- #elif !defined(NDEBUG)
- # define ALWAYS(X) ((X)?1:(assert(0),0))
- # define NEVER(X) ((X)?(assert(0),1):0)
- #else
- # define ALWAYS(X) (X)
- # define NEVER(X) (X)
- #endif
- /*
- ** Return true (non-zero) if the input is a integer that is too large
- ** to fit in 32-bits. This macro is used inside of various testcase()
- ** macros to verify that we have tested SQLite for large-file support.
- */
- #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
- /*
- ** The macro unlikely() is a hint that surrounds a boolean
- ** expression that is usually false. Macro likely() surrounds
- ** a boolean expression that is usually true. GCC is able to
- ** use these hints to generate better code, sometimes.
- */
- #if defined(__GNUC__) && 0
- # define likely(X) __builtin_expect((X),1)
- # define unlikely(X) __builtin_expect((X),0)
- #else
- # define likely(X) !!(X)
- # define unlikely(X) !!(X)
- #endif
- /************** Include sqlite3.h in the middle of sqliteInt.h ***************/
- /************** Begin file sqlite3.h *****************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This header file defines the interface that the SQLite library
- ** presents to client programs. If a C-function, structure, datatype,
- ** or constant definition does not appear in this file, then it is
- ** not a published API of SQLite, is subject to change without
- ** notice, and should not be referenced by programs that use SQLite.
- **
- ** Some of the definitions that are in this file are marked as
- ** "experimental". Experimental interfaces are normally new
- ** features recently added to SQLite. We do not anticipate changes
- ** to experimental interfaces but reserve the right to make minor changes
- ** if experience from use "in the wild" suggest such changes are prudent.
- **
- ** The official C-language API documentation for SQLite is derived
- ** from comments in this file. This file is the authoritative source
- ** on how SQLite interfaces are suppose to operate.
- **
- ** The name of this file under configuration management is "sqlite.h.in".
- ** The makefile makes some minor changes to this file (such as inserting
- ** the version number) and changes its name to "sqlite3.h" as
- ** part of the build process.
- */
- #ifndef _SQLITE3_H_
- #define _SQLITE3_H_
- #include <stdarg.h> /* Needed for the definition of va_list */
- /*
- ** Make sure we can call this stuff from C++.
- */
- #if 0
- extern "C" {
- #endif
- /*
- ** Add the ability to override 'extern'
- */
- #ifndef SQLITE_EXTERN
- # define SQLITE_EXTERN extern
- #endif
- #ifndef SQLITE_API
- # define SQLITE_API
- #endif
- /*
- ** These no-op macros are used in front of interfaces to mark those
- ** interfaces as either deprecated or experimental. New applications
- ** should not use deprecated interfaces - they are support for backwards
- ** compatibility only. Application writers should be aware that
- ** experimental interfaces are subject to change in point releases.
- **
- ** These macros used to resolve to various kinds of compiler magic that
- ** would generate warning messages when they were used. But that
- ** compiler magic ended up generating such a flurry of bug reports
- ** that we have taken it all out and gone back to using simple
- ** noop macros.
- */
- #define SQLITE_DEPRECATED
- #define SQLITE_EXPERIMENTAL
- /*
- ** Ensure these symbols were not defined by some previous header file.
- */
- #ifdef SQLITE_VERSION
- # undef SQLITE_VERSION
- #endif
- #ifdef SQLITE_VERSION_NUMBER
- # undef SQLITE_VERSION_NUMBER
- #endif
- /*
- ** CAPI3REF: Compile-Time Library Version Numbers
- **
- ** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
- ** evaluates to a string literal that is the SQLite version in the
- ** format "X.Y.Z" where X is the major version number (always 3 for
- ** SQLite3) and Y is the minor version number and Z is the release number.)^
- ** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer
- ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
- ** numbers used in [SQLITE_VERSION].)^
- ** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
- ** be larger than the release from which it is derived. Either Y will
- ** be held constant and Z will be incremented or else Y will be incremented
- ** and Z will be reset to zero.
- **
- ** Since version 3.6.18, SQLite source code has been stored in the
- ** <a href="http://www.fossil-scm.org/">Fossil configuration management
- ** system</a>. ^The SQLITE_SOURCE_ID macro evaluates to
- ** a string which identifies a particular check-in of SQLite
- ** within its configuration management system. ^The SQLITE_SOURCE_ID
- ** string contains the date and time of the check-in (UTC) and an SHA1
- ** hash of the entire source tree.
- **
- ** See also: [sqlite3_libversion()],
- ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
- ** [sqlite_version()] and [sqlite_source_id()].
- */
- #define SQLITE_VERSION "3.7.10"
- #define SQLITE_VERSION_NUMBER 3007010
- #define SQLITE_SOURCE_ID "2012-01-16 13:28:40 ebd01a8deffb5024a5d7494eef800d2366d97204"
- /*
- ** CAPI3REF: Run-Time Library Version Numbers
- ** KEYWORDS: sqlite3_version, sqlite3_sourceid
- **
- ** These interfaces provide the same information as the [SQLITE_VERSION],
- ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
- ** but are associated with the library instead of the header file. ^(Cautious
- ** programmers might include assert() statements in their application to
- ** verify that values returned by these interfaces match the macros in
- ** the header, and thus insure that the application is
- ** compiled with matching library and header files.
- **
- ** <blockquote><pre>
- ** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
- ** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
- ** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
- ** </pre></blockquote>)^
- **
- ** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
- ** macro. ^The sqlite3_libversion() function returns a pointer to the
- ** to the sqlite3_version[] string constant. The sqlite3_libversion()
- ** function is provided for use in DLLs since DLL users usually do not have
- ** direct access to string constants within the DLL. ^The
- ** sqlite3_libversion_number() function returns an integer equal to
- ** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns
- ** a pointer to a string constant whose value is the same as the
- ** [SQLITE_SOURCE_ID] C preprocessor macro.
- **
- ** See also: [sqlite_version()] and [sqlite_source_id()].
- */
- SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;
- SQLITE_API const char *sqlite3_libversion(void);
- SQLITE_API const char *sqlite3_sourceid(void);
- SQLITE_API int sqlite3_libversion_number(void);
- /*
- ** CAPI3REF: Run-Time Library Compilation Options Diagnostics
- **
- ** ^The sqlite3_compileoption_used() function returns 0 or 1
- ** indicating whether the specified option was defined at
- ** compile time. ^The SQLITE_ prefix may be omitted from the
- ** option name passed to sqlite3_compileoption_used().
- **
- ** ^The sqlite3_compileoption_get() function allows iterating
- ** over the list of options that were defined at compile time by
- ** returning the N-th compile time option string. ^If N is out of range,
- ** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_
- ** prefix is omitted from any strings returned by
- ** sqlite3_compileoption_get().
- **
- ** ^Support for the diagnostic functions sqlite3_compileoption_used()
- ** and sqlite3_compileoption_get() may be omitted by specifying the
- ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
- **
- ** See also: SQL functions [sqlite_compileoption_used()] and
- ** [sqlite_compileoption_get()] and the [compile_options pragma].
- */
- #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
- SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
- SQLITE_API const char *sqlite3_compileoption_get(int N);
- #endif
- /*
- ** CAPI3REF: Test To See If The Library Is Threadsafe
- **
- ** ^The sqlite3_threadsafe() function returns zero if and only if
- ** SQLite was compiled with mutexing code omitted due to the
- ** [SQLITE_THREADSAFE] compile-time option being set to 0.
- **
- ** SQLite can be compiled with or without mutexes. When
- ** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
- ** are enabled and SQLite is threadsafe. When the
- ** [SQLITE_THREADSAFE] macro is 0,
- ** the mutexes are omitted. Without the mutexes, it is not safe
- ** to use SQLite concurrently from more than one thread.
- **
- ** Enabling mutexes incurs a measurable performance penalty.
- ** So if speed is of utmost importance, it makes sense to disable
- ** the mutexes. But for maximum safety, mutexes should be enabled.
- ** ^The default behavior is for mutexes to be enabled.
- **
- ** This interface can be used by an application to make sure that the
- ** version of SQLite that it is linking against was compiled with
- ** the desired setting of the [SQLITE_THREADSAFE] macro.
- **
- ** This interface only reports on the compile-time mutex setting
- ** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with
- ** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
- ** can be fully or partially disabled using a call to [sqlite3_config()]
- ** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],
- ** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the
- ** sqlite3_threadsafe() function shows only the compile-time setting of
- ** thread safety, not any run-time changes to that setting made by
- ** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
- ** is unchanged by calls to sqlite3_config().)^
- **
- ** See the [threading mode] documentation for additional information.
- */
- SQLITE_API int sqlite3_threadsafe(void);
- /*
- ** CAPI3REF: Database Connection Handle
- ** KEYWORDS: {database connection} {database connections}
- **
- ** Each open SQLite database is represented by a pointer to an instance of
- ** the opaque structure named "sqlite3". It is useful to think of an sqlite3
- ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and
- ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
- ** is its destructor. There are many other interfaces (such as
- ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and
- ** [sqlite3_busy_timeout()] to name but three) that are methods on an
- ** sqlite3 object.
- */
- typedef struct sqlite3 sqlite3;
- /*
- ** CAPI3REF: 64-Bit Integer Types
- ** KEYWORDS: sqlite_int64 sqlite_uint64
- **
- ** Because there is no cross-platform way to specify 64-bit integer types
- ** SQLite includes typedefs for 64-bit signed and unsigned integers.
- **
- ** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.
- ** The sqlite_int64 and sqlite_uint64 types are supported for backwards
- ** compatibility only.
- **
- ** ^The sqlite3_int64 and sqlite_int64 types can store integer values
- ** between -9223372036854775808 and +9223372036854775807 inclusive. ^The
- ** sqlite3_uint64 and sqlite_uint64 types can store integer values
- ** between 0 and +18446744073709551615 inclusive.
- */
- #ifdef SQLITE_INT64_TYPE
- typedef SQLITE_INT64_TYPE sqlite_int64;
- typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
- #elif defined(_MSC_VER) || defined(__BORLANDC__)
- typedef __int64 sqlite_int64;
- typedef unsigned __int64 sqlite_uint64;
- #else
- typedef long long int sqlite_int64;
- typedef unsigned long long int sqlite_uint64;
- #endif
- typedef sqlite_int64 sqlite3_int64;
- typedef sqlite_uint64 sqlite3_uint64;
- /*
- ** If compiling for a processor that lacks floating point support,
- ** substitute integer for floating-point.
- */
- #ifdef SQLITE_OMIT_FLOATING_POINT
- # define double sqlite3_int64
- #endif
- /*
- ** CAPI3REF: Closing A Database Connection
- **
- ** ^The sqlite3_close() routine is the destructor for the [sqlite3] object.
- ** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is
- ** successfully destroyed and all associated resources are deallocated.
- **
- ** Applications must [sqlite3_finalize | finalize] all [prepared statements]
- ** and [sqlite3_blob_close | close] all [BLOB handles] associated with
- ** the [sqlite3] object prior to attempting to close the object. ^If
- ** sqlite3_close() is called on a [database connection] that still has
- ** outstanding [prepared statements] or [BLOB handles], then it returns
- ** SQLITE_BUSY.
- **
- ** ^If [sqlite3_close()] is invoked while a transaction is open,
- ** the transaction is automatically rolled back.
- **
- ** The C parameter to [sqlite3_close(C)] must be either a NULL
- ** pointer or an [sqlite3] object pointer obtained
- ** from [sqlite3_open()], [sqlite3_open16()], or
- ** [sqlite3_open_v2()], and not previously closed.
- ** ^Calling sqlite3_close() with a NULL pointer argument is a
- ** harmless no-op.
- */
- SQLITE_API int sqlite3_close(sqlite3 *);
- /*
- ** The type for a callback function.
- ** This is legacy and deprecated. It is included for historical
- ** compatibility and is not documented.
- */
- typedef int (*sqlite3_callback)(void*,int,char**, char**);
- /*
- ** CAPI3REF: One-Step Query Execution Interface
- **
- ** The sqlite3_exec() interface is a convenience wrapper around
- ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
- ** that allows an application to run multiple statements of SQL
- ** without having to use a lot of C code.
- **
- ** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
- ** semicolon-separate SQL statements passed into its 2nd argument,
- ** in the context of the [database connection] passed in as its 1st
- ** argument. ^If the callback function of the 3rd argument to
- ** sqlite3_exec() is not NULL, then it is invoked for each result row
- ** coming out of the evaluated SQL statements. ^The 4th argument to
- ** sqlite3_exec() is relayed through to the 1st argument of each
- ** callback invocation. ^If the callback pointer to sqlite3_exec()
- ** is NULL, then no callback is ever invoked and result rows are
- ** ignored.
- **
- ** ^If an error occurs while evaluating the SQL statements passed into
- ** sqlite3_exec(), then execution of the current statement stops and
- ** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec()
- ** is not NULL then any error message is written into memory obtained
- ** from [sqlite3_malloc()] and passed back through the 5th parameter.
- ** To avoid memory leaks, the application should invoke [sqlite3_free()]
- ** on error message strings returned through the 5th parameter of
- ** of sqlite3_exec() after the error message string is no longer needed.
- ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
- ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
- ** NULL before returning.
- **
- ** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
- ** routine returns SQLITE_ABORT without invoking the callback again and
- ** without running any subsequent SQL statements.
- **
- ** ^The 2nd argument to the sqlite3_exec() callback function is the
- ** number of columns in the result. ^The 3rd argument to the sqlite3_exec()
- ** callback is an array of pointers to strings obtained as if from
- ** [sqlite3_column_text()], one for each column. ^If an element of a
- ** result row is NULL then the corresponding string pointer for the
- ** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the
- ** sqlite3_exec() callback is an array of pointers to strings where each
- ** entry represents the name of corresponding result column as obtained
- ** from [sqlite3_column_name()].
- **
- ** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer
- ** to an empty string, or a pointer that contains only whitespace and/or
- ** SQL comments, then no SQL statements are evaluated and the database
- ** is not changed.
- **
- ** Restrictions:
- **
- ** <ul>
- ** <li> The application must insure that the 1st parameter to sqlite3_exec()
- ** is a valid and open [database connection].
- ** <li> The application must not close [database connection] specified by
- ** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
- ** <li> The application must not modify the SQL statement text passed into
- ** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
- ** </ul>
- */
- SQLITE_API int sqlite3_exec(
- sqlite3*, /* An open database */
- const char *sql, /* SQL to be evaluated */
- int (*callback)(void*,int,char**,char**), /* Callback function */
- void *, /* 1st argument to callback */
- char **errmsg /* Error msg written here */
- );
- /*
- ** CAPI3REF: Result Codes
- ** KEYWORDS: SQLITE_OK {error code} {error codes}
- ** KEYWORDS: {result code} {result codes}
- **
- ** Many SQLite functions return an integer result code from the set shown
- ** here in order to indicate success or failure.
- **
- ** New error codes may be added in future versions of SQLite.
- **
- ** See also: [SQLITE_IOERR_READ | extended result codes],
- ** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | result codes].
- */
- #define SQLITE_OK 0 /* Successful result */
- /* beginning-of-error-codes */
- #define SQLITE_ERROR 1 /* SQL error or missing database */
- #define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */
- #define SQLITE_PERM 3 /* Access permission denied */
- #define SQLITE_ABORT 4 /* Callback routine requested an abort */
- #define SQLITE_BUSY 5 /* The database file is locked */
- #define SQLITE_LOCKED 6 /* A table in the database is locked */
- #define SQLITE_NOMEM 7 /* A malloc() failed */
- #define SQLITE_READONLY 8 /* Attempt to write a readonly database */
- #define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/
- #define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */
- #define SQLITE_CORRUPT 11 /* The database disk image is malformed */
- #define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */
- #define SQLITE_FULL 13 /* Insertion failed because database is full */
- #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
- #define SQLITE_PROTOCOL 15 /* Database lock protocol error */
- #define SQLITE_EMPTY 16 /* Database is empty */
- #define SQLITE_SCHEMA 17 /* The database schema changed */
- #define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */
- #define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */
- #define SQLITE_MISMATCH 20 /* Data type mismatch */
- #define SQLITE_MISUSE 21 /* Library used incorrectly */
- #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
- #define SQLITE_AUTH 23 /* Authorization denied */
- #define SQLITE_FORMAT 24 /* Auxiliary database format error */
- #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
- #define SQLITE_NOTADB 26 /* File opened that is not a database file */
- #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */
- #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */
- /* end-of-error-codes */
- /*
- ** CAPI3REF: Extended Result Codes
- ** KEYWORDS: {extended error code} {extended error codes}
- ** KEYWORDS: {extended result code} {extended result codes}
- **
- ** In its default configuration, SQLite API routines return one of 26 integer
- ** [SQLITE_OK | result codes]. However, experience has shown that many of
- ** these result codes are too coarse-grained. They do not provide as
- ** much information about problems as programmers might like. In an effort to
- ** address this, newer versions of SQLite (version 3.3.8 and later) include
- ** support for additional result codes that provide more detailed information
- ** about errors. The extended result codes are enabled or disabled
- ** on a per database connection basis using the
- ** [sqlite3_extended_result_codes()] API.
- **
- ** Some of the available extended result codes are listed here.
- ** One may expect the number of extended result codes will be expand
- ** over time. Software that uses extended result codes should expect
- ** to see new result codes in future releases of SQLite.
- **
- ** The SQLITE_OK result code will never be extended. It will always
- ** be exactly zero.
- */
- #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))
- #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))
- #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))
- #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))
- #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))
- #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))
- #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))
- #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))
- #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))
- #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))
- #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))
- #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))
- #define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))
- #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
- #define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))
- #define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))
- #define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))
- #define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))
- #define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))
- #define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))
- #define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))
- #define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))
- #define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))
- #define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))
- #define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))
- #define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))
- #define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))
- #define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))
- /*
- ** CAPI3REF: Flags For File Open Operations
- **
- ** These bit values are intended for use in the
- ** 3rd parameter to the [sqlite3_open_v2()] interface and
- ** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
- */
- #define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */
- #define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */
- #define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */
- #define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */
- #define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */
- #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */
- #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */
- #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */
- #define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */
- #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
- #define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
- #define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
- /* Reserved: 0x00F00000 */
- /*
- ** CAPI3REF: Device Characteristics
- **
- ** The xDeviceCharacteristics method of the [sqlite3_io_methods]
- ** object returns an integer which is a vector of the these
- ** bit values expressing I/O characteristics of the mass storage
- ** device that holds the file that the [sqlite3_io_methods]
- ** refers to.
- **
- ** The SQLITE_IOCAP_ATOMIC property means that all writes of
- ** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values
- ** mean that writes of blocks that are nnn bytes in size and
- ** are aligned to an address which is an integer multiple of
- ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
- ** that when data is appended to a file, the data is appended
- ** first then the size of the file is extended, never the other
- ** way around. The SQLITE_IOCAP_SEQUENTIAL property means that
- ** information is written to disk in the same order as calls
- ** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that
- ** after reboot following a crash or power loss, the only bytes in a
- ** file that were written at the application level might have changed
- ** and that adjacent bytes, even bytes within the same sector are
- ** guaranteed to be unchanged.
- */
- #define SQLITE_IOCAP_ATOMIC 0x00000001
- #define SQLITE_IOCAP_ATOMIC512 0x00000002
- #define SQLITE_IOCAP_ATOMIC1K 0x00000004
- #define SQLITE_IOCAP_ATOMIC2K 0x00000008
- #define SQLITE_IOCAP_ATOMIC4K 0x00000010
- #define SQLITE_IOCAP_ATOMIC8K 0x00000020
- #define SQLITE_IOCAP_ATOMIC16K 0x00000040
- #define SQLITE_IOCAP_ATOMIC32K 0x00000080
- #define SQLITE_IOCAP_ATOMIC64K 0x00000100
- #define SQLITE_IOCAP_SAFE_APPEND 0x00000200
- #define SQLITE_IOCAP_SEQUENTIAL 0x00000400
- #define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800
- #define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000
- /*
- ** CAPI3REF: File Locking Levels
- **
- ** SQLite uses one of these integer values as the second
- ** argument to calls it makes to the xLock() and xUnlock() methods
- ** of an [sqlite3_io_methods] object.
- */
- #define SQLITE_LOCK_NONE 0
- #define SQLITE_LOCK_SHARED 1
- #define SQLITE_LOCK_RESERVED 2
- #define SQLITE_LOCK_PENDING 3
- #define SQLITE_LOCK_EXCLUSIVE 4
- /*
- ** CAPI3REF: Synchronization Type Flags
- **
- ** When SQLite invokes the xSync() method of an
- ** [sqlite3_io_methods] object it uses a combination of
- ** these integer values as the second argument.
- **
- ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
- ** sync operation only needs to flush data to mass storage. Inode
- ** information need not be flushed. If the lower four bits of the flag
- ** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.
- ** If the lower four bits equal SQLITE_SYNC_FULL, that means
- ** to use Mac OS X style fullsync instead of fsync().
- **
- ** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
- ** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL
- ** settings. The [synchronous pragma] determines when calls to the
- ** xSync VFS method occur and applies uniformly across all platforms.
- ** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how
- ** energetic or rigorous or forceful the sync operations are and
- ** only make a difference on Mac OSX for the default SQLite code.
- ** (Third-party VFS implementations might also make the distinction
- ** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the
- ** operating systems natively supported by SQLite, only Mac OSX
- ** cares about the difference.)
- */
- #define SQLITE_SYNC_NORMAL 0x00002
- #define SQLITE_SYNC_FULL 0x00003
- #define SQLITE_SYNC_DATAONLY 0x00010
- /*
- ** CAPI3REF: OS Interface Open File Handle
- **
- ** An [sqlite3_file] object represents an open file in the
- ** [sqlite3_vfs | OS interface layer]. Individual OS interface
- ** implementations will
- ** want to subclass this object by appending additional fields
- ** for their own use. The pMethods entry is a pointer to an
- ** [sqlite3_io_methods] object that defines methods for performing
- ** I/O operations on the open file.
- */
- typedef struct sqlite3_file sqlite3_file;
- struct sqlite3_file {
- const struct sqlite3_io_methods *pMethods; /* Methods for an open file */
- };
- /*
- ** CAPI3REF: OS Interface File Virtual Methods Object
- **
- ** Every file opened by the [sqlite3_vfs.xOpen] method populates an
- ** [sqlite3_file] object (or, more commonly, a subclass of the
- ** [sqlite3_file] object) with a pointer to an instance of this object.
- ** This object defines the methods used to perform various operations
- ** against the open file represented by the [sqlite3_file] object.
- **
- ** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element
- ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
- ** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The
- ** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen]
- ** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element
- ** to NULL.
- **
- ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
- ** [SQLITE_SYNC_FULL]. The first choice is the normal fsync().
- ** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY]
- ** flag may be ORed in to indicate that only the data of the file
- ** and not its inode needs to be synced.
- **
- ** The integer values to xLock() and xUnlock() are one of
- ** <ul>
- ** <li> [SQLITE_LOCK_NONE],
- ** <li> [SQLITE_LOCK_SHARED],
- ** <li> [SQLITE_LOCK_RESERVED],
- ** <li> [SQLITE_LOCK_PENDING], or
- ** <li> [SQLITE_LOCK_EXCLUSIVE].
- ** </ul>
- ** xLock() increases the lock. xUnlock() decreases the lock.
- ** The xCheckReservedLock() method checks whether any database connection,
- ** either in this process or in some other process, is holding a RESERVED,
- ** PENDING, or EXCLUSIVE lock on the file. It returns true
- ** if such a lock exists and false otherwise.
- **
- ** The xFileControl() method is a generic interface that allows custom
- ** VFS implementations to directly control an open file using the
- ** [sqlite3_file_control()] interface. The second "op" argument is an
- ** integer opcode. The third argument is a generic pointer intended to
- ** point to a structure that may contain arguments or space in which to
- ** write return values. Potential uses for xFileControl() might be
- ** functions to enable blocking locks with timeouts, to change the
- ** locking strategy (for example to use dot-file locks), to inquire
- ** about the status of a lock, or to break stale locks. The SQLite
- ** core reserves all opcodes less than 100 for its own use.
- ** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
- ** Applications that define a custom xFileControl method should use opcodes
- ** greater than 100 to avoid conflicts. VFS implementations should
- ** return [SQLITE_NOTFOUND] for file control opcodes that they do not
- ** recognize.
- **
- ** The xSectorSize() method returns the sector size of the
- ** device that underlies the file. The sector size is the
- ** minimum write that can be performed without disturbing
- ** other bytes in the file. The xDeviceCharacteristics()
- ** method returns a bit vector describing behaviors of the
- ** underlying device:
- **
- ** <ul>
- ** <li> [SQLITE_IOCAP_ATOMIC]
- ** <li> [SQLITE_IOCAP_ATOMIC512]
- ** <li> [SQLITE_IOCAP_ATOMIC1K]
- ** <li> [SQLITE_IOCAP_ATOMIC2K]
- ** <li> [SQLITE_IOCAP_ATOMIC4K]
- ** <li> [SQLITE_IOCAP_ATOMIC8K]
- ** <li> [SQLITE_IOCAP_ATOMIC16K]
- ** <li> [SQLITE_IOCAP_ATOMIC32K]
- ** <li> [SQLITE_IOCAP_ATOMIC64K]
- ** <li> [SQLITE_IOCAP_SAFE_APPEND]
- ** <li> [SQLITE_IOCAP_SEQUENTIAL]
- ** </ul>
- **
- ** The SQLITE_IOCAP_ATOMIC property means that all writes of
- ** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values
- ** mean that writes of blocks that are nnn bytes in size and
- ** are aligned to an address which is an integer multiple of
- ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
- ** that when data is appended to a file, the data is appended
- ** first then the size of the file is extended, never the other
- ** way around. The SQLITE_IOCAP_SEQUENTIAL property means that
- ** information is written to disk in the same order as calls
- ** to xWrite().
- **
- ** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
- ** in the unread portions of the buffer with zeros. A VFS that
- ** fails to zero-fill short reads might seem to work. However,
- ** failure to zero-fill short reads will eventually lead to
- ** database corruption.
- */
- typedef struct sqlite3_io_methods sqlite3_io_methods;
- struct sqlite3_io_methods {
- int iVersion;
- int (*xClose)(sqlite3_file*);
- int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
- int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
- int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
- int (*xSync)(sqlite3_file*, int flags);
- int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
- int (*xLock)(sqlite3_file*, int);
- int (*xUnlock)(sqlite3_file*, int);
- int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);
- int (*xFileControl)(sqlite3_file*, int op, void *pArg);
- int (*xSectorSize)(sqlite3_file*);
- int (*xDeviceCharacteristics)(sqlite3_file*);
- /* Methods above are valid for version 1 */
- int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
- int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
- void (*xShmBarrier)(sqlite3_file*);
- int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
- /* Methods above are valid for version 2 */
- /* Additional methods may be added in future releases */
- };
- /*
- ** CAPI3REF: Standard File Control Opcodes
- **
- ** These integer constants are opcodes for the xFileControl method
- ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
- ** interface.
- **
- ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This
- ** opcode causes the xFileControl method to write the current state of
- ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
- ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
- ** into an integer that the pArg argument points to. This capability
- ** is used during testing and only needs to be supported when SQLITE_TEST
- ** is defined.
- **
- ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
- ** layer a hint of how large the database file will grow to be during the
- ** current transaction. This hint is not guaranteed to be accurate but it
- ** is often close. The underlying VFS might choose to preallocate database
- ** file space based on this hint in order to help writes to the database
- ** file run faster.
- **
- ** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
- ** extends and truncates the database file in chunks of a size specified
- ** by the user. The fourth argument to [sqlite3_file_control()] should
- ** point to an integer (type int) containing the new chunk-size to use
- ** for the nominated database. Allocating database file space in large
- ** chunks (say 1MB at a time), may reduce file-system fragmentation and
- ** improve performance on some systems.
- **
- ** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
- ** to the [sqlite3_file] object associated with a particular database
- ** connection. See the [sqlite3_file_control()] documentation for
- ** additional information.
- **
- ** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by
- ** SQLite and sent to all VFSes in place of a call to the xSync method
- ** when the database connection has [PRAGMA synchronous] set to OFF.)^
- ** Some specialized VFSes need this signal in order to operate correctly
- ** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most
- ** VFSes do not need this signal and should silently ignore this opcode.
- ** Applications should not call [sqlite3_file_control()] with this
- ** opcode as doing so may disrupt the operation of the specialized VFSes
- ** that do require it.
- **
- ** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic
- ** retry counts and intervals for certain disk I/O operations for the
- ** windows [VFS] in order to provide robustness in the presence of
- ** anti-virus programs. By default, the windows VFS will retry file read,
- ** file write, and file delete operations up to 10 times, with a delay
- ** of 25 milliseconds before the first retry and with the delay increasing
- ** by an additional 25 milliseconds with each subsequent retry. This
- ** opcode allows these two values (10 retries and 25 milliseconds of delay)
- ** to be adjusted. The values are changed for all database connections
- ** within the same process. The argument is a pointer to an array of two
- ** integers where the first integer i the new retry count and the second
- ** integer is the delay. If either integer is negative, then the setting
- ** is not changed but instead the prior value of that setting is written
- ** into the array entry, allowing the current retry settings to be
- ** interrogated. The zDbName parameter is ignored.
- **
- ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
- ** persistent [WAL | Write AHead Log] setting. By default, the auxiliary
- ** write ahead log and shared memory files used for transaction control
- ** are automatically deleted when the latest connection to the database
- ** closes. Setting persistent WAL mode causes those files to persist after
- ** close. Persisting the files is useful when other processes that do not
- ** have write permission on the directory containing the database file want
- ** to read the database file, as the WAL and shared memory files must exist
- ** in order for the database to be readable. The fourth parameter to
- ** [sqlite3_file_control()] for this opcode should be a pointer to an integer.
- ** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
- ** WAL mode. If the integer is -1, then it is overwritten with the current
- ** WAL persistence setting.
- **
- ** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the
- ** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting
- ** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the
- ** xDeviceCharacteristics methods. The fourth parameter to
- ** [sqlite3_file_control()] for this opcode should be a pointer to an integer.
- ** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
- ** mode. If the integer is -1, then it is overwritten with the current
- ** zero-damage mode setting.
- **
- ** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening
- ** a write transaction to indicate that, unless it is rolled back for some
- ** reason, the entire database file will be overwritten by the current
- ** transaction. This is used by VACUUM operations.
- **
- ** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
- ** all [VFSes] in the VFS stack. The names are of all VFS shims and the
- ** final bottom-level VFS are written into memory obtained from
- ** [sqlite3_malloc()] and the result is stored in the char* variable
- ** that the fourth parameter of [sqlite3_file_control()] points to.
- ** The caller is responsible for freeing the memory when done. As with
- ** all file-control actions, there is no guarantee that this will actually
- ** do anything. Callers should initialize the char* variable to a NULL
- ** pointer in case this file-control is not implemented. This file-control
- ** is intended for diagnostic use only.
- */
- #define SQLITE_FCNTL_LOCKSTATE 1
- #define SQLITE_GET_LOCKPROXYFILE 2
- #define SQLITE_SET_LOCKPROXYFILE 3
- #define SQLITE_LAST_ERRNO 4
- #define SQLITE_FCNTL_SIZE_HINT 5
- #define SQLITE_FCNTL_CHUNK_SIZE 6
- #define SQLITE_FCNTL_FILE_POINTER 7
- #define SQLITE_FCNTL_SYNC_OMITTED 8
- #define SQLITE_FCNTL_WIN32_AV_RETRY 9
- #define SQLITE_FCNTL_PERSIST_WAL 10
- #define SQLITE_FCNTL_OVERWRITE 11
- #define SQLITE_FCNTL_VFSNAME 12
- #define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13
- /*
- ** CAPI3REF: Mutex Handle
- **
- ** The mutex module within SQLite defines [sqlite3_mutex] to be an
- ** abstract type for a mutex object. The SQLite core never looks
- ** at the internal representation of an [sqlite3_mutex]. It only
- ** deals with pointers to the [sqlite3_mutex] object.
- **
- ** Mutexes are created using [sqlite3_mutex_alloc()].
- */
- typedef struct sqlite3_mutex sqlite3_mutex;
- /*
- ** CAPI3REF: OS Interface Object
- **
- ** An instance of the sqlite3_vfs object defines the interface between
- ** the SQLite core and the underlying operating system. The "vfs"
- ** in the name of the object stands for "virtual file system". See
- ** the [VFS | VFS documentation] for further information.
- **
- ** The value of the iVersion field is initially 1 but may be larger in
- ** future versions of SQLite. Additional fields may be appended to this
- ** object when the iVersion value is increased. Note that the structure
- ** of the sqlite3_vfs object changes in the transaction between
- ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
- ** modified.
- **
- ** The szOsFile field is the size of the subclassed [sqlite3_file]
- ** structure used by this VFS. mxPathname is the maximum length of
- ** a pathname in this VFS.
- **
- ** Registered sqlite3_vfs objects are kept on a linked list formed by
- ** the pNext pointer. The [sqlite3_vfs_register()]
- ** and [sqlite3_vfs_unregister()] interfaces manage this list
- ** in a thread-safe way. The [sqlite3_vfs_find()] interface
- ** searches the list. Neither the application code nor the VFS
- ** implementation should use the pNext pointer.
- **
- ** The pNext field is the only field in the sqlite3_vfs
- ** structure that SQLite will ever modify. SQLite will only access
- ** or modify this field while holding a particular static mutex.
- ** The application should never modify anything within the sqlite3_vfs
- ** object once the object has been registered.
- **
- ** The zName field holds the name of the VFS module. The name must
- ** be unique across all VFS modules.
- **
- ** [[sqlite3_vfs.xOpen]]
- ** ^SQLite guarantees that the zFilename parameter to xOpen
- ** is either a NULL pointer or string obtained
- ** from xFullPathname() with an optional suffix added.
- ** ^If a suffix is added to the zFilename parameter, it will
- ** consist of a single "-" character followed by no more than
- ** 11 alphanumeric and/or "-" characters.
- ** ^SQLite further guarantees that
- ** the string will be valid and unchanged until xClose() is
- ** called. Because of the previous sentence,
- ** the [sqlite3_file] can safely store a pointer to the
- ** filename if it needs to remember the filename for some reason.
- ** If the zFilename parameter to xOpen is a NULL pointer then xOpen
- ** must invent its own temporary name for the file. ^Whenever the
- ** xFilename parameter is NULL it will also be the case that the
- ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
- **
- ** The flags argument to xOpen() includes all bits set in
- ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]
- ** or [sqlite3_open16()] is used, then flags includes at least
- ** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
- ** If xOpen() opens a file read-only then it sets *pOutFlags to
- ** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set.
- **
- ** ^(SQLite will also add one of the following flags to the xOpen()
- ** call, depending on the object being opened:
- **
- ** <ul>
- ** <li> [SQLITE_OPEN_MAIN_DB]
- ** <li> [SQLITE_OPEN_MAIN_JOURNAL]
- ** <li> [SQLITE_OPEN_TEMP_DB]
- ** <li> [SQLITE_OPEN_TEMP_JOURNAL]
- ** <li> [SQLITE_OPEN_TRANSIENT_DB]
- ** <li> [SQLITE_OPEN_SUBJOURNAL]
- ** <li> [SQLITE_OPEN_MASTER_JOURNAL]
- ** <li> [SQLITE_OPEN_WAL]
- ** </ul>)^
- **
- ** The file I/O implementation can use the object type flags to
- ** change the way it deals with files. For example, an application
- ** that does not care about crash recovery or rollback might make
- ** the open of a journal file a no-op. Writes to this journal would
- ** also be no-ops, and any attempt to read the journal would return
- ** SQLITE_IOERR. Or the implementation might recognize that a database
- ** file will be doing page-aligned sector reads and writes in a random
- ** order and set up its I/O subsystem accordingly.
- **
- ** SQLite might also add one of the following flags to the xOpen method:
- **
- ** <ul>
- ** <li> [SQLITE_OPEN_DELETEONCLOSE]
- ** <li> [SQLITE_OPEN_EXCLUSIVE]
- ** </ul>
- **
- ** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
- ** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE]
- ** will be set for TEMP databases and their journals, transient
- ** databases, and subjournals.
- **
- ** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
- ** with the [SQLITE_OPEN_CREATE] flag, which are both directly
- ** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
- ** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
- ** SQLITE_OPEN_CREATE, is used to indicate that file should always
- ** be created, and that it is an error if it already exists.
- ** It is <i>not</i> used to indicate the file should be opened
- ** for exclusive access.
- **
- ** ^At least szOsFile bytes of memory are allocated by SQLite
- ** to hold the [sqlite3_file] structure passed as the third
- ** argument to xOpen. The xOpen method does not have to
- ** allocate the structure; it should just fill it in. Note that
- ** the xOpen method must set the sqlite3_file.pMethods to either
- ** a valid [sqlite3_io_methods] object or to NULL. xOpen must do
- ** this even if the open fails. SQLite expects that the sqlite3_file.pMethods
- ** element will be valid after xOpen returns regardless of the success
- ** or failure of the xOpen call.
- **
- ** [[sqlite3_vfs.xAccess]]
- ** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
- ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
- ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
- ** to test whether a file is at least readable. The file can be a
- ** directory.
- **
- ** ^SQLite will always allocate at least mxPathname+1 bytes for the
- ** output buffer xFullPathname. The exact size of the output buffer
- ** is also passed as a parameter to both methods. If the output buffer
- ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
- ** handled as a fatal error by SQLite, vfs implementations should endeavor
- ** to prevent this by setting mxPathname to a sufficiently large value.
- **
- ** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()
- ** interfaces are not strictly a part of the filesystem, but they are
- ** included in the VFS structure for completeness.
- ** The xRandomness() function attempts to return nBytes bytes
- ** of good-quality randomness into zOut. The return value is
- ** the actual number of bytes of randomness obtained.
- ** The xSleep() method causes the calling thread to sleep for at
- ** least the number of microseconds given. ^The xCurrentTime()
- ** method returns a Julian Day Number for the current date and time as
- ** a floating point value.
- ** ^The xCurrentTimeInt64() method returns, as an integer, the Julian
- ** Day Number multiplied by 86400000 (the number of milliseconds in
- ** a 24-hour day).
- ** ^SQLite will use the xCurrentTimeInt64() method to get the current
- ** date and time if that method is available (if iVersion is 2 or
- ** greater and the function pointer is not NULL) and will fall back
- ** to xCurrentTime() if xCurrentTimeInt64() is unavailable.
- **
- ** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces
- ** are not used by the SQLite core. These optional interfaces are provided
- ** by some VFSes to facilitate testing of the VFS code. By overriding
- ** system calls with functions under its control, a test program can
- ** simulate faults and error conditions that would otherwise be difficult
- ** or impossible to induce. The set of system calls that can be overridden
- ** varies from one VFS to another, and from one version of the same VFS to the
- ** next. Applications that use these interfaces must be prepared for any
- ** or all of these interfaces to be NULL or for their behavior to change
- ** from one release to the next. Applications must not attempt to access
- ** any of these methods if the iVersion of the VFS is less than 3.
- */
- typedef struct sqlite3_vfs sqlite3_vfs;
- typedef void (*sqlite3_syscall_ptr)(void);
- struct sqlite3_vfs {
- int iVersion; /* Structure version number (currently 3) */
- int szOsFile; /* Size of subclassed sqlite3_file */
- int mxPathname; /* Maximum file pathname length */
- sqlite3_vfs *pNext; /* Next registered VFS */
- const char *zName; /* Name of this virtual file system */
- void *pAppData; /* Pointer to application-specific data */
- int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
- int flags, int *pOutFlags);
- int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
- int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
- int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
- void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
- void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
- void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
- void (*xDlClose)(sqlite3_vfs*, void*);
- int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
- int (*xSleep)(sqlite3_vfs*, int microseconds);
- int (*xCurrentTime)(sqlite3_vfs*, double*);
- int (*xGetLastError)(sqlite3_vfs*, int, char *);
- /*
- ** The methods above are in version 1 of the sqlite_vfs object
- ** definition. Those that follow are added in version 2 or later
- */
- int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
- /*
- ** The methods above are in versions 1 and 2 of the sqlite_vfs object.
- ** Those below are for version 3 and greater.
- */
- int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
- sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
- const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
- /*
- ** The methods above are in versions 1 through 3 of the sqlite_vfs object.
- ** New fields may be appended in figure versions. The iVersion
- ** value will increment whenever this happens.
- */
- };
- /*
- ** CAPI3REF: Flags for the xAccess VFS method
- **
- ** These integer constants can be used as the third parameter to
- ** the xAccess method of an [sqlite3_vfs] object. They determine
- ** what kind of permissions the xAccess method is looking for.
- ** With SQLITE_ACCESS_EXISTS, the xAccess method
- ** simply checks whether the file exists.
- ** With SQLITE_ACCESS_READWRITE, the xAccess method
- ** checks whether the named directory is both readable and writable
- ** (in other words, if files can be added, removed, and renamed within
- ** the directory).
- ** The SQLITE_ACCESS_READWRITE constant is currently used only by the
- ** [temp_store_directory pragma], though this could change in a future
- ** release of SQLite.
- ** With SQLITE_ACCESS_READ, the xAccess method
- ** checks whether the file is readable. The SQLITE_ACCESS_READ constant is
- ** currently unused, though it might be used in a future release of
- ** SQLite.
- */
- #define SQLITE_ACCESS_EXISTS 0
- #define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
- #define SQLITE_ACCESS_READ 2 /* Unused */
- /*
- ** CAPI3REF: Flags for the xShmLock VFS method
- **
- ** These integer constants define the various locking operations
- ** allowed by the xShmLock method of [sqlite3_io_methods]. The
- ** following are the only legal combinations of flags to the
- ** xShmLock method:
- **
- ** <ul>
- ** <li> SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
- ** <li> SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
- ** <li> SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
- ** <li> SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE
- ** </ul>
- **
- ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
- ** was given no the corresponding lock.
- **
- ** The xShmLock method can transition between unlocked and SHARED or
- ** between unlocked and EXCLUSIVE. It cannot transition between SHARED
- ** and EXCLUSIVE.
- */
- #define SQLITE_SHM_UNLOCK 1
- #define SQLITE_SHM_LOCK 2
- #define SQLITE_SHM_SHARED 4
- #define SQLITE_SHM_EXCLUSIVE 8
- /*
- ** CAPI3REF: Maximum xShmLock index
- **
- ** The xShmLock method on [sqlite3_io_methods] may use values
- ** between 0 and this upper bound as its "offset" argument.
- ** The SQLite core will never attempt to acquire or release a
- ** lock outside of this range
- */
- #define SQLITE_SHM_NLOCK 8
- /*
- ** CAPI3REF: Initialize The SQLite Library
- **
- ** ^The sqlite3_initialize() routine initializes the
- ** SQLite library. ^The sqlite3_shutdown() routine
- ** deallocates any resources that were allocated by sqlite3_initialize().
- ** These routines are designed to aid in process initialization and
- ** shutdown on embedded systems. Workstation applications using
- ** SQLite normally do not need to invoke either of these routines.
- **
- ** A call to sqlite3_initialize() is an "effective" call if it is
- ** the first time sqlite3_initialize() is invoked during the lifetime of
- ** the process, or if it is the first time sqlite3_initialize() is invoked
- ** following a call to sqlite3_shutdown(). ^(Only an effective call
- ** of sqlite3_initialize() does any initialization. All other calls
- ** are harmless no-ops.)^
- **
- ** A call to sqlite3_shutdown() is an "effective" call if it is the first
- ** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only
- ** an effective call to sqlite3_shutdown() does any deinitialization.
- ** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
- **
- ** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown()
- ** is not. The sqlite3_shutdown() interface must only be called from a
- ** single thread. All open [database connections] must be closed and all
- ** other SQLite resources must be deallocated prior to invoking
- ** sqlite3_shutdown().
- **
- ** Among other things, ^sqlite3_initialize() will invoke
- ** sqlite3_os_init(). Similarly, ^sqlite3_shutdown()
- ** will invoke sqlite3_os_end().
- **
- ** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
- ** ^If for some reason, sqlite3_initialize() is unable to initialize
- ** the library (perhaps it is unable to allocate a needed resource such
- ** as a mutex) it returns an [error code] other than [SQLITE_OK].
- **
- ** ^The sqlite3_initialize() routine is called internally by many other
- ** SQLite interfaces so that an application usually does not need to
- ** invoke sqlite3_initialize() directly. For example, [sqlite3_open()]
- ** calls sqlite3_initialize() so the SQLite library will be automatically
- ** initialized when [sqlite3_open()] is called if it has not be initialized
- ** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]
- ** compile-time option, then the automatic calls to sqlite3_initialize()
- ** are omitted and the application must call sqlite3_initialize() directly
- ** prior to using any other SQLite interface. For maximum portability,
- ** it is recommended that applications always invoke sqlite3_initialize()
- ** directly prior to using any other SQLite interface. Future releases
- ** of SQLite may require this. In other words, the behavior exhibited
- ** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the
- ** default behavior in some future release of SQLite.
- **
- ** The sqlite3_os_init() routine does operating-system specific
- ** initialization of the SQLite library. The sqlite3_os_end()
- ** routine undoes the effect of sqlite3_os_init(). Typical tasks
- ** performed by these routines include allocation or deallocation
- ** of static resources, initialization of global variables,
- ** setting up a default [sqlite3_vfs] module, or setting up
- ** a default configuration using [sqlite3_config()].
- **
- ** The application should never invoke either sqlite3_os_init()
- ** or sqlite3_os_end() directly. The application should only invoke
- ** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init()
- ** interface is called automatically by sqlite3_initialize() and
- ** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate
- ** implementations for sqlite3_os_init() and sqlite3_os_end()
- ** are built into SQLite when it is compiled for Unix, Windows, or OS/2.
- ** When [custom builds | built for other platforms]
- ** (using the [SQLITE_OS_OTHER=1] compile-time
- ** option) the application must supply a suitable implementation for
- ** sqlite3_os_init() and sqlite3_os_end(). An application-supplied
- ** implementation of sqlite3_os_init() or sqlite3_os_end()
- ** must return [SQLITE_OK] on success and some other [error code] upon
- ** failure.
- */
- SQLITE_API int sqlite3_initialize(void);
- SQLITE_API int sqlite3_shutdown(void);
- SQLITE_API int sqlite3_os_init(void);
- SQLITE_API int sqlite3_os_end(void);
- /*
- ** CAPI3REF: Configuring The SQLite Library
- **
- ** The sqlite3_config() interface is used to make global configuration
- ** changes to SQLite in order to tune SQLite to the specific needs of
- ** the application. The default configuration is recommended for most
- ** applications and so this routine is usually not necessary. It is
- ** provided to support rare applications with unusual needs.
- **
- ** The sqlite3_config() interface is not threadsafe. The application
- ** must insure that no other SQLite interfaces are invoked by other
- ** threads while sqlite3_config() is running. Furthermore, sqlite3_config()
- ** may only be invoked prior to library initialization using
- ** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].
- ** ^If sqlite3_config() is called after [sqlite3_initialize()] and before
- ** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
- ** Note, however, that ^sqlite3_config() can be called as part of the
- ** implementation of an application-defined [sqlite3_os_init()].
- **
- ** The first argument to sqlite3_config() is an integer
- ** [configuration option] that determines
- ** what property of SQLite is to be configured. Subsequent arguments
- ** vary depending on the [configuration option]
- ** in the first argument.
- **
- ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
- ** ^If the option is unknown or SQLite is unable to set the option
- ** then this routine returns a non-zero [error code].
- */
- SQLITE_API int sqlite3_config(int, ...);
- /*
- ** CAPI3REF: Configure database connections
- **
- ** The sqlite3_db_config() interface is used to make configuration
- ** changes to a [database connection]. The interface is similar to
- ** [sqlite3_config()] except that the changes apply to a single
- ** [database connection] (specified in the first argument).
- **
- ** The second argument to sqlite3_db_config(D,V,...) is the
- ** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
- ** that indicates what aspect of the [database connection] is being configured.
- ** Subsequent arguments vary depending on the configuration verb.
- **
- ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
- ** the call is considered successful.
- */
- SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);
- /*
- ** CAPI3REF: Memory Allocation Routines
- **
- ** An instance of this object defines the interface between SQLite
- ** and low-level memory allocation routines.
- **
- ** This object is used in only one place in the SQLite interface.
- ** A pointer to an instance of this object is the argument to
- ** [sqlite3_config()] when the configuration option is
- ** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].
- ** By creating an instance of this object
- ** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
- ** during configuration, an application can specify an alternative
- ** memory allocation subsystem for SQLite to use for all of its
- ** dynamic memory needs.
- **
- ** Note that SQLite comes with several [built-in memory allocators]
- ** that are perfectly adequate for the overwhelming majority of applications
- ** and that this object is only useful to a tiny minority of applications
- ** with specialized memory allocation requirements. This object is
- ** also used during testing of SQLite in order to specify an alternative
- ** memory allocator that simulates memory out-of-memory conditions in
- ** order to verify that SQLite recovers gracefully from such
- ** conditions.
- **
- ** The xMalloc, xRealloc, and xFree methods must work like the
- ** malloc(), realloc() and free() functions from the standard C library.
- ** ^SQLite guarantees that the second argument to
- ** xRealloc is always a value returned by a prior call to xRoundup.
- **
- ** xSize should return the allocated size of a memory allocation
- ** previously obtained from xMalloc or xRealloc. The allocated size
- ** is always at least as big as the requested size but may be larger.
- **
- ** The xRoundup method returns what would be the allocated size of
- ** a memory allocation given a particular requested size. Most memory
- ** allocators round up memory allocations at least to the next multiple
- ** of 8. Some allocators round up to a larger multiple or to a power of 2.
- ** Every memory allocation request coming in through [sqlite3_malloc()]
- ** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0,
- ** that causes the corresponding memory allocation to fail.
- **
- ** The xInit method initializes the memory allocator. (For example,
- ** it might allocate any require mutexes or initialize internal data
- ** structures. The xShutdown method is invoked (indirectly) by
- ** [sqlite3_shutdown()] and should deallocate any resources acquired
- ** by xInit. The pAppData pointer is used as the only parameter to
- ** xInit and xShutdown.
- **
- ** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes
- ** the xInit method, so the xInit method need not be threadsafe. The
- ** xShutdown method is only called from [sqlite3_shutdown()] so it does
- ** not need to be threadsafe either. For all other methods, SQLite
- ** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
- ** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
- ** it is by default) and so the methods are automatically serialized.
- ** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
- ** methods must be threadsafe or else make their own arrangements for
- ** serialization.
- **
- ** SQLite will never invoke xInit() more than once without an intervening
- ** call to xShutdown().
- */
- typedef struct sqlite3_mem_methods sqlite3_mem_methods;
- struct sqlite3_mem_methods {
- void *(*xMalloc)(int); /* Memory allocation function */
- void (*xFree)(void*); /* Free a prior allocation */
- void *(*xRealloc)(void*,int); /* Resize an allocation */
- int (*xSize)(void*); /* Return the size of an allocation */
- int (*xRoundup)(int); /* Round up request size to allocation size */
- int (*xInit)(void*); /* Initialize the memory allocator */
- void (*xShutdown)(void*); /* Deinitialize the memory allocator */
- void *pAppData; /* Argument to xInit() and xShutdown() */
- };
- /*
- ** CAPI3REF: Configuration Options
- ** KEYWORDS: {configuration option}
- **
- ** These constants are the available integer configuration options that
- ** can be passed as the first argument to the [sqlite3_config()] interface.
- **
- ** New configuration options may be added in future releases of SQLite.
- ** Existing configuration options might be discontinued. Applications
- ** should check the return code from [sqlite3_config()] to make sure that
- ** the call worked. The [sqlite3_config()] interface will return a
- ** non-zero [error code] if a discontinued or unsupported configuration option
- ** is invoked.
- **
- ** <dl>
- ** [[SQLITE_CONFIG_SINGLETHREAD]] <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
- ** <dd>There are no arguments to this option. ^This option sets the
- ** [threading mode] to Single-thread. In other words, it disables
- ** all mutexing and puts SQLite into a mode where it can only be used
- ** by a single thread. ^If SQLite is compiled with
- ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- ** it is not possible to change the [threading mode] from its default
- ** value of Single-thread and so [sqlite3_config()] will return
- ** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD
- ** configuration option.</dd>
- **
- ** [[SQLITE_CONFIG_MULTITHREAD]] <dt>SQLITE_CONFIG_MULTITHREAD</dt>
- ** <dd>There are no arguments to this option. ^This option sets the
- ** [threading mode] to Multi-thread. In other words, it disables
- ** mutexing on [database connection] and [prepared statement] objects.
- ** The application is responsible for serializing access to
- ** [database connections] and [prepared statements]. But other mutexes
- ** are enabled so that SQLite will be safe to use in a multi-threaded
- ** environment as long as no two threads attempt to use the same
- ** [database connection] at the same time. ^If SQLite is compiled with
- ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- ** it is not possible to set the Multi-thread [threading mode] and
- ** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
- ** SQLITE_CONFIG_MULTITHREAD configuration option.</dd>
- **
- ** [[SQLITE_CONFIG_SERIALIZED]] <dt>SQLITE_CONFIG_SERIALIZED</dt>
- ** <dd>There are no arguments to this option. ^This option sets the
- ** [threading mode] to Serialized. In other words, this option enables
- ** all mutexes including the recursive
- ** mutexes on [database connection] and [prepared statement] objects.
- ** In this mode (which is the default when SQLite is compiled with
- ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
- ** to [database connections] and [prepared statements] so that the
- ** application is free to use the same [database connection] or the
- ** same [prepared statement] in different threads at the same time.
- ** ^If SQLite is compiled with
- ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- ** it is not possible to set the Serialized [threading mode] and
- ** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
- ** SQLITE_CONFIG_SERIALIZED configuration option.</dd>
- **
- ** [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
- ** <dd> ^(This option takes a single argument which is a pointer to an
- ** instance of the [sqlite3_mem_methods] structure. The argument specifies
- ** alternative low-level memory allocation routines to be used in place of
- ** the memory allocation routines built into SQLite.)^ ^SQLite makes
- ** its own private copy of the content of the [sqlite3_mem_methods] structure
- ** before the [sqlite3_config()] call returns.</dd>
- **
- ** [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
- ** <dd> ^(This option takes a single argument which is a pointer to an
- ** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods]
- ** structure is filled with the currently defined memory allocation routines.)^
- ** This option can be used to overload the default memory allocation
- ** routines with a wrapper that simulations memory allocation failure or
- ** tracks memory usage, for example. </dd>
- **
- ** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
- ** <dd> ^This option takes single argument of type int, interpreted as a
- ** boolean, which enables or disables the collection of memory allocation
- ** statistics. ^(When memory allocation statistics are disabled, the
- ** following SQLite interfaces become non-operational:
- ** <ul>
- ** <li> [sqlite3_memory_used()]
- ** <li> [sqlite3_memory_highwater()]
- ** <li> [sqlite3_soft_heap_limit64()]
- ** <li> [sqlite3_status()]
- ** </ul>)^
- ** ^Memory allocation statistics are enabled by default unless SQLite is
- ** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
- ** allocation statistics are disabled by default.
- ** </dd>
- **
- ** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
- ** <dd> ^This option specifies a static memory buffer that SQLite can use for
- ** scratch memory. There are three arguments: A pointer an 8-byte
- ** aligned memory buffer from which the scratch allocations will be
- ** drawn, the size of each scratch allocation (sz),
- ** and the maximum number of scratch allocations (N). The sz
- ** argument must be a multiple of 16.
- ** The first argument must be a pointer to an 8-byte aligned buffer
- ** of at least sz*N bytes of memory.
- ** ^SQLite will use no more than two scratch buffers per thread. So
- ** N should be set to twice the expected maximum number of threads.
- ** ^SQLite will never require a scratch buffer that is more than 6
- ** times the database page size. ^If SQLite needs needs additional
- ** scratch memory beyond what is provided by this configuration option, then
- ** [sqlite3_malloc()] will be used to obtain the memory needed.</dd>
- **
- ** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
- ** <dd> ^This option specifies a static memory buffer that SQLite can use for
- ** the database page cache with the default page cache implementation.
- ** This configuration should not be used if an application-define page
- ** cache implementation is loaded using the SQLITE_CONFIG_PCACHE2 option.
- ** There are three arguments to this option: A pointer to 8-byte aligned
- ** memory, the size of each page buffer (sz), and the number of pages (N).
- ** The sz argument should be the size of the largest database page
- ** (a power of two between 512 and 32768) plus a little extra for each
- ** page header. ^The page header size is 20 to 40 bytes depending on
- ** the host architecture. ^It is harmless, apart from the wasted memory,
- ** to make sz a little too large. The first
- ** argument should point to an allocation of at least sz*N bytes of memory.
- ** ^SQLite will use the memory provided by the first argument to satisfy its
- ** memory needs for the first N pages that it adds to cache. ^If additional
- ** page cache memory is needed beyond what is provided by this option, then
- ** SQLite goes to [sqlite3_malloc()] for the additional storage space.
- ** The pointer in the first argument must
- ** be aligned to an 8-byte boundary or subsequent behavior of SQLite
- ** will be undefined.</dd>
- **
- ** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
- ** <dd> ^This option specifies a static memory buffer that SQLite will use
- ** for all of its dynamic memory allocation needs beyond those provided
- ** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].
- ** There are three arguments: An 8-byte aligned pointer to the memory,
- ** the number of bytes in the memory buffer, and the minimum allocation size.
- ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
- ** to using its default memory allocator (the system malloc() implementation),
- ** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the
- ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
- ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
- ** allocator is engaged to handle all of SQLites memory allocation needs.
- ** The first pointer (the memory pointer) must be aligned to an 8-byte
- ** boundary or subsequent behavior of SQLite will be undefined.
- ** The minimum allocation size is capped at 2**12. Reasonable values
- ** for the minimum allocation size are 2**5 through 2**8.</dd>
- **
- ** [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
- ** <dd> ^(This option takes a single argument which is a pointer to an
- ** instance of the [sqlite3_mutex_methods] structure. The argument specifies
- ** alternative low-level mutex routines to be used in place
- ** the mutex routines built into SQLite.)^ ^SQLite makes a copy of the
- ** content of the [sqlite3_mutex_methods] structure before the call to
- ** [sqlite3_config()] returns. ^If SQLite is compiled with
- ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- ** the entire mutexing subsystem is omitted from the build and hence calls to
- ** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will
- ** return [SQLITE_ERROR].</dd>
- **
- ** [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
- ** <dd> ^(This option takes a single argument which is a pointer to an
- ** instance of the [sqlite3_mutex_methods] structure. The
- ** [sqlite3_mutex_methods]
- ** structure is filled with the currently defined mutex routines.)^
- ** This option can be used to overload the default mutex allocation
- ** routines with a wrapper used to track mutex usage for performance
- ** profiling or testing, for example. ^If SQLite is compiled with
- ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- ** the entire mutexing subsystem is omitted from the build and hence calls to
- ** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will
- ** return [SQLITE_ERROR].</dd>
- **
- ** [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
- ** <dd> ^(This option takes two arguments that determine the default
- ** memory allocation for the lookaside memory allocator on each
- ** [database connection]. The first argument is the
- ** size of each lookaside buffer slot and the second is the number of
- ** slots allocated to each database connection.)^ ^(This option sets the
- ** <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
- ** verb to [sqlite3_db_config()] can be used to change the lookaside
- ** configuration on individual connections.)^ </dd>
- **
- ** [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
- ** <dd> ^(This option takes a single argument which is a pointer to
- ** an [sqlite3_pcache_methods2] object. This object specifies the interface
- ** to a custom page cache implementation.)^ ^SQLite makes a copy of the
- ** object and uses it for page cache memory allocations.</dd>
- **
- ** [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
- ** <dd> ^(This option takes a single argument which is a pointer to an
- ** [sqlite3_pcache_methods2] object. SQLite copies of the current
- ** page cache implementation into that object.)^ </dd>
- **
- ** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
- ** <dd> ^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a
- ** function with a call signature of void(*)(void*,int,const char*),
- ** and a pointer to void. ^If the function pointer is not NULL, it is
- ** invoked by [sqlite3_log()] to process each logging event. ^If the
- ** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op.
- ** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is
- ** passed through as the first parameter to the application-defined logger
- ** function whenever that function is invoked. ^The second parameter to
- ** the logger function is a copy of the first parameter to the corresponding
- ** [sqlite3_log()] call and is intended to be a [result code] or an
- ** [extended result code]. ^The third parameter passed to the logger is
- ** log message after formatting via [sqlite3_snprintf()].
- ** The SQLite logging interface is not reentrant; the logger function
- ** supplied by the application must not invoke any SQLite interface.
- ** In a multi-threaded application, the application-defined logger
- ** function must be threadsafe. </dd>
- **
- ** [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
- ** <dd> This option takes a single argument of type int. If non-zero, then
- ** URI handling is globally enabled. If the parameter is zero, then URI handling
- ** is globally disabled. If URI handling is globally enabled, all filenames
- ** passed to [sqlite3_open()], [sqlite3_open_v2()], [sqlite3_open16()] or
- ** specified as part of [ATTACH] commands are interpreted as URIs, regardless
- ** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
- ** connection is opened. If it is globally disabled, filenames are
- ** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
- ** database connection is opened. By default, URI handling is globally
- ** disabled. The default value may be changed by compiling with the
- ** [SQLITE_USE_URI] symbol defined.
- **
- ** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]]
- ** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFNIG_GETPCACHE
- ** <dd> These options are obsolete and should not be used by new code.
- ** They are retained for backwards compatibility but are now no-ops.
- ** </dl>
- */
- #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */
- #define SQLITE_CONFIG_MULTITHREAD 2 /* nil */
- #define SQLITE_CONFIG_SERIALIZED 3 /* nil */
- #define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */
- #define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */
- #define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */
- #define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */
- #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */
- #define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */
- #define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */
- #define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */
- /* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
- #define SQLITE_CONFIG_LOOKASIDE 13 /* int int */
- #define SQLITE_CONFIG_PCACHE 14 /* no-op */
- #define SQLITE_CONFIG_GETPCACHE 15 /* no-op */
- #define SQLITE_CONFIG_LOG 16 /* xFunc, void* */
- #define SQLITE_CONFIG_URI 17 /* int */
- #define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */
- #define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */
- /*
- ** CAPI3REF: Database Connection Configuration Options
- **
- ** These constants are the available integer configuration options that
- ** can be passed as the second argument to the [sqlite3_db_config()] interface.
- **
- ** New configuration options may be added in future releases of SQLite.
- ** Existing configuration options might be discontinued. Applications
- ** should check the return code from [sqlite3_db_config()] to make sure that
- ** the call worked. ^The [sqlite3_db_config()] interface will return a
- ** non-zero [error code] if a discontinued or unsupported configuration option
- ** is invoked.
- **
- ** <dl>
- ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
- ** <dd> ^This option takes three additional arguments that determine the
- ** [lookaside memory allocator] configuration for the [database connection].
- ** ^The first argument (the third parameter to [sqlite3_db_config()] is a
- ** pointer to a memory buffer to use for lookaside memory.
- ** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb
- ** may be NULL in which case SQLite will allocate the
- ** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the
- ** size of each lookaside buffer slot. ^The third argument is the number of
- ** slots. The size of the buffer in the first argument must be greater than
- ** or equal to the product of the second and third arguments. The buffer
- ** must be aligned to an 8-byte boundary. ^If the second argument to
- ** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
- ** rounded down to the next smaller multiple of 8. ^(The lookaside memory
- ** configuration for a database connection can only be changed when that
- ** connection is not currently using lookaside memory, or in other words
- ** when the "current value" returned by
- ** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero.
- ** Any attempt to change the lookaside memory configuration when lookaside
- ** memory is in use leaves the configuration unchanged and returns
- ** [SQLITE_BUSY].)^</dd>
- **
- ** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
- ** <dd> ^This option is used to enable or disable the enforcement of
- ** [foreign key constraints]. There should be two additional arguments.
- ** The first argument is an integer which is 0 to disable FK enforcement,
- ** positive to enable FK enforcement or negative to leave FK enforcement
- ** unchanged. The second parameter is a pointer to an integer into which
- ** is written 0 or 1 to indicate whether FK enforcement is off or on
- ** following this call. The second parameter may be a NULL pointer, in
- ** which case the FK enforcement setting is not reported back. </dd>
- **
- ** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
- ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
- ** There should be two additional arguments.
- ** The first argument is an integer which is 0 to disable triggers,
- ** positive to enable triggers or negative to leave the setting unchanged.
- ** The second parameter is a pointer to an integer into which
- ** is written 0 or 1 to indicate whether triggers are disabled or enabled
- ** following this call. The second parameter may be a NULL pointer, in
- ** which case the trigger setting is not reported back. </dd>
- **
- ** </dl>
- */
- #define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */
- #define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */
- #define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */
- /*
- ** CAPI3REF: Enable Or Disable Extended Result Codes
- **
- ** ^The sqlite3_extended_result_codes() routine enables or disables the
- ** [extended result codes] feature of SQLite. ^The extended result
- ** codes are disabled by default for historical compatibility.
- */
- SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
- /*
- ** CAPI3REF: Last Insert Rowid
- **
- ** ^Each entry in an SQLite table has a unique 64-bit signed
- ** integer key called the [ROWID | "rowid"]. ^The rowid is always available
- ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
- ** names are not also used by explicitly declared columns. ^If
- ** the table has a column of type [INTEGER PRIMARY KEY] then that column
- ** is another alias for the rowid.
- **
- ** ^This routine returns the [rowid] of the most recent
- ** successful [INSERT] into the database from the [database connection]
- ** in the first argument. ^As of SQLite version 3.7.7, this routines
- ** records the last insert rowid of both ordinary tables and [virtual tables].
- ** ^If no successful [INSERT]s
- ** have ever occurred on that database connection, zero is returned.
- **
- ** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
- ** method, then this routine will return the [rowid] of the inserted
- ** row as long as the trigger or virtual table method is running.
- ** But once the trigger or virtual table method ends, the value returned
- ** by this routine reverts to what it was before the trigger or virtual
- ** table method began.)^
- **
- ** ^An [INSERT] that fails due to a constraint violation is not a
- ** successful [INSERT] and does not change the value returned by this
- ** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
- ** and INSERT OR ABORT make no changes to the return value of this
- ** routine when their insertion fails. ^(When INSERT OR REPLACE
- ** encounters a constraint violation, it does not fail. The
- ** INSERT continues to completion after deleting rows that caused
- ** the constraint problem so INSERT OR REPLACE will always change
- ** the return value of this interface.)^
- **
- ** ^For the purposes of this routine, an [INSERT] is considered to
- ** be successful even if it is subsequently rolled back.
- **
- ** This function is accessible to SQL statements via the
- ** [last_insert_rowid() SQL function].
- **
- ** If a separate thread performs a new [INSERT] on the same
- ** database connection while the [sqlite3_last_insert_rowid()]
- ** function is running and thus changes the last insert [rowid],
- ** then the value returned by [sqlite3_last_insert_rowid()] is
- ** unpredictable and might not equal either the old or the new
- ** last insert [rowid].
- */
- SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
- /*
- ** CAPI3REF: Count The Number Of Rows Modified
- **
- ** ^This function returns the number of database rows that were changed
- ** or inserted or deleted by the most recently completed SQL statement
- ** on the [database connection] specified by the first parameter.
- ** ^(Only changes that are directly specified by the [INSERT], [UPDATE],
- ** or [DELETE] statement are counted. Auxiliary changes caused by
- ** triggers or [foreign key actions] are not counted.)^ Use the
- ** [sqlite3_total_changes()] function to find the total number of changes
- ** including changes caused by triggers and foreign key actions.
- **
- ** ^Changes to a view that are simulated by an [INSTEAD OF trigger]
- ** are not counted. Only real table changes are counted.
- **
- ** ^(A "row change" is a change to a single row of a single table
- ** caused by an INSERT, DELETE, or UPDATE statement. Rows that
- ** are changed as side effects of [REPLACE] constraint resolution,
- ** rollback, ABORT processing, [DROP TABLE], or by any other
- ** mechanisms do not count as direct row changes.)^
- **
- ** A "trigger context" is a scope of execution that begins and
- ** ends with the script of a [CREATE TRIGGER | trigger].
- ** Most SQL statements are
- ** evaluated outside of any trigger. This is the "top level"
- ** trigger context. If a trigger fires from the top level, a
- ** new trigger context is entered for the duration of that one
- ** trigger. Subtriggers create subcontexts for their duration.
- **
- ** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
- ** not create a new trigger context.
- **
- ** ^This function returns the number of direct row changes in the
- ** most recent INSERT, UPDATE, or DELETE statement within the same
- ** trigger context.
- **
- ** ^Thus, when called from the top level, this function returns the
- ** number of changes in the most recent INSERT, UPDATE, or DELETE
- ** that also occurred at the top level. ^(Within the body of a trigger,
- ** the sqlite3_changes() interface can be called to find the number of
- ** changes in the most recently completed INSERT, UPDATE, or DELETE
- ** statement within the body of the same trigger.
- ** However, the number returned does not include changes
- ** caused by subtriggers since those have their own context.)^
- **
- ** See also the [sqlite3_total_changes()] interface, the
- ** [count_changes pragma], and the [changes() SQL function].
- **
- ** If a separate thread makes changes on the same database connection
- ** while [sqlite3_changes()] is running then the value returned
- ** is unpredictable and not meaningful.
- */
- SQLITE_API int sqlite3_changes(sqlite3*);
- /*
- ** CAPI3REF: Total Number Of Rows Modified
- **
- ** ^This function returns the number of row changes caused by [INSERT],
- ** [UPDATE] or [DELETE] statements since the [database connection] was opened.
- ** ^(The count returned by sqlite3_total_changes() includes all changes
- ** from all [CREATE TRIGGER | trigger] contexts and changes made by
- ** [foreign key actions]. However,
- ** the count does not include changes used to implement [REPLACE] constraints,
- ** do rollbacks or ABORT processing, or [DROP TABLE] processing. The
- ** count does not include rows of views that fire an [INSTEAD OF trigger],
- ** though if the INSTEAD OF trigger makes changes of its own, those changes
- ** are counted.)^
- ** ^The sqlite3_total_changes() function counts the changes as soon as
- ** the statement that makes them is completed (when the statement handle
- ** is passed to [sqlite3_reset()] or [sqlite3_finalize()]).
- **
- ** See also the [sqlite3_changes()] interface, the
- ** [count_changes pragma], and the [total_changes() SQL function].
- **
- ** If a separate thread makes changes on the same database connection
- ** while [sqlite3_total_changes()] is running then the value
- ** returned is unpredictable and not meaningful.
- */
- SQLITE_API int sqlite3_total_changes(sqlite3*);
- /*
- ** CAPI3REF: Interrupt A Long-Running Query
- **
- ** ^This function causes any pending database operation to abort and
- ** return at its earliest opportunity. This routine is typically
- ** called in response to a user action such as pressing "Cancel"
- ** or Ctrl-C where the user wants a long query operation to halt
- ** immediately.
- **
- ** ^It is safe to call this routine from a thread different from the
- ** thread that is currently running the database operation. But it
- ** is not safe to call this routine with a [database connection] that
- ** is closed or might close before sqlite3_interrupt() returns.
- **
- ** ^If an SQL operation is very nearly finished at the time when
- ** sqlite3_interrupt() is called, then it might not have an opportunity
- ** to be interrupted and might continue to completion.
- **
- ** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
- ** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
- ** that is inside an explicit transaction, then the entire transaction
- ** will be rolled back automatically.
- **
- ** ^The sqlite3_interrupt(D) call is in effect until all currently running
- ** SQL statements on [database connection] D complete. ^Any new SQL statements
- ** that are started after the sqlite3_interrupt() call and before the
- ** running statements reaches zero are interrupted as if they had been
- ** running prior to the sqlite3_interrupt() call. ^New SQL statements
- ** that are started after the running statement count reaches zero are
- ** not effected by the sqlite3_interrupt().
- ** ^A call to sqlite3_interrupt(D) that occurs when there are no running
- ** SQL statements is a no-op and has no effect on SQL statements
- ** that are started after the sqlite3_interrupt() call returns.
- **
- ** If the database connection closes while [sqlite3_interrupt()]
- ** is running then bad things will likely happen.
- */
- SQLITE_API void sqlite3_interrupt(sqlite3*);
- /*
- ** CAPI3REF: Determine If An SQL Statement Is Complete
- **
- ** These routines are useful during command-line input to determine if the
- ** currently entered text seems to form a complete SQL statement or
- ** if additional input is needed before sending the text into
- ** SQLite for parsing. ^These routines return 1 if the input string
- ** appears to be a complete SQL statement. ^A statement is judged to be
- ** complete if it ends with a semicolon token and is not a prefix of a
- ** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within
- ** string literals or quoted identifier names or comments are not
- ** independent tokens (they are part of the token in which they are
- ** embedded) and thus do not count as a statement terminator. ^Whitespace
- ** and comments that follow the final semicolon are ignored.
- **
- ** ^These routines return 0 if the statement is incomplete. ^If a
- ** memory allocation fails, then SQLITE_NOMEM is returned.
- **
- ** ^These routines do not parse the SQL statements thus
- ** will not detect syntactically incorrect SQL.
- **
- ** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
- ** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
- ** automatically by sqlite3_complete16(). If that initialization fails,
- ** then the return value from sqlite3_complete16() will be non-zero
- ** regardless of whether or not the input SQL is complete.)^
- **
- ** The input to [sqlite3_complete()] must be a zero-terminated
- ** UTF-8 string.
- **
- ** The input to [sqlite3_complete16()] must be a zero-terminated
- ** UTF-16 string in native byte order.
- */
- SQLITE_API int sqlite3_complete(const char *sql);
- SQLITE_API int sqlite3_complete16(const void *sql);
- /*
- ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
- **
- ** ^This routine sets a callback function that might be invoked whenever
- ** an attempt is made to open a database table that another thread
- ** or process has locked.
- **
- ** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]
- ** is returned immediately upon encountering the lock. ^If the busy callback
- ** is not NULL, then the callback might be invoked with two arguments.
- **
- ** ^The first argument to the busy handler is a copy of the void* pointer which
- ** is the third argument to sqlite3_busy_handler(). ^The second argument to
- ** the busy handler callback is the number of times that the busy handler has
- ** been invoked for this locking event. ^If the
- ** busy callback returns 0, then no additional attempts are made to
- ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
- ** ^If the callback returns non-zero, then another attempt
- ** is made to open the database for reading and the cycle repeats.
- **
- ** The presence of a busy handler does not guarantee that it will be invoked
- ** when there is lock contention. ^If SQLite determines that invoking the busy
- ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
- ** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler.
- ** Consider a scenario where one process is holding a read lock that
- ** it is trying to promote to a reserved lock and
- ** a second process is holding a reserved lock that it is trying
- ** to promote to an exclusive lock. The first process cannot proceed
- ** because it is blocked by the second and the second process cannot
- ** proceed because it is blocked by the first. If both processes
- ** invoke the busy handlers, neither will make any progress. Therefore,
- ** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
- ** will induce the first process to release its read lock and allow
- ** the second process to proceed.
- **
- ** ^The default busy callback is NULL.
- **
- ** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]
- ** when SQLite is in the middle of a large transaction where all the
- ** changes will not fit into the in-memory cache. SQLite will
- ** already hold a RESERVED lock on the database file, but it needs
- ** to promote this lock to EXCLUSIVE so that it can spill cache
- ** pages into the database file without harm to concurrent
- ** readers. ^If it is unable to promote the lock, then the in-memory
- ** cache will be left in an inconsistent state and so the error
- ** code is promoted from the relatively benign [SQLITE_BUSY] to
- ** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion
- ** forces an automatic rollback of the changes. See the
- ** <a href="/cvstrac/wiki?p=CorruptionFollowingBusyError">
- ** CorruptionFollowingBusyError</a> wiki page for a discussion of why
- ** this is important.
- **
- ** ^(There can only be a single busy handler defined for each
- ** [database connection]. Setting a new busy handler clears any
- ** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()]
- ** will also set or clear the busy handler.
- **
- ** The busy callback should not take any actions which modify the
- ** database connection that invoked the busy handler. Any such actions
- ** result in undefined behavior.
- **
- ** A busy handler must not close the database connection
- ** or [prepared statement] that invoked the busy handler.
- */
- SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
- /*
- ** CAPI3REF: Set A Busy Timeout
- **
- ** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
- ** for a specified amount of time when a table is locked. ^The handler
- ** will sleep multiple times until at least "ms" milliseconds of sleeping
- ** have accumulated. ^After at least "ms" milliseconds of sleeping,
- ** the handler returns 0 which causes [sqlite3_step()] to return
- ** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].
- **
- ** ^Calling this routine with an argument less than or equal to zero
- ** turns off all busy handlers.
- **
- ** ^(There can only be a single busy handler for a particular
- ** [database connection] any any given moment. If another busy handler
- ** was defined (using [sqlite3_busy_handler()]) prior to calling
- ** this routine, that other busy handler is cleared.)^
- */
- SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
- /*
- ** CAPI3REF: Convenience Routines For Running Queries
- **
- ** This is a legacy interface that is preserved for backwards compatibility.
- ** Use of this interface is not recommended.
- **
- ** Definition: A <b>result table</b> is memory data structure created by the
- ** [sqlite3_get_table()] interface. A result table records the
- ** complete query results from one or more queries.
- **
- ** The table conceptually has a number of rows and columns. But
- ** these numbers are not part of the result table itself. These
- ** numbers are obtained separately. Let N be the number of rows
- ** and M be the number of columns.
- **
- ** A result table is an array of pointers to zero-terminated UTF-8 strings.
- ** There are (N+1)*M elements in the array. The first M pointers point
- ** to zero-terminated strings that contain the names of the columns.
- ** The remaining entries all point to query results. NULL values result
- ** in NULL pointers. All other values are in their UTF-8 zero-terminated
- ** string representation as returned by [sqlite3_column_text()].
- **
- ** A result table might consist of one or more memory allocations.
- ** It is not safe to pass a result table directly to [sqlite3_free()].
- ** A result table should be deallocated using [sqlite3_free_table()].
- **
- ** ^(As an example of the result table format, suppose a query result
- ** is as follows:
- **
- ** <blockquote><pre>
- ** Name | Age
- ** -----------------------
- ** Alice | 43
- ** Bob | 28
- ** Cindy | 21
- ** </pre></blockquote>
- **
- ** There are two column (M==2) and three rows (N==3). Thus the
- ** result table has 8 entries. Suppose the result table is stored
- ** in an array names azResult. Then azResult holds this content:
- **
- ** <blockquote><pre>
- ** azResult[0] = "Name";
- ** azResult[1] = "Age";
- ** azResult[2] = "Alice";
- ** azResult[3] = "43";
- ** azResult[4] = "Bob";
- ** azResult[5] = "28";
- ** azResult[6] = "Cindy";
- ** azResult[7] = "21";
- ** </pre></blockquote>)^
- **
- ** ^The sqlite3_get_table() function evaluates one or more
- ** semicolon-separated SQL statements in the zero-terminated UTF-8
- ** string of its 2nd parameter and returns a result table to the
- ** pointer given in its 3rd parameter.
- **
- ** After the application has finished with the result from sqlite3_get_table(),
- ** it must pass the result table pointer to sqlite3_free_table() in order to
- ** release the memory that was malloced. Because of the way the
- ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
- ** function must not try to call [sqlite3_free()] directly. Only
- ** [sqlite3_free_table()] is able to release the memory properly and safely.
- **
- ** The sqlite3_get_table() interface is implemented as a wrapper around
- ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access
- ** to any internal data structures of SQLite. It uses only the public
- ** interface defined here. As a consequence, errors that occur in the
- ** wrapper layer outside of the internal [sqlite3_exec()] call are not
- ** reflected in subsequent calls to [sqlite3_errcode()] or
- ** [sqlite3_errmsg()].
- */
- SQLITE_API int sqlite3_get_table(
- sqlite3 *db, /* An open database */
- const char *zSql, /* SQL to be evaluated */
- char ***pazResult, /* Results of the query */
- int *pnRow, /* Number of result rows written here */
- int *pnColumn, /* Number of result columns written here */
- char **pzErrmsg /* Error msg written here */
- );
- SQLITE_API void sqlite3_free_table(char **result);
- /*
- ** CAPI3REF: Formatted String Printing Functions
- **
- ** These routines are work-alikes of the "printf()" family of functions
- ** from the standard C library.
- **
- ** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
- ** results into memory obtained from [sqlite3_malloc()].
- ** The strings returned by these two routines should be
- ** released by [sqlite3_free()]. ^Both routines return a
- ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough
- ** memory to hold the resulting string.
- **
- ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
- ** the standard C library. The result is written into the
- ** buffer supplied as the second parameter whose size is given by
- ** the first parameter. Note that the order of the
- ** first two parameters is reversed from snprintf().)^ This is an
- ** historical accident that cannot be fixed without breaking
- ** backwards compatibility. ^(Note also that sqlite3_snprintf()
- ** returns a pointer to its buffer instead of the number of
- ** characters actually written into the buffer.)^ We admit that
- ** the number of characters written would be a more useful return
- ** value but we cannot change the implementation of sqlite3_snprintf()
- ** now without breaking compatibility.
- **
- ** ^As long as the buffer size is greater than zero, sqlite3_snprintf()
- ** guarantees that the buffer is always zero-terminated. ^The first
- ** parameter "n" is the total size of the buffer, including space for
- ** the zero terminator. So the longest string that can be completely
- ** written will be n-1 characters.
- **
- ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
- **
- ** These routines all implement some additional formatting
- ** options that are useful for constructing SQL statements.
- ** All of the usual printf() formatting options apply. In addition, there
- ** is are "%q", "%Q", and "%z" options.
- **
- ** ^(The %q option works like %s in that it substitutes a nul-terminated
- ** string from the argument list. But %q also doubles every '\'' character.
- ** %q is designed for use inside a string literal.)^ By doubling each '\''
- ** character it escapes that character and allows it to be inserted into
- ** the string.
- **
- ** For example, assume the string variable zText contains text as follows:
- **
- ** <blockquote><pre>
- ** char *zText = "It's a happy day!";
- ** </pre></blockquote>
- **
- ** One can use this text in an SQL statement as follows:
- **
- ** <blockquote><pre>
- ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
- ** sqlite3_exec(db, zSQL, 0, 0, 0);
- ** sqlite3_free(zSQL);
- ** </pre></blockquote>
- **
- ** Because the %q format string is used, the '\'' character in zText
- ** is escaped and the SQL generated is as follows:
- **
- ** <blockquote><pre>
- ** INSERT INTO table1 VALUES('It''s a happy day!')
- ** </pre></blockquote>
- **
- ** This is correct. Had we used %s instead of %q, the generated SQL
- ** would have looked like this:
- **
- ** <blockquote><pre>
- ** INSERT INTO table1 VALUES('It's a happy day!');
- ** </pre></blockquote>
- **
- ** This second example is an SQL syntax error. As a general rule you should
- ** always use %q instead of %s when inserting text into a string literal.
- **
- ** ^(The %Q option works like %q except it also adds single quotes around
- ** the outside of the total string. Additionally, if the parameter in the
- ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without
- ** single quotes).)^ So, for example, one could say:
- **
- ** <blockquote><pre>
- ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
- ** sqlite3_exec(db, zSQL, 0, 0, 0);
- ** sqlite3_free(zSQL);
- ** </pre></blockquote>
- **
- ** The code above will render a correct SQL statement in the zSQL
- ** variable even if the zText variable is a NULL pointer.
- **
- ** ^(The "%z" formatting option works like "%s" but with the
- ** addition that after the string has been read and copied into
- ** the result, [sqlite3_free()] is called on the input string.)^
- */
- SQLITE_API char *sqlite3_mprintf(const char*,...);
- SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
- SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
- SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
- /*
- ** CAPI3REF: Memory Allocation Subsystem
- **
- ** The SQLite core uses these three routines for all of its own
- ** internal memory allocation needs. "Core" in the previous sentence
- ** does not include operating-system specific VFS implementation. The
- ** Windows VFS uses native malloc() and free() for some operations.
- **
- ** ^The sqlite3_malloc() routine returns a pointer to a block
- ** of memory at least N bytes in length, where N is the parameter.
- ** ^If sqlite3_malloc() is unable to obtain sufficient free
- ** memory, it returns a NULL pointer. ^If the parameter N to
- ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
- ** a NULL pointer.
- **
- ** ^Calling sqlite3_free() with a pointer previously returned
- ** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
- ** that it might be reused. ^The sqlite3_free() routine is
- ** a no-op if is called with a NULL pointer. Passing a NULL pointer
- ** to sqlite3_free() is harmless. After being freed, memory
- ** should neither be read nor written. Even reading previously freed
- ** memory might result in a segmentation fault or other severe error.
- ** Memory corruption, a segmentation fault, or other severe error
- ** might result if sqlite3_free() is called with a non-NULL pointer that
- ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
- **
- ** ^(The sqlite3_realloc() interface attempts to resize a
- ** prior memory allocation to be at least N bytes, where N is the
- ** second parameter. The memory allocation to be resized is the first
- ** parameter.)^ ^ If the first parameter to sqlite3_realloc()
- ** is a NULL pointer then its behavior is identical to calling
- ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().
- ** ^If the second parameter to sqlite3_realloc() is zero or
- ** negative then the behavior is exactly the same as calling
- ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().
- ** ^sqlite3_realloc() returns a pointer to a memory allocation
- ** of at least N bytes in size or NULL if sufficient memory is unavailable.
- ** ^If M is the size of the prior allocation, then min(N,M) bytes
- ** of the prior allocation are copied into the beginning of buffer returned
- ** by sqlite3_realloc() and the prior allocation is freed.
- ** ^If sqlite3_realloc() returns NULL, then the prior allocation
- ** is not freed.
- **
- ** ^The memory returned by sqlite3_malloc() and sqlite3_realloc()
- ** is always aligned to at least an 8 byte boundary, or to a
- ** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
- ** option is used.
- **
- ** In SQLite version 3.5.0 and 3.5.1, it was possible to define
- ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
- ** implementation of these routines to be omitted. That capability
- ** is no longer provided. Only built-in memory allocators can be used.
- **
- ** The Windows OS interface layer calls
- ** the system malloc() and free() directly when converting
- ** filenames between the UTF-8 encoding used by SQLite
- ** and whatever filename encoding is used by the particular Windows
- ** installation. Memory allocation errors are detected, but
- ** they are reported back as [SQLITE_CANTOPEN] or
- ** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
- **
- ** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
- ** must be either NULL or else pointers obtained from a prior
- ** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have
- ** not yet been released.
- **
- ** The application must not read or write any part of
- ** a block of memory after it has been released using
- ** [sqlite3_free()] or [sqlite3_realloc()].
- */
- SQLITE_API void *sqlite3_malloc(int);
- SQLITE_API void *sqlite3_realloc(void*, int);
- SQLITE_API void sqlite3_free(void*);
- /*
- ** CAPI3REF: Memory Allocator Statistics
- **
- ** SQLite provides these two interfaces for reporting on the status
- ** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
- ** routines, which form the built-in memory allocation subsystem.
- **
- ** ^The [sqlite3_memory_used()] routine returns the number of bytes
- ** of memory currently outstanding (malloced but not freed).
- ** ^The [sqlite3_memory_highwater()] routine returns the maximum
- ** value of [sqlite3_memory_used()] since the high-water mark
- ** was last reset. ^The values returned by [sqlite3_memory_used()] and
- ** [sqlite3_memory_highwater()] include any overhead
- ** added by SQLite in its implementation of [sqlite3_malloc()],
- ** but not overhead added by the any underlying system library
- ** routines that [sqlite3_malloc()] may call.
- **
- ** ^The memory high-water mark is reset to the current value of
- ** [sqlite3_memory_used()] if and only if the parameter to
- ** [sqlite3_memory_highwater()] is true. ^The value returned
- ** by [sqlite3_memory_highwater(1)] is the high-water mark
- ** prior to the reset.
- */
- SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
- SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
- /*
- ** CAPI3REF: Pseudo-Random Number Generator
- **
- ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
- ** select random [ROWID | ROWIDs] when inserting new records into a table that
- ** already uses the largest possible [ROWID]. The PRNG is also used for
- ** the build-in random() and randomblob() SQL functions. This interface allows
- ** applications to access the same PRNG for other purposes.
- **
- ** ^A call to this routine stores N bytes of randomness into buffer P.
- **
- ** ^The first time this routine is invoked (either internally or by
- ** the application) the PRNG is seeded using randomness obtained
- ** from the xRandomness method of the default [sqlite3_vfs] object.
- ** ^On all subsequent invocations, the pseudo-randomness is generated
- ** internally and without recourse to the [sqlite3_vfs] xRandomness
- ** method.
- */
- SQLITE_API void sqlite3_randomness(int N, void *P);
- /*
- ** CAPI3REF: Compile-Time Authorization Callbacks
- **
- ** ^This routine registers an authorizer callback with a particular
- ** [database connection], supplied in the first argument.
- ** ^The authorizer callback is invoked as SQL statements are being compiled
- ** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
- ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various
- ** points during the compilation process, as logic is being created
- ** to perform various actions, the authorizer callback is invoked to
- ** see if those actions are allowed. ^The authorizer callback should
- ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
- ** specific action but allow the SQL statement to continue to be
- ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
- ** rejected with an error. ^If the authorizer callback returns
- ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
- ** then the [sqlite3_prepare_v2()] or equivalent call that triggered
- ** the authorizer will fail with an error message.
- **
- ** When the callback returns [SQLITE_OK], that means the operation
- ** requested is ok. ^When the callback returns [SQLITE_DENY], the
- ** [sqlite3_prepare_v2()] or equivalent call that triggered the
- ** authorizer will fail with an error message explaining that
- ** access is denied.
- **
- ** ^The first parameter to the authorizer callback is a copy of the third
- ** parameter to the sqlite3_set_authorizer() interface. ^The second parameter
- ** to the callback is an integer [SQLITE_COPY | action code] that specifies
- ** the particular action to be authorized. ^The third through sixth parameters
- ** to the callback are zero-terminated strings that contain additional
- ** details about the action to be authorized.
- **
- ** ^If the action code is [SQLITE_READ]
- ** and the callback returns [SQLITE_IGNORE] then the
- ** [prepared statement] statement is constructed to substitute
- ** a NULL value in place of the table column that would have
- ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
- ** return can be used to deny an untrusted user access to individual
- ** columns of a table.
- ** ^If the action code is [SQLITE_DELETE] and the callback returns
- ** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
- ** [truncate optimization] is disabled and all rows are deleted individually.
- **
- ** An authorizer is used when [sqlite3_prepare | preparing]
- ** SQL statements from an untrusted source, to ensure that the SQL statements
- ** do not try to access data they are not allowed to see, or that they do not
- ** try to execute malicious statements that damage the database. For
- ** example, an application may allow a user to enter arbitrary
- ** SQL queries for evaluation by a database. But the application does
- ** not want the user to be able to make arbitrary changes to the
- ** database. An authorizer could then be put in place while the
- ** user-entered SQL is being [sqlite3_prepare | prepared] that
- ** disallows everything except [SELECT] statements.
- **
- ** Applications that need to process SQL from untrusted sources
- ** might also consider lowering resource limits using [sqlite3_limit()]
- ** and limiting database size using the [max_page_count] [PRAGMA]
- ** in addition to using an authorizer.
- **
- ** ^(Only a single authorizer can be in place on a database connection
- ** at a time. Each call to sqlite3_set_authorizer overrides the
- ** previous call.)^ ^Disable the authorizer by installing a NULL callback.
- ** The authorizer is disabled by default.
- **
- ** The authorizer callback must not do anything that will modify
- ** the database connection that invoked the authorizer callback.
- ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
- ** database connections for the meaning of "modify" in this paragraph.
- **
- ** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the
- ** statement might be re-prepared during [sqlite3_step()] due to a
- ** schema change. Hence, the application should ensure that the
- ** correct authorizer callback remains in place during the [sqlite3_step()].
- **
- ** ^Note that the authorizer callback is invoked only during
- ** [sqlite3_prepare()] or its variants. Authorization is not
- ** performed during statement evaluation in [sqlite3_step()], unless
- ** as stated in the previous paragraph, sqlite3_step() invokes
- ** sqlite3_prepare_v2() to reprepare a statement after a schema change.
- */
- SQLITE_API int sqlite3_set_authorizer(
- sqlite3*,
- int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
- void *pUserData
- );
- /*
- ** CAPI3REF: Authorizer Return Codes
- **
- ** The [sqlite3_set_authorizer | authorizer callback function] must
- ** return either [SQLITE_OK] or one of these two constants in order
- ** to signal SQLite whether or not the action is permitted. See the
- ** [sqlite3_set_authorizer | authorizer documentation] for additional
- ** information.
- **
- ** Note that SQLITE_IGNORE is also used as a [SQLITE_ROLLBACK | return code]
- ** from the [sqlite3_vtab_on_conflict()] interface.
- */
- #define SQLITE_DENY 1 /* Abort the SQL statement with an error */
- #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */
- /*
- ** CAPI3REF: Authorizer Action Codes
- **
- ** The [sqlite3_set_authorizer()] interface registers a callback function
- ** that is invoked to authorize certain SQL statement actions. The
- ** second parameter to the callback is an integer code that specifies
- ** what action is being authorized. These are the integer action codes that
- ** the authorizer callback may be passed.
- **
- ** These action code values signify what kind of operation is to be
- ** authorized. The 3rd and 4th parameters to the authorization
- ** callback function will be parameters or NULL depending on which of these
- ** codes is used as the second parameter. ^(The 5th parameter to the
- ** authorizer callback is the name of the database ("main", "temp",
- ** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback
- ** is the name of the inner-most trigger or view that is responsible for
- ** the access attempt or NULL if this access attempt is directly from
- ** top-level SQL code.
- */
- /******************************************* 3rd ************ 4th ***********/
- #define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */
- #define SQLITE_CREATE_TABLE 2 /* Table Name NULL */
- #define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */
- #define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */
- #define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */
- #define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */
- #define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */
- #define SQLITE_CREATE_VIEW 8 /* View Name NULL */
- #define SQLITE_DELETE 9 /* Table Name NULL */
- #define SQLITE_DROP_INDEX 10 /* Index Name Table Name */
- #define SQLITE_DROP_TABLE 11 /* Table Name NULL */
- #define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */
- #define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */
- #define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */
- #define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */
- #define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */
- #define SQLITE_DROP_VIEW 17 /* View Name NULL */
- #define SQLITE_INSERT 18 /* Table Name NULL */
- #define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */
- #define SQLITE_READ 20 /* Table Name Column Name */
- #define SQLITE_SELECT 21 /* NULL NULL */
- #define SQLITE_TRANSACTION 22 /* Operation NULL */
- #define SQLITE_UPDATE 23 /* Table Name Column Name */
- #define SQLITE_ATTACH 24 /* Filename NULL */
- #define SQLITE_DETACH 25 /* Database Name NULL */
- #define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
- #define SQLITE_REINDEX 27 /* Index Name NULL */
- #define SQLITE_ANALYZE 28 /* Table Name NULL */
- #define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */
- #define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */
- #define SQLITE_FUNCTION 31 /* NULL Function Name */
- #define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */
- #define SQLITE_COPY 0 /* No longer used */
- /*
- ** CAPI3REF: Tracing And Profiling Functions
- **
- ** These routines register callback functions that can be used for
- ** tracing and profiling the execution of SQL statements.
- **
- ** ^The callback function registered by sqlite3_trace() is invoked at
- ** various times when an SQL statement is being run by [sqlite3_step()].
- ** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the
- ** SQL statement text as the statement first begins executing.
- ** ^(Additional sqlite3_trace() callbacks might occur
- ** as each triggered subprogram is entered. The callbacks for triggers
- ** contain a UTF-8 SQL comment that identifies the trigger.)^
- **
- ** ^The callback function registered by sqlite3_profile() is invoked
- ** as each SQL statement finishes. ^The profile callback contains
- ** the original statement text and an estimate of wall-clock time
- ** of how long that statement took to run. ^The profile callback
- ** time is in units of nanoseconds, however the current implementation
- ** is only capable of millisecond resolution so the six least significant
- ** digits in the time are meaningless. Future versions of SQLite
- ** might provide greater resolution on the profiler callback. The
- ** sqlite3_profile() function is considered experimental and is
- ** subject to change in future versions of SQLite.
- */
- SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
- SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
- void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
- /*
- ** CAPI3REF: Query Progress Callbacks
- **
- ** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback
- ** function X to be invoked periodically during long running calls to
- ** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for
- ** database connection D. An example use for this
- ** interface is to keep a GUI updated during a large query.
- **
- ** ^The parameter P is passed through as the only parameter to the
- ** callback function X. ^The parameter N is the number of
- ** [virtual machine instructions] that are evaluated between successive
- ** invocations of the callback X.
- **
- ** ^Only a single progress handler may be defined at one time per
- ** [database connection]; setting a new progress handler cancels the
- ** old one. ^Setting parameter X to NULL disables the progress handler.
- ** ^The progress handler is also disabled by setting N to a value less
- ** than 1.
- **
- ** ^If the progress callback returns non-zero, the operation is
- ** interrupted. This feature can be used to implement a
- ** "Cancel" button on a GUI progress dialog box.
- **
- ** The progress handler callback must not do anything that will modify
- ** the database connection that invoked the progress handler.
- ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
- ** database connections for the meaning of "modify" in this paragraph.
- **
- */
- SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
- /*
- ** CAPI3REF: Opening A New Database Connection
- **
- ** ^These routines open an SQLite database file as specified by the
- ** filename argument. ^The filename argument is interpreted as UTF-8 for
- ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
- ** order for sqlite3_open16(). ^(A [database connection] handle is usually
- ** returned in *ppDb, even if an error occurs. The only exception is that
- ** if SQLite is unable to allocate memory to hold the [sqlite3] object,
- ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
- ** object.)^ ^(If the database is opened (and/or created) successfully, then
- ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
- ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain
- ** an English language description of the error following a failure of any
- ** of the sqlite3_open() routines.
- **
- ** ^The default encoding for the database will be UTF-8 if
- ** sqlite3_open() or sqlite3_open_v2() is called and
- ** UTF-16 in the native byte order if sqlite3_open16() is used.
- **
- ** Whether or not an error occurs when it is opened, resources
- ** associated with the [database connection] handle should be released by
- ** passing it to [sqlite3_close()] when it is no longer required.
- **
- ** The sqlite3_open_v2() interface works like sqlite3_open()
- ** except that it accepts two additional parameters for additional control
- ** over the new database connection. ^(The flags parameter to
- ** sqlite3_open_v2() can take one of
- ** the following three values, optionally combined with the
- ** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],
- ** [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^
- **
- ** <dl>
- ** ^(<dt>[SQLITE_OPEN_READONLY]</dt>
- ** <dd>The database is opened in read-only mode. If the database does not
- ** already exist, an error is returned.</dd>)^
- **
- ** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
- ** <dd>The database is opened for reading and writing if possible, or reading
- ** only if the file is write protected by the operating system. In either
- ** case the database must already exist, otherwise an error is returned.</dd>)^
- **
- ** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
- ** <dd>The database is opened for reading and writing, and is created if
- ** it does not already exist. This is the behavior that is always used for
- ** sqlite3_open() and sqlite3_open16().</dd>)^
- ** </dl>
- **
- ** If the 3rd parameter to sqlite3_open_v2() is not one of the
- ** combinations shown above optionally combined with other
- ** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
- ** then the behavior is undefined.
- **
- ** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
- ** opens in the multi-thread [threading mode] as long as the single-thread
- ** mode has not been set at compile-time or start-time. ^If the
- ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
- ** in the serialized [threading mode] unless single-thread was
- ** previously selected at compile-time or start-time.
- ** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
- ** eligible to use [shared cache mode], regardless of whether or not shared
- ** cache is enabled using [sqlite3_enable_shared_cache()]. ^The
- ** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
- ** participate in [shared cache mode] even if it is enabled.
- **
- ** ^The fourth parameter to sqlite3_open_v2() is the name of the
- ** [sqlite3_vfs] object that defines the operating system interface that
- ** the new database connection should use. ^If the fourth parameter is
- ** a NULL pointer then the default [sqlite3_vfs] object is used.
- **
- ** ^If the filename is ":memory:", then a private, temporary in-memory database
- ** is created for the connection. ^This in-memory database will vanish when
- ** the database connection is closed. Future versions of SQLite might
- ** make use of additional special filenames that begin with the ":" character.
- ** It is recommended that when a database filename actually does begin with
- ** a ":" character you should prefix the filename with a pathname such as
- ** "./" to avoid ambiguity.
- **
- ** ^If the filename is an empty string, then a private, temporary
- ** on-disk database will be created. ^This private database will be
- ** automatically deleted as soon as the database connection is closed.
- **
- ** [[URI filenames in sqlite3_open()]] <h3>URI Filenames</h3>
- **
- ** ^If [URI filename] interpretation is enabled, and the filename argument
- ** begins with "file:", then the filename is interpreted as a URI. ^URI
- ** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is
- ** set in the fourth argument to sqlite3_open_v2(), or if it has
- ** been enabled globally using the [SQLITE_CONFIG_URI] option with the
- ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
- ** As of SQLite version 3.7.7, URI filename interpretation is turned off
- ** by default, but future releases of SQLite might enable URI filename
- ** interpretation by default. See "[URI filenames]" for additional
- ** information.
- **
- ** URI filenames are parsed according to RFC 3986. ^If the URI contains an
- ** authority, then it must be either an empty string or the string
- ** "localhost". ^If the authority is not an empty string or "localhost", an
- ** error is returned to the caller. ^The fragment component of a URI, if
- ** present, is ignored.
- **
- ** ^SQLite uses the path component of the URI as the name of the disk file
- ** which contains the database. ^If the path begins with a '/' character,
- ** then it is interpreted as an absolute path. ^If the path does not begin
- ** with a '/' (meaning that the authority section is omitted from the URI)
- ** then the path is interpreted as a relative path.
- ** ^On windows, the first component of an absolute path
- ** is a drive specification (e.g. "C:").
- **
- ** [[core URI query parameters]]
- ** The query component of a URI may contain parameters that are interpreted
- ** either by SQLite itself, or by a [VFS | custom VFS implementation].
- ** SQLite interprets the following three query parameters:
- **
- ** <ul>
- ** <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
- ** a VFS object that provides the operating system interface that should
- ** be used to access the database file on disk. ^If this option is set to
- ** an empty string the default VFS object is used. ^Specifying an unknown
- ** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is
- ** present, then the VFS specified by the option takes precedence over
- ** the value passed as the fourth parameter to sqlite3_open_v2().
- **
- ** <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw" or
- ** "rwc". Attempting to set it to any other value is an error)^.
- ** ^If "ro" is specified, then the database is opened for read-only
- ** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
- ** third argument to sqlite3_prepare_v2(). ^If the mode option is set to
- ** "rw", then the database is opened for read-write (but not create)
- ** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
- ** been set. ^Value "rwc" is equivalent to setting both
- ** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If sqlite3_open_v2() is
- ** used, it is an error to specify a value for the mode parameter that is
- ** less restrictive than that specified by the flags passed as the third
- ** parameter.
- **
- ** <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
- ** "private". ^Setting it to "shared" is equivalent to setting the
- ** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to
- ** sqlite3_open_v2(). ^Setting the cache parameter to "private" is
- ** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit.
- ** ^If sqlite3_open_v2() is used and the "cache" parameter is present in
- ** a URI filename, its value overrides any behaviour requested by setting
- ** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.
- ** </ul>
- **
- ** ^Specifying an unknown parameter in the query component of a URI is not an
- ** error. Future versions of SQLite might understand additional query
- ** parameters. See "[query parameters with special meaning to SQLite]" for
- ** additional information.
- **
- ** [[URI filename examples]] <h3>URI filename examples</h3>
- **
- ** <table border="1" align=center cellpadding=5>
- ** <tr><th> URI filenames <th> Results
- ** <tr><td> file:data.db <td>
- ** Open the file "data.db" in the current directory.
- ** <tr><td> file:/home/fred/data.db<br>
- ** file:///home/fred/data.db <br>
- ** file://localhost/home/fred/data.db <br> <td>
- ** Open the database file "/home/fred/data.db".
- ** <tr><td> file://darkstar/home/fred/data.db <td>
- ** An error. "darkstar" is not a recognized authority.
- ** <tr><td style="white-space:nowrap">
- ** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
- ** <td> Windows only: Open the file "data.db" on fred's desktop on drive
- ** C:. Note that the %20 escaping in this example is not strictly
- ** necessary - space characters can be used literally
- ** in URI filenames.
- ** <tr><td> file:data.db?mode=ro&cache=private <td>
- ** Open file "data.db" in the current directory for read-only access.
- ** Regardless of whether or not shared-cache mode is enabled by
- ** default, use a private cache.
- ** <tr><td> file:/home/fred/data.db?vfs=unix-nolock <td>
- ** Open file "/home/fred/data.db". Use the special VFS "unix-nolock".
- ** <tr><td> file:data.db?mode=readonly <td>
- ** An error. "readonly" is not a valid option for the "mode" parameter.
- ** </table>
- **
- ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
- ** query components of a URI. A hexadecimal escape sequence consists of a
- ** percent sign - "%" - followed by exactly two hexadecimal digits
- ** specifying an octet value. ^Before the path or query components of a
- ** URI filename are interpreted, they are encoded using UTF-8 and all
- ** hexadecimal escape sequences replaced by a single byte containing the
- ** corresponding octet. If this process generates an invalid UTF-8 encoding,
- ** the results are undefined.
- **
- ** <b>Note to Windows users:</b> The encoding used for the filename argument
- ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
- ** codepage is currently defined. Filenames containing international
- ** characters must be converted to UTF-8 prior to passing them into
- ** sqlite3_open() or sqlite3_open_v2().
- */
- SQLITE_API int sqlite3_open(
- const char *filename, /* Database filename (UTF-8) */
- sqlite3 **ppDb /* OUT: SQLite db handle */
- );
- SQLITE_API int sqlite3_open16(
- const void *filename, /* Database filename (UTF-16) */
- sqlite3 **ppDb /* OUT: SQLite db handle */
- );
- SQLITE_API int sqlite3_open_v2(
- const char *filename, /* Database filename (UTF-8) */
- sqlite3 **ppDb, /* OUT: SQLite db handle */
- int flags, /* Flags */
- const char *zVfs /* Name of VFS module to use */
- );
- /*
- ** CAPI3REF: Obtain Values For URI Parameters
- **
- ** These are utility routines, useful to VFS implementations, that check
- ** to see if a database file was a URI that contained a specific query
- ** parameter, and if so obtains the value of that query parameter.
- **
- ** If F is the database filename pointer passed into the xOpen() method of
- ** a VFS implementation when the flags parameter to xOpen() has one or
- ** more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and
- ** P is the name of the query parameter, then
- ** sqlite3_uri_parameter(F,P) returns the value of the P
- ** parameter if it exists or a NULL pointer if P does not appear as a
- ** query parameter on F. If P is a query parameter of F
- ** has no explicit value, then sqlite3_uri_parameter(F,P) returns
- ** a pointer to an empty string.
- **
- ** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean
- ** parameter and returns true (1) or false (0) according to the value
- ** of P. The value of P is true if it is "yes" or "true" or "on" or
- ** a non-zero number and is false otherwise. If P is not a query parameter
- ** on F then sqlite3_uri_boolean(F,P,B) returns (B!=0).
- **
- ** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a
- ** 64-bit signed integer and returns that integer, or D if P does not
- ** exist. If the value of P is something other than an integer, then
- ** zero is returned.
- **
- ** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and
- ** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and
- ** is not a database file pathname pointer that SQLite passed into the xOpen
- ** VFS method, then the behavior of this routine is undefined and probably
- ** undesirable.
- */
- SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
- SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
- SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
- /*
- ** CAPI3REF: Error Codes And Messages
- **
- ** ^The sqlite3_errcode() interface returns the numeric [result code] or
- ** [extended result code] for the most recent failed sqlite3_* API call
- ** associated with a [database connection]. If a prior API call failed
- ** but the most recent API call succeeded, the return value from
- ** sqlite3_errcode() is undefined. ^The sqlite3_extended_errcode()
- ** interface is the same except that it always returns the
- ** [extended result code] even when extended result codes are
- ** disabled.
- **
- ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
- ** text that describes the error, as either UTF-8 or UTF-16 respectively.
- ** ^(Memory to hold the error message string is managed internally.
- ** The application does not need to worry about freeing the result.
- ** However, the error string might be overwritten or deallocated by
- ** subsequent calls to other SQLite interface functions.)^
- **
- ** When the serialized [threading mode] is in use, it might be the
- ** case that a second error occurs on a separate thread in between
- ** the time of the first error and the call to these interfaces.
- ** When that happens, the second error will be reported since these
- ** interfaces always report the most recent result. To avoid
- ** this, each thread can obtain exclusive use of the [database connection] D
- ** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
- ** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
- ** all calls to the interfaces listed here are completed.
- **
- ** If an interface fails with SQLITE_MISUSE, that means the interface
- ** was invoked incorrectly by the application. In that case, the
- ** error code and message may or may not be set.
- */
- SQLITE_API int sqlite3_errcode(sqlite3 *db);
- SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
- SQLITE_API const char *sqlite3_errmsg(sqlite3*);
- SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
- /*
- ** CAPI3REF: SQL Statement Object
- ** KEYWORDS: {prepared statement} {prepared statements}
- **
- ** An instance of this object represents a single SQL statement.
- ** This object is variously known as a "prepared statement" or a
- ** "compiled SQL statement" or simply as a "statement".
- **
- ** The life of a statement object goes something like this:
- **
- ** <ol>
- ** <li> Create the object using [sqlite3_prepare_v2()] or a related
- ** function.
- ** <li> Bind values to [host parameters] using the sqlite3_bind_*()
- ** interfaces.
- ** <li> Run the SQL by calling [sqlite3_step()] one or more times.
- ** <li> Reset the statement using [sqlite3_reset()] then go back
- ** to step 2. Do this zero or more times.
- ** <li> Destroy the object using [sqlite3_finalize()].
- ** </ol>
- **
- ** Refer to documentation on individual methods above for additional
- ** information.
- */
- typedef struct sqlite3_stmt sqlite3_stmt;
- /*
- ** CAPI3REF: Run-time Limits
- **
- ** ^(This interface allows the size of various constructs to be limited
- ** on a connection by connection basis. The first parameter is the
- ** [database connection] whose limit is to be set or queried. The
- ** second parameter is one of the [limit categories] that define a
- ** class of constructs to be size limited. The third parameter is the
- ** new limit for that construct.)^
- **
- ** ^If the new limit is a negative number, the limit is unchanged.
- ** ^(For each limit category SQLITE_LIMIT_<i>NAME</i> there is a
- ** [limits | hard upper bound]
- ** set at compile-time by a C preprocessor macro called
- ** [limits | SQLITE_MAX_<i>NAME</i>].
- ** (The "_LIMIT_" in the name is changed to "_MAX_".))^
- ** ^Attempts to increase a limit above its hard upper bound are
- ** silently truncated to the hard upper bound.
- **
- ** ^Regardless of whether or not the limit was changed, the
- ** [sqlite3_limit()] interface returns the prior value of the limit.
- ** ^Hence, to find the current value of a limit without changing it,
- ** simply invoke this interface with the third parameter set to -1.
- **
- ** Run-time limits are intended for use in applications that manage
- ** both their own internal database and also databases that are controlled
- ** by untrusted external sources. An example application might be a
- ** web browser that has its own databases for storing history and
- ** separate databases controlled by JavaScript applications downloaded
- ** off the Internet. The internal databases can be given the
- ** large, default limits. Databases managed by external sources can
- ** be given much smaller limits designed to prevent a denial of service
- ** attack. Developers might also want to use the [sqlite3_set_authorizer()]
- ** interface to further control untrusted SQL. The size of the database
- ** created by an untrusted script can be contained using the
- ** [max_page_count] [PRAGMA].
- **
- ** New run-time limit categories may be added in future releases.
- */
- SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
- /*
- ** CAPI3REF: Run-Time Limit Categories
- ** KEYWORDS: {limit category} {*limit categories}
- **
- ** These constants define various performance limits
- ** that can be lowered at run-time using [sqlite3_limit()].
- ** The synopsis of the meanings of the various limits is shown below.
- ** Additional information is available at [limits | Limits in SQLite].
- **
- ** <dl>
- ** [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
- ** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
- **
- ** [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
- ** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
- **
- ** [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
- ** <dd>The maximum number of columns in a table definition or in the
- ** result set of a [SELECT] or the maximum number of columns in an index
- ** or in an ORDER BY or GROUP BY clause.</dd>)^
- **
- ** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
- ** <dd>The maximum depth of the parse tree on any expression.</dd>)^
- **
- ** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
- ** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
- **
- ** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
- ** <dd>The maximum number of instructions in a virtual machine program
- ** used to implement an SQL statement. This limit is not currently
- ** enforced, though that might be added in some future release of
- ** SQLite.</dd>)^
- **
- ** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
- ** <dd>The maximum number of arguments on a function.</dd>)^
- **
- ** [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
- ** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
- **
- ** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
- ** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
- ** <dd>The maximum length of the pattern argument to the [LIKE] or
- ** [GLOB] operators.</dd>)^
- **
- ** [[SQLITE_LIMIT_VARIABLE_NUMBER]]
- ** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
- ** <dd>The maximum index number of any [parameter] in an SQL statement.)^
- **
- ** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
- ** <dd>The maximum depth of recursion for triggers.</dd>)^
- ** </dl>
- */
- #define SQLITE_LIMIT_LENGTH 0
- #define SQLITE_LIMIT_SQL_LENGTH 1
- #define SQLITE_LIMIT_COLUMN 2
- #define SQLITE_LIMIT_EXPR_DEPTH 3
- #define SQLITE_LIMIT_COMPOUND_SELECT 4
- #define SQLITE_LIMIT_VDBE_OP 5
- #define SQLITE_LIMIT_FUNCTION_ARG 6
- #define SQLITE_LIMIT_ATTACHED 7
- #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8
- #define SQLITE_LIMIT_VARIABLE_NUMBER 9
- #define SQLITE_LIMIT_TRIGGER_DEPTH 10
- /*
- ** CAPI3REF: Compiling An SQL Statement
- ** KEYWORDS: {SQL statement compiler}
- **
- ** To execute an SQL query, it must first be compiled into a byte-code
- ** program using one of these routines.
- **
- ** The first argument, "db", is a [database connection] obtained from a
- ** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
- ** [sqlite3_open16()]. The database connection must not have been closed.
- **
- ** The second argument, "zSql", is the statement to be compiled, encoded
- ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2()
- ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
- ** use UTF-16.
- **
- ** ^If the nByte argument is less than zero, then zSql is read up to the
- ** first zero terminator. ^If nByte is non-negative, then it is the maximum
- ** number of bytes read from zSql. ^When nByte is non-negative, the
- ** zSql string ends at either the first '\000' or '\u0000' character or
- ** the nByte-th byte, whichever comes first. If the caller knows
- ** that the supplied string is nul-terminated, then there is a small
- ** performance advantage to be gained by passing an nByte parameter that
- ** is equal to the number of bytes in the input string <i>including</i>
- ** the nul-terminator bytes as this saves SQLite from having to
- ** make a copy of the input string.
- **
- ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
- ** past the end of the first SQL statement in zSql. These routines only
- ** compile the first statement in zSql, so *pzTail is left pointing to
- ** what remains uncompiled.
- **
- ** ^*ppStmt is left pointing to a compiled [prepared statement] that can be
- ** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set
- ** to NULL. ^If the input text contains no SQL (if the input is an empty
- ** string or a comment) then *ppStmt is set to NULL.
- ** The calling procedure is responsible for deleting the compiled
- ** SQL statement using [sqlite3_finalize()] after it has finished with it.
- ** ppStmt may not be NULL.
- **
- ** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
- ** otherwise an [error code] is returned.
- **
- ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
- ** recommended for all new programs. The two older interfaces are retained
- ** for backwards compatibility, but their use is discouraged.
- ** ^In the "v2" interfaces, the prepared statement
- ** that is returned (the [sqlite3_stmt] object) contains a copy of the
- ** original SQL text. This causes the [sqlite3_step()] interface to
- ** behave differently in three ways:
- **
- ** <ol>
- ** <li>
- ** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
- ** always used to do, [sqlite3_step()] will automatically recompile the SQL
- ** statement and try to run it again.
- ** </li>
- **
- ** <li>
- ** ^When an error occurs, [sqlite3_step()] will return one of the detailed
- ** [error codes] or [extended error codes]. ^The legacy behavior was that
- ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
- ** and the application would have to make a second call to [sqlite3_reset()]
- ** in order to find the underlying cause of the problem. With the "v2" prepare
- ** interfaces, the underlying reason for the error is returned immediately.
- ** </li>
- **
- ** <li>
- ** ^If the specific value bound to [parameter | host parameter] in the
- ** WHERE clause might influence the choice of query plan for a statement,
- ** then the statement will be automatically recompiled, as if there had been
- ** a schema change, on the first [sqlite3_step()] call following any change
- ** to the [sqlite3_bind_text | bindings] of that [parameter].
- ** ^The specific value of WHERE-clause [parameter] might influence the
- ** choice of query plan if the parameter is the left-hand side of a [LIKE]
- ** or [GLOB] operator or if the parameter is compared to an indexed column
- ** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled.
- ** the
- ** </li>
- ** </ol>
- */
- SQLITE_API int sqlite3_prepare(
- sqlite3 *db, /* Database handle */
- const char *zSql, /* SQL statement, UTF-8 encoded */
- int nByte, /* Maximum length of zSql in bytes. */
- sqlite3_stmt **ppStmt, /* OUT: Statement handle */
- const char **pzTail /* OUT: Pointer to unused portion of zSql */
- );
- SQLITE_API int sqlite3_prepare_v2(
- sqlite3 *db, /* Database handle */
- const char *zSql, /* SQL statement, UTF-8 encoded */
- int nByte, /* Maximum length of zSql in bytes. */
- sqlite3_stmt **ppStmt, /* OUT: Statement handle */
- const char **pzTail /* OUT: Pointer to unused portion of zSql */
- );
- SQLITE_API int sqlite3_prepare16(
- sqlite3 *db, /* Database handle */
- const void *zSql, /* SQL statement, UTF-16 encoded */
- int nByte, /* Maximum length of zSql in bytes. */
- sqlite3_stmt **ppStmt, /* OUT: Statement handle */
- const void **pzTail /* OUT: Pointer to unused portion of zSql */
- );
- SQLITE_API int sqlite3_prepare16_v2(
- sqlite3 *db, /* Database handle */
- const void *zSql, /* SQL statement, UTF-16 encoded */
- int nByte, /* Maximum length of zSql in bytes. */
- sqlite3_stmt **ppStmt, /* OUT: Statement handle */
- const void **pzTail /* OUT: Pointer to unused portion of zSql */
- );
- /*
- ** CAPI3REF: Retrieving Statement SQL
- **
- ** ^This interface can be used to retrieve a saved copy of the original
- ** SQL text used to create a [prepared statement] if that statement was
- ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
- */
- SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Determine If An SQL Statement Writes The Database
- **
- ** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
- ** and only if the [prepared statement] X makes no direct changes to
- ** the content of the database file.
- **
- ** Note that [application-defined SQL functions] or
- ** [virtual tables] might change the database indirectly as a side effect.
- ** ^(For example, if an application defines a function "eval()" that
- ** calls [sqlite3_exec()], then the following SQL statement would
- ** change the database file through side-effects:
- **
- ** <blockquote><pre>
- ** SELECT eval('DELETE FROM t1') FROM t2;
- ** </pre></blockquote>
- **
- ** But because the [SELECT] statement does not change the database file
- ** directly, sqlite3_stmt_readonly() would still return true.)^
- **
- ** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],
- ** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true,
- ** since the statements themselves do not actually modify the database but
- ** rather they control the timing of when other statements modify the
- ** database. ^The [ATTACH] and [DETACH] statements also cause
- ** sqlite3_stmt_readonly() to return true since, while those statements
- ** change the configuration of a database connection, they do not make
- ** changes to the content of the database files on disk.
- */
- SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Determine If A Prepared Statement Has Been Reset
- **
- ** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
- ** [prepared statement] S has been stepped at least once using
- ** [sqlite3_step(S)] but has not run to completion and/or has not
- ** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S)
- ** interface returns false if S is a NULL pointer. If S is not a
- ** NULL pointer and is not a pointer to a valid [prepared statement]
- ** object, then the behavior is undefined and probably undesirable.
- **
- ** This interface can be used in combination [sqlite3_next_stmt()]
- ** to locate all prepared statements associated with a database
- ** connection that are in need of being reset. This can be used,
- ** for example, in diagnostic routines to search for prepared
- ** statements that are holding a transaction open.
- */
- SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
- /*
- ** CAPI3REF: Dynamically Typed Value Object
- ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
- **
- ** SQLite uses the sqlite3_value object to represent all values
- ** that can be stored in a database table. SQLite uses dynamic typing
- ** for the values it stores. ^Values stored in sqlite3_value objects
- ** can be integers, floating point values, strings, BLOBs, or NULL.
- **
- ** An sqlite3_value object may be either "protected" or "unprotected".
- ** Some interfaces require a protected sqlite3_value. Other interfaces
- ** will accept either a protected or an unprotected sqlite3_value.
- ** Every interface that accepts sqlite3_value arguments specifies
- ** whether or not it requires a protected sqlite3_value.
- **
- ** The terms "protected" and "unprotected" refer to whether or not
- ** a mutex is held. An internal mutex is held for a protected
- ** sqlite3_value object but no mutex is held for an unprotected
- ** sqlite3_value object. If SQLite is compiled to be single-threaded
- ** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0)
- ** or if SQLite is run in one of reduced mutex modes
- ** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
- ** then there is no distinction between protected and unprotected
- ** sqlite3_value objects and they can be used interchangeably. However,
- ** for maximum code portability it is recommended that applications
- ** still make the distinction between protected and unprotected
- ** sqlite3_value objects even when not strictly required.
- **
- ** ^The sqlite3_value objects that are passed as parameters into the
- ** implementation of [application-defined SQL functions] are protected.
- ** ^The sqlite3_value object returned by
- ** [sqlite3_column_value()] is unprotected.
- ** Unprotected sqlite3_value objects may only be used with
- ** [sqlite3_result_value()] and [sqlite3_bind_value()].
- ** The [sqlite3_value_blob | sqlite3_value_type()] family of
- ** interfaces require protected sqlite3_value objects.
- */
- typedef struct Mem sqlite3_value;
- /*
- ** CAPI3REF: SQL Function Context Object
- **
- ** The context in which an SQL function executes is stored in an
- ** sqlite3_context object. ^A pointer to an sqlite3_context object
- ** is always first parameter to [application-defined SQL functions].
- ** The application-defined SQL function implementation will pass this
- ** pointer through into calls to [sqlite3_result_int | sqlite3_result()],
- ** [sqlite3_aggregate_context()], [sqlite3_user_data()],
- ** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
- ** and/or [sqlite3_set_auxdata()].
- */
- typedef struct sqlite3_context sqlite3_context;
- /*
- ** CAPI3REF: Binding Values To Prepared Statements
- ** KEYWORDS: {host parameter} {host parameters} {host parameter name}
- ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
- **
- ** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
- ** literals may be replaced by a [parameter] that matches one of following
- ** templates:
- **
- ** <ul>
- ** <li> ?
- ** <li> ?NNN
- ** <li> :VVV
- ** <li> @VVV
- ** <li> $VVV
- ** </ul>
- **
- ** In the templates above, NNN represents an integer literal,
- ** and VVV represents an alphanumeric identifier.)^ ^The values of these
- ** parameters (also called "host parameter names" or "SQL parameters")
- ** can be set using the sqlite3_bind_*() routines defined here.
- **
- ** ^The first argument to the sqlite3_bind_*() routines is always
- ** a pointer to the [sqlite3_stmt] object returned from
- ** [sqlite3_prepare_v2()] or its variants.
- **
- ** ^The second argument is the index of the SQL parameter to be set.
- ** ^The leftmost SQL parameter has an index of 1. ^When the same named
- ** SQL parameter is used more than once, second and subsequent
- ** occurrences have the same index as the first occurrence.
- ** ^The index for named parameters can be looked up using the
- ** [sqlite3_bind_parameter_index()] API if desired. ^The index
- ** for "?NNN" parameters is the value of NNN.
- ** ^The NNN value must be between 1 and the [sqlite3_limit()]
- ** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).
- **
- ** ^The third argument is the value to bind to the parameter.
- **
- ** ^(In those routines that have a fourth argument, its value is the
- ** number of bytes in the parameter. To be clear: the value is the
- ** number of <u>bytes</u> in the value, not the number of characters.)^
- ** ^If the fourth parameter is negative, the length of the string is
- ** the number of bytes up to the first zero terminator.
- ** If a non-negative fourth parameter is provided to sqlite3_bind_text()
- ** or sqlite3_bind_text16() then that parameter must be the byte offset
- ** where the NUL terminator would occur assuming the string were NUL
- ** terminated. If any NUL characters occur at byte offsets less than
- ** the value of the fourth parameter then the resulting string value will
- ** contain embedded NULs. The result of expressions involving strings
- ** with embedded NULs is undefined.
- **
- ** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
- ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
- ** string after SQLite has finished with it. ^The destructor is called
- ** to dispose of the BLOB or string even if the call to sqlite3_bind_blob(),
- ** sqlite3_bind_text(), or sqlite3_bind_text16() fails.
- ** ^If the fifth argument is
- ** the special value [SQLITE_STATIC], then SQLite assumes that the
- ** information is in static, unmanaged space and does not need to be freed.
- ** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
- ** SQLite makes its own private copy of the data immediately, before
- ** the sqlite3_bind_*() routine returns.
- **
- ** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
- ** is filled with zeroes. ^A zeroblob uses a fixed amount of memory
- ** (just an integer to hold its size) while it is being processed.
- ** Zeroblobs are intended to serve as placeholders for BLOBs whose
- ** content is later written using
- ** [sqlite3_blob_open | incremental BLOB I/O] routines.
- ** ^A negative value for the zeroblob results in a zero-length BLOB.
- **
- ** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer
- ** for the [prepared statement] or with a prepared statement for which
- ** [sqlite3_step()] has been called more recently than [sqlite3_reset()],
- ** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_()
- ** routine is passed a [prepared statement] that has been finalized, the
- ** result is undefined and probably harmful.
- **
- ** ^Bindings are not cleared by the [sqlite3_reset()] routine.
- ** ^Unbound parameters are interpreted as NULL.
- **
- ** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
- ** [error code] if anything goes wrong.
- ** ^[SQLITE_RANGE] is returned if the parameter
- ** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails.
- **
- ** See also: [sqlite3_bind_parameter_count()],
- ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
- */
- SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
- SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
- SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
- SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
- SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
- SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
- SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
- SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
- SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
- /*
- ** CAPI3REF: Number Of SQL Parameters
- **
- ** ^This routine can be used to find the number of [SQL parameters]
- ** in a [prepared statement]. SQL parameters are tokens of the
- ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
- ** placeholders for values that are [sqlite3_bind_blob | bound]
- ** to the parameters at a later time.
- **
- ** ^(This routine actually returns the index of the largest (rightmost)
- ** parameter. For all forms except ?NNN, this will correspond to the
- ** number of unique parameters. If parameters of the ?NNN form are used,
- ** there may be gaps in the list.)^
- **
- ** See also: [sqlite3_bind_blob|sqlite3_bind()],
- ** [sqlite3_bind_parameter_name()], and
- ** [sqlite3_bind_parameter_index()].
- */
- SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
- /*
- ** CAPI3REF: Name Of A Host Parameter
- **
- ** ^The sqlite3_bind_parameter_name(P,N) interface returns
- ** the name of the N-th [SQL parameter] in the [prepared statement] P.
- ** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
- ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
- ** respectively.
- ** In other words, the initial ":" or "$" or "@" or "?"
- ** is included as part of the name.)^
- ** ^Parameters of the form "?" without a following integer have no name
- ** and are referred to as "nameless" or "anonymous parameters".
- **
- ** ^The first host parameter has an index of 1, not 0.
- **
- ** ^If the value N is out of range or if the N-th parameter is
- ** nameless, then NULL is returned. ^The returned string is
- ** always in UTF-8 encoding even if the named parameter was
- ** originally specified as UTF-16 in [sqlite3_prepare16()] or
- ** [sqlite3_prepare16_v2()].
- **
- ** See also: [sqlite3_bind_blob|sqlite3_bind()],
- ** [sqlite3_bind_parameter_count()], and
- ** [sqlite3_bind_parameter_index()].
- */
- SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
- /*
- ** CAPI3REF: Index Of A Parameter With A Given Name
- **
- ** ^Return the index of an SQL parameter given its name. ^The
- ** index value returned is suitable for use as the second
- ** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero
- ** is returned if no matching parameter is found. ^The parameter
- ** name must be given in UTF-8 even if the original statement
- ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
- **
- ** See also: [sqlite3_bind_blob|sqlite3_bind()],
- ** [sqlite3_bind_parameter_count()], and
- ** [sqlite3_bind_parameter_index()].
- */
- SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
- /*
- ** CAPI3REF: Reset All Bindings On A Prepared Statement
- **
- ** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
- ** the [sqlite3_bind_blob | bindings] on a [prepared statement].
- ** ^Use this routine to reset all host parameters to NULL.
- */
- SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
- /*
- ** CAPI3REF: Number Of Columns In A Result Set
- **
- ** ^Return the number of columns in the result set returned by the
- ** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
- ** statement that does not return data (for example an [UPDATE]).
- **
- ** See also: [sqlite3_data_count()]
- */
- SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Column Names In A Result Set
- **
- ** ^These routines return the name assigned to a particular column
- ** in the result set of a [SELECT] statement. ^The sqlite3_column_name()
- ** interface returns a pointer to a zero-terminated UTF-8 string
- ** and sqlite3_column_name16() returns a pointer to a zero-terminated
- ** UTF-16 string. ^The first parameter is the [prepared statement]
- ** that implements the [SELECT] statement. ^The second parameter is the
- ** column number. ^The leftmost column is number 0.
- **
- ** ^The returned string pointer is valid until either the [prepared statement]
- ** is destroyed by [sqlite3_finalize()] or until the statement is automatically
- ** reprepared by the first call to [sqlite3_step()] for a particular run
- ** or until the next call to
- ** sqlite3_column_name() or sqlite3_column_name16() on the same column.
- **
- ** ^If sqlite3_malloc() fails during the processing of either routine
- ** (for example during a conversion from UTF-8 to UTF-16) then a
- ** NULL pointer is returned.
- **
- ** ^The name of a result column is the value of the "AS" clause for
- ** that column, if there is an AS clause. If there is no AS clause
- ** then the name of the column is unspecified and may change from
- ** one release of SQLite to the next.
- */
- SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
- SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
- /*
- ** CAPI3REF: Source Of Data In A Query Result
- **
- ** ^These routines provide a means to determine the database, table, and
- ** table column that is the origin of a particular result column in
- ** [SELECT] statement.
- ** ^The name of the database or table or column can be returned as
- ** either a UTF-8 or UTF-16 string. ^The _database_ routines return
- ** the database name, the _table_ routines return the table name, and
- ** the origin_ routines return the column name.
- ** ^The returned string is valid until the [prepared statement] is destroyed
- ** using [sqlite3_finalize()] or until the statement is automatically
- ** reprepared by the first call to [sqlite3_step()] for a particular run
- ** or until the same information is requested
- ** again in a different encoding.
- **
- ** ^The names returned are the original un-aliased names of the
- ** database, table, and column.
- **
- ** ^The first argument to these interfaces is a [prepared statement].
- ** ^These functions return information about the Nth result column returned by
- ** the statement, where N is the second function argument.
- ** ^The left-most column is column 0 for these routines.
- **
- ** ^If the Nth column returned by the statement is an expression or
- ** subquery and is not a column value, then all of these functions return
- ** NULL. ^These routine might also return NULL if a memory allocation error
- ** occurs. ^Otherwise, they return the name of the attached database, table,
- ** or column that query result column was extracted from.
- **
- ** ^As with all other SQLite APIs, those whose names end with "16" return
- ** UTF-16 encoded strings and the other functions return UTF-8.
- **
- ** ^These APIs are only available if the library was compiled with the
- ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
- **
- ** If two or more threads call one or more of these routines against the same
- ** prepared statement and column at the same time then the results are
- ** undefined.
- **
- ** If two or more threads call one or more
- ** [sqlite3_column_database_name | column metadata interfaces]
- ** for the same [prepared statement] and result column
- ** at the same time then the results are undefined.
- */
- SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
- SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
- SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
- SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
- SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
- SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
- /*
- ** CAPI3REF: Declared Datatype Of A Query Result
- **
- ** ^(The first parameter is a [prepared statement].
- ** If this statement is a [SELECT] statement and the Nth column of the
- ** returned result set of that [SELECT] is a table column (not an
- ** expression or subquery) then the declared type of the table
- ** column is returned.)^ ^If the Nth column of the result set is an
- ** expression or subquery, then a NULL pointer is returned.
- ** ^The returned string is always UTF-8 encoded.
- **
- ** ^(For example, given the database schema:
- **
- ** CREATE TABLE t1(c1 VARIANT);
- **
- ** and the following statement to be compiled:
- **
- ** SELECT c1 + 1, c1 FROM t1;
- **
- ** this routine would return the string "VARIANT" for the second result
- ** column (i==1), and a NULL pointer for the first result column (i==0).)^
- **
- ** ^SQLite uses dynamic run-time typing. ^So just because a column
- ** is declared to contain a particular type does not mean that the
- ** data stored in that column is of the declared type. SQLite is
- ** strongly typed, but the typing is dynamic not static. ^Type
- ** is associated with individual values, not with the containers
- ** used to hold those values.
- */
- SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
- SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
- /*
- ** CAPI3REF: Evaluate An SQL Statement
- **
- ** After a [prepared statement] has been prepared using either
- ** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
- ** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function
- ** must be called one or more times to evaluate the statement.
- **
- ** The details of the behavior of the sqlite3_step() interface depend
- ** on whether the statement was prepared using the newer "v2" interface
- ** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
- ** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the
- ** new "v2" interface is recommended for new applications but the legacy
- ** interface will continue to be supported.
- **
- ** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
- ** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
- ** ^With the "v2" interface, any of the other [result codes] or
- ** [extended result codes] might be returned as well.
- **
- ** ^[SQLITE_BUSY] means that the database engine was unable to acquire the
- ** database locks it needs to do its job. ^If the statement is a [COMMIT]
- ** or occurs outside of an explicit transaction, then you can retry the
- ** statement. If the statement is not a [COMMIT] and occurs within an
- ** explicit transaction then you should rollback the transaction before
- ** continuing.
- **
- ** ^[SQLITE_DONE] means that the statement has finished executing
- ** successfully. sqlite3_step() should not be called again on this virtual
- ** machine without first calling [sqlite3_reset()] to reset the virtual
- ** machine back to its initial state.
- **
- ** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
- ** is returned each time a new row of data is ready for processing by the
- ** caller. The values may be accessed using the [column access functions].
- ** sqlite3_step() is called again to retrieve the next row of data.
- **
- ** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
- ** violation) has occurred. sqlite3_step() should not be called again on
- ** the VM. More information may be found by calling [sqlite3_errmsg()].
- ** ^With the legacy interface, a more specific error code (for example,
- ** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
- ** can be obtained by calling [sqlite3_reset()] on the
- ** [prepared statement]. ^In the "v2" interface,
- ** the more specific error code is returned directly by sqlite3_step().
- **
- ** [SQLITE_MISUSE] means that the this routine was called inappropriately.
- ** Perhaps it was called on a [prepared statement] that has
- ** already been [sqlite3_finalize | finalized] or on one that had
- ** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could
- ** be the case that the same database connection is being used by two or
- ** more threads at the same moment in time.
- **
- ** For all versions of SQLite up to and including 3.6.23.1, a call to
- ** [sqlite3_reset()] was required after sqlite3_step() returned anything
- ** other than [SQLITE_ROW] before any subsequent invocation of
- ** sqlite3_step(). Failure to reset the prepared statement using
- ** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from
- ** sqlite3_step(). But after version 3.6.23.1, sqlite3_step() began
- ** calling [sqlite3_reset()] automatically in this circumstance rather
- ** than returning [SQLITE_MISUSE]. This is not considered a compatibility
- ** break because any application that ever receives an SQLITE_MISUSE error
- ** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option
- ** can be used to restore the legacy behavior.
- **
- ** <b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step()
- ** API always returns a generic error code, [SQLITE_ERROR], following any
- ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call
- ** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the
- ** specific [error codes] that better describes the error.
- ** We admit that this is a goofy design. The problem has been fixed
- ** with the "v2" interface. If you prepare all of your SQL statements
- ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
- ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces,
- ** then the more specific [error codes] are returned directly
- ** by sqlite3_step(). The use of the "v2" interface is recommended.
- */
- SQLITE_API int sqlite3_step(sqlite3_stmt*);
- /*
- ** CAPI3REF: Number of columns in a result set
- **
- ** ^The sqlite3_data_count(P) interface returns the number of columns in the
- ** current row of the result set of [prepared statement] P.
- ** ^If prepared statement P does not have results ready to return
- ** (via calls to the [sqlite3_column_int | sqlite3_column_*()] of
- ** interfaces) then sqlite3_data_count(P) returns 0.
- ** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer.
- ** ^The sqlite3_data_count(P) routine returns 0 if the previous call to
- ** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P)
- ** will return non-zero if previous call to [sqlite3_step](P) returned
- ** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum]
- ** where it always returns zero since each step of that multi-step
- ** pragma returns 0 columns of data.
- **
- ** See also: [sqlite3_column_count()]
- */
- SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Fundamental Datatypes
- ** KEYWORDS: SQLITE_TEXT
- **
- ** ^(Every value in SQLite has one of five fundamental datatypes:
- **
- ** <ul>
- ** <li> 64-bit signed integer
- ** <li> 64-bit IEEE floating point number
- ** <li> string
- ** <li> BLOB
- ** <li> NULL
- ** </ul>)^
- **
- ** These constants are codes for each of those types.
- **
- ** Note that the SQLITE_TEXT constant was also used in SQLite version 2
- ** for a completely different meaning. Software that links against both
- ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
- ** SQLITE_TEXT.
- */
- #define SQLITE_INTEGER 1
- #define SQLITE_FLOAT 2
- #define SQLITE_BLOB 4
- #define SQLITE_NULL 5
- #ifdef SQLITE_TEXT
- # undef SQLITE_TEXT
- #else
- # define SQLITE_TEXT 3
- #endif
- #define SQLITE3_TEXT 3
- /*
- ** CAPI3REF: Result Values From A Query
- ** KEYWORDS: {column access functions}
- **
- ** These routines form the "result set" interface.
- **
- ** ^These routines return information about a single column of the current
- ** result row of a query. ^In every case the first argument is a pointer
- ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
- ** that was returned from [sqlite3_prepare_v2()] or one of its variants)
- ** and the second argument is the index of the column for which information
- ** should be returned. ^The leftmost column of the result set has the index 0.
- ** ^The number of columns in the result can be determined using
- ** [sqlite3_column_count()].
- **
- ** If the SQL statement does not currently point to a valid row, or if the
- ** column index is out of range, the result is undefined.
- ** These routines may only be called when the most recent call to
- ** [sqlite3_step()] has returned [SQLITE_ROW] and neither
- ** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
- ** If any of these routines are called after [sqlite3_reset()] or
- ** [sqlite3_finalize()] or after [sqlite3_step()] has returned
- ** something other than [SQLITE_ROW], the results are undefined.
- ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
- ** are called from a different thread while any of these routines
- ** are pending, then the results are undefined.
- **
- ** ^The sqlite3_column_type() routine returns the
- ** [SQLITE_INTEGER | datatype code] for the initial data type
- ** of the result column. ^The returned value is one of [SQLITE_INTEGER],
- ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value
- ** returned by sqlite3_column_type() is only meaningful if no type
- ** conversions have occurred as described below. After a type conversion,
- ** the value returned by sqlite3_column_type() is undefined. Future
- ** versions of SQLite may change the behavior of sqlite3_column_type()
- ** following a type conversion.
- **
- ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
- ** routine returns the number of bytes in that BLOB or string.
- ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
- ** the string to UTF-8 and then returns the number of bytes.
- ** ^If the result is a numeric value then sqlite3_column_bytes() uses
- ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
- ** the number of bytes in that string.
- ** ^If the result is NULL, then sqlite3_column_bytes() returns zero.
- **
- ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
- ** routine returns the number of bytes in that BLOB or string.
- ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
- ** the string to UTF-16 and then returns the number of bytes.
- ** ^If the result is a numeric value then sqlite3_column_bytes16() uses
- ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
- ** the number of bytes in that string.
- ** ^If the result is NULL, then sqlite3_column_bytes16() returns zero.
- **
- ** ^The values returned by [sqlite3_column_bytes()] and
- ** [sqlite3_column_bytes16()] do not include the zero terminators at the end
- ** of the string. ^For clarity: the values returned by
- ** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of
- ** bytes in the string, not the number of characters.
- **
- ** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
- ** even empty strings, are always zero-terminated. ^The return
- ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
- **
- ** ^The object returned by [sqlite3_column_value()] is an
- ** [unprotected sqlite3_value] object. An unprotected sqlite3_value object
- ** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()].
- ** If the [unprotected sqlite3_value] object returned by
- ** [sqlite3_column_value()] is used in any other way, including calls
- ** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
- ** or [sqlite3_value_bytes()], then the behavior is undefined.
- **
- ** These routines attempt to convert the value where appropriate. ^For
- ** example, if the internal representation is FLOAT and a text result
- ** is requested, [sqlite3_snprintf()] is used internally to perform the
- ** conversion automatically. ^(The following table details the conversions
- ** that are applied:
- **
- ** <blockquote>
- ** <table border="1">
- ** <tr><th> Internal<br>Type <th> Requested<br>Type <th> Conversion
- **
- ** <tr><td> NULL <td> INTEGER <td> Result is 0
- ** <tr><td> NULL <td> FLOAT <td> Result is 0.0
- ** <tr><td> NULL <td> TEXT <td> Result is NULL pointer
- ** <tr><td> NULL <td> BLOB <td> Result is NULL pointer
- ** <tr><td> INTEGER <td> FLOAT <td> Convert from integer to float
- ** <tr><td> INTEGER <td> TEXT <td> ASCII rendering of the integer
- ** <tr><td> INTEGER <td> BLOB <td> Same as INTEGER->TEXT
- ** <tr><td> FLOAT <td> INTEGER <td> Convert from float to integer
- ** <tr><td> FLOAT <td> TEXT <td> ASCII rendering of the float
- ** <tr><td> FLOAT <td> BLOB <td> Same as FLOAT->TEXT
- ** <tr><td> TEXT <td> INTEGER <td> Use atoi()
- ** <tr><td> TEXT <td> FLOAT <td> Use atof()
- ** <tr><td> TEXT <td> BLOB <td> No change
- ** <tr><td> BLOB <td> INTEGER <td> Convert to TEXT then use atoi()
- ** <tr><td> BLOB <td> FLOAT <td> Convert to TEXT then use atof()
- ** <tr><td> BLOB <td> TEXT <td> Add a zero terminator if needed
- ** </table>
- ** </blockquote>)^
- **
- ** The table above makes reference to standard C library functions atoi()
- ** and atof(). SQLite does not really use these functions. It has its
- ** own equivalent internal routines. The atoi() and atof() names are
- ** used in the table for brevity and because they are familiar to most
- ** C programmers.
- **
- ** Note that when type conversions occur, pointers returned by prior
- ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
- ** sqlite3_column_text16() may be invalidated.
- ** Type conversions and pointer invalidations might occur
- ** in the following cases:
- **
- ** <ul>
- ** <li> The initial content is a BLOB and sqlite3_column_text() or
- ** sqlite3_column_text16() is called. A zero-terminator might
- ** need to be added to the string.</li>
- ** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
- ** sqlite3_column_text16() is called. The content must be converted
- ** to UTF-16.</li>
- ** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
- ** sqlite3_column_text() is called. The content must be converted
- ** to UTF-8.</li>
- ** </ul>
- **
- ** ^Conversions between UTF-16be and UTF-16le are always done in place and do
- ** not invalidate a prior pointer, though of course the content of the buffer
- ** that the prior pointer references will have been modified. Other kinds
- ** of conversion are done in place when it is possible, but sometimes they
- ** are not possible and in those cases prior pointers are invalidated.
- **
- ** The safest and easiest to remember policy is to invoke these routines
- ** in one of the following ways:
- **
- ** <ul>
- ** <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
- ** <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
- ** <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
- ** </ul>
- **
- ** In other words, you should call sqlite3_column_text(),
- ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
- ** into the desired format, then invoke sqlite3_column_bytes() or
- ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
- ** to sqlite3_column_text() or sqlite3_column_blob() with calls to
- ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
- ** with calls to sqlite3_column_bytes().
- **
- ** ^The pointers returned are valid until a type conversion occurs as
- ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
- ** [sqlite3_finalize()] is called. ^The memory space used to hold strings
- ** and BLOBs is freed automatically. Do <b>not</b> pass the pointers returned
- ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
- ** [sqlite3_free()].
- **
- ** ^(If a memory allocation error occurs during the evaluation of any
- ** of these routines, a default value is returned. The default value
- ** is either the integer 0, the floating point number 0.0, or a NULL
- ** pointer. Subsequent calls to [sqlite3_errcode()] will return
- ** [SQLITE_NOMEM].)^
- */
- SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
- SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
- SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
- SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
- SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
- SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
- SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
- SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
- SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
- SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
- /*
- ** CAPI3REF: Destroy A Prepared Statement Object
- **
- ** ^The sqlite3_finalize() function is called to delete a [prepared statement].
- ** ^If the most recent evaluation of the statement encountered no errors
- ** or if the statement is never been evaluated, then sqlite3_finalize() returns
- ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
- ** sqlite3_finalize(S) returns the appropriate [error code] or
- ** [extended error code].
- **
- ** ^The sqlite3_finalize(S) routine can be called at any point during
- ** the life cycle of [prepared statement] S:
- ** before statement S is ever evaluated, after
- ** one or more calls to [sqlite3_reset()], or after any call
- ** to [sqlite3_step()] regardless of whether or not the statement has
- ** completed execution.
- **
- ** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op.
- **
- ** The application must finalize every [prepared statement] in order to avoid
- ** resource leaks. It is a grievous error for the application to try to use
- ** a prepared statement after it has been finalized. Any use of a prepared
- ** statement after it has been finalized can result in undefined and
- ** undesirable behavior such as segfaults and heap corruption.
- */
- SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Reset A Prepared Statement Object
- **
- ** The sqlite3_reset() function is called to reset a [prepared statement]
- ** object back to its initial state, ready to be re-executed.
- ** ^Any SQL statement variables that had values bound to them using
- ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
- ** Use [sqlite3_clear_bindings()] to reset the bindings.
- **
- ** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S
- ** back to the beginning of its program.
- **
- ** ^If the most recent call to [sqlite3_step(S)] for the
- ** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
- ** or if [sqlite3_step(S)] has never before been called on S,
- ** then [sqlite3_reset(S)] returns [SQLITE_OK].
- **
- ** ^If the most recent call to [sqlite3_step(S)] for the
- ** [prepared statement] S indicated an error, then
- ** [sqlite3_reset(S)] returns an appropriate [error code].
- **
- ** ^The [sqlite3_reset(S)] interface does not change the values
- ** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
- */
- SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Create Or Redefine SQL Functions
- ** KEYWORDS: {function creation routines}
- ** KEYWORDS: {application-defined SQL function}
- ** KEYWORDS: {application-defined SQL functions}
- **
- ** ^These functions (collectively known as "function creation routines")
- ** are used to add SQL functions or aggregates or to redefine the behavior
- ** of existing SQL functions or aggregates. The only differences between
- ** these routines are the text encoding expected for
- ** the second parameter (the name of the function being created)
- ** and the presence or absence of a destructor callback for
- ** the application data pointer.
- **
- ** ^The first parameter is the [database connection] to which the SQL
- ** function is to be added. ^If an application uses more than one database
- ** connection then application-defined SQL functions must be added
- ** to each database connection separately.
- **
- ** ^The second parameter is the name of the SQL function to be created or
- ** redefined. ^The length of the name is limited to 255 bytes in a UTF-8
- ** representation, exclusive of the zero-terminator. ^Note that the name
- ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
- ** ^Any attempt to create a function with a longer name
- ** will result in [SQLITE_MISUSE] being returned.
- **
- ** ^The third parameter (nArg)
- ** is the number of arguments that the SQL function or
- ** aggregate takes. ^If this parameter is -1, then the SQL function or
- ** aggregate may take any number of arguments between 0 and the limit
- ** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third
- ** parameter is less than -1 or greater than 127 then the behavior is
- ** undefined.
- **
- ** ^The fourth parameter, eTextRep, specifies what
- ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
- ** its parameters. Every SQL function implementation must be able to work
- ** with UTF-8, UTF-16le, or UTF-16be. But some implementations may be
- ** more efficient with one encoding than another. ^An application may
- ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
- ** times with the same function but with different values of eTextRep.
- ** ^When multiple implementations of the same function are available, SQLite
- ** will pick the one that involves the least amount of data conversion.
- ** If there is only a single implementation which does not care what text
- ** encoding is used, then the fourth argument should be [SQLITE_ANY].
- **
- ** ^(The fifth parameter is an arbitrary pointer. The implementation of the
- ** function can gain access to this pointer using [sqlite3_user_data()].)^
- **
- ** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are
- ** pointers to C-language functions that implement the SQL function or
- ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
- ** callback only; NULL pointers must be passed as the xStep and xFinal
- ** parameters. ^An aggregate SQL function requires an implementation of xStep
- ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
- ** SQL function or aggregate, pass NULL pointers for all three function
- ** callbacks.
- **
- ** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,
- ** then it is destructor for the application data pointer.
- ** The destructor is invoked when the function is deleted, either by being
- ** overloaded or when the database connection closes.)^
- ** ^The destructor is also invoked if the call to
- ** sqlite3_create_function_v2() fails.
- ** ^When the destructor callback of the tenth parameter is invoked, it
- ** is passed a single argument which is a copy of the application data
- ** pointer which was the fifth parameter to sqlite3_create_function_v2().
- **
- ** ^It is permitted to register multiple implementations of the same
- ** functions with the same name but with either differing numbers of
- ** arguments or differing preferred text encodings. ^SQLite will use
- ** the implementation that most closely matches the way in which the
- ** SQL function is used. ^A function implementation with a non-negative
- ** nArg parameter is a better match than a function implementation with
- ** a negative nArg. ^A function where the preferred text encoding
- ** matches the database encoding is a better
- ** match than a function where the encoding is different.
- ** ^A function where the encoding difference is between UTF16le and UTF16be
- ** is a closer match than a function where the encoding difference is
- ** between UTF8 and UTF16.
- **
- ** ^Built-in functions may be overloaded by new application-defined functions.
- **
- ** ^An application-defined function is permitted to call other
- ** SQLite interfaces. However, such calls must not
- ** close the database connection nor finalize or reset the prepared
- ** statement in which the function is running.
- */
- SQLITE_API int sqlite3_create_function(
- sqlite3 *db,
- const char *zFunctionName,
- int nArg,
- int eTextRep,
- void *pApp,
- void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
- void (*xStep)(sqlite3_context*,int,sqlite3_value**),
- void (*xFinal)(sqlite3_context*)
- );
- SQLITE_API int sqlite3_create_function16(
- sqlite3 *db,
- const void *zFunctionName,
- int nArg,
- int eTextRep,
- void *pApp,
- void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
- void (*xStep)(sqlite3_context*,int,sqlite3_value**),
- void (*xFinal)(sqlite3_context*)
- );
- SQLITE_API int sqlite3_create_function_v2(
- sqlite3 *db,
- const char *zFunctionName,
- int nArg,
- int eTextRep,
- void *pApp,
- void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
- void (*xStep)(sqlite3_context*,int,sqlite3_value**),
- void (*xFinal)(sqlite3_context*),
- void(*xDestroy)(void*)
- );
- /*
- ** CAPI3REF: Text Encodings
- **
- ** These constant define integer codes that represent the various
- ** text encodings supported by SQLite.
- */
- #define SQLITE_UTF8 1
- #define SQLITE_UTF16LE 2
- #define SQLITE_UTF16BE 3
- #define SQLITE_UTF16 4 /* Use native byte order */
- #define SQLITE_ANY 5 /* sqlite3_create_function only */
- #define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */
- /*
- ** CAPI3REF: Deprecated Functions
- ** DEPRECATED
- **
- ** These functions are [deprecated]. In order to maintain
- ** backwards compatibility with older code, these functions continue
- ** to be supported. However, new applications should avoid
- ** the use of these functions. To help encourage people to avoid
- ** using these functions, we are not going to tell you what they do.
- */
- #ifndef SQLITE_OMIT_DEPRECATED
- SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
- SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
- SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
- SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
- SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
- SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
- #endif
- /*
- ** CAPI3REF: Obtaining SQL Function Parameter Values
- **
- ** The C-language implementation of SQL functions and aggregates uses
- ** this set of interface routines to access the parameter values on
- ** the function or aggregate.
- **
- ** The xFunc (for scalar functions) or xStep (for aggregates) parameters
- ** to [sqlite3_create_function()] and [sqlite3_create_function16()]
- ** define callbacks that implement the SQL functions and aggregates.
- ** The 3rd parameter to these callbacks is an array of pointers to
- ** [protected sqlite3_value] objects. There is one [sqlite3_value] object for
- ** each parameter to the SQL function. These routines are used to
- ** extract values from the [sqlite3_value] objects.
- **
- ** These routines work only with [protected sqlite3_value] objects.
- ** Any attempt to use these routines on an [unprotected sqlite3_value]
- ** object results in undefined behavior.
- **
- ** ^These routines work just like the corresponding [column access functions]
- ** except that these routines take a single [protected sqlite3_value] object
- ** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
- **
- ** ^The sqlite3_value_text16() interface extracts a UTF-16 string
- ** in the native byte-order of the host machine. ^The
- ** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
- ** extract UTF-16 strings as big-endian and little-endian respectively.
- **
- ** ^(The sqlite3_value_numeric_type() interface attempts to apply
- ** numeric affinity to the value. This means that an attempt is
- ** made to convert the value to an integer or floating point. If
- ** such a conversion is possible without loss of information (in other
- ** words, if the value is a string that looks like a number)
- ** then the conversion is performed. Otherwise no conversion occurs.
- ** The [SQLITE_INTEGER | datatype] after conversion is returned.)^
- **
- ** Please pay particular attention to the fact that the pointer returned
- ** from [sqlite3_value_blob()], [sqlite3_value_text()], or
- ** [sqlite3_value_text16()] can be invalidated by a subsequent call to
- ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
- ** or [sqlite3_value_text16()].
- **
- ** These routines must be called from the same thread as
- ** the SQL function that supplied the [sqlite3_value*] parameters.
- */
- SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
- SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
- SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
- SQLITE_API double sqlite3_value_double(sqlite3_value*);
- SQLITE_API int sqlite3_value_int(sqlite3_value*);
- SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
- SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
- SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
- SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
- SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
- SQLITE_API int sqlite3_value_type(sqlite3_value*);
- SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
- /*
- ** CAPI3REF: Obtain Aggregate Function Context
- **
- ** Implementations of aggregate SQL functions use this
- ** routine to allocate memory for storing their state.
- **
- ** ^The first time the sqlite3_aggregate_context(C,N) routine is called
- ** for a particular aggregate function, SQLite
- ** allocates N of memory, zeroes out that memory, and returns a pointer
- ** to the new memory. ^On second and subsequent calls to
- ** sqlite3_aggregate_context() for the same aggregate function instance,
- ** the same buffer is returned. Sqlite3_aggregate_context() is normally
- ** called once for each invocation of the xStep callback and then one
- ** last time when the xFinal callback is invoked. ^(When no rows match
- ** an aggregate query, the xStep() callback of the aggregate function
- ** implementation is never called and xFinal() is called exactly once.
- ** In those cases, sqlite3_aggregate_context() might be called for the
- ** first time from within xFinal().)^
- **
- ** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer if N is
- ** less than or equal to zero or if a memory allocate error occurs.
- **
- ** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
- ** determined by the N parameter on first successful call. Changing the
- ** value of N in subsequent call to sqlite3_aggregate_context() within
- ** the same aggregate function instance will not resize the memory
- ** allocation.)^
- **
- ** ^SQLite automatically frees the memory allocated by
- ** sqlite3_aggregate_context() when the aggregate query concludes.
- **
- ** The first parameter must be a copy of the
- ** [sqlite3_context | SQL function context] that is the first parameter
- ** to the xStep or xFinal callback routine that implements the aggregate
- ** function.
- **
- ** This routine must be called from the same thread in which
- ** the aggregate SQL function is running.
- */
- SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
- /*
- ** CAPI3REF: User Data For Functions
- **
- ** ^The sqlite3_user_data() interface returns a copy of
- ** the pointer that was the pUserData parameter (the 5th parameter)
- ** of the [sqlite3_create_function()]
- ** and [sqlite3_create_function16()] routines that originally
- ** registered the application defined function.
- **
- ** This routine must be called from the same thread in which
- ** the application-defined function is running.
- */
- SQLITE_API void *sqlite3_user_data(sqlite3_context*);
- /*
- ** CAPI3REF: Database Connection For Functions
- **
- ** ^The sqlite3_context_db_handle() interface returns a copy of
- ** the pointer to the [database connection] (the 1st parameter)
- ** of the [sqlite3_create_function()]
- ** and [sqlite3_create_function16()] routines that originally
- ** registered the application defined function.
- */
- SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
- /*
- ** CAPI3REF: Function Auxiliary Data
- **
- ** The following two functions may be used by scalar SQL functions to
- ** associate metadata with argument values. If the same value is passed to
- ** multiple invocations of the same SQL function during query execution, under
- ** some circumstances the associated metadata may be preserved. This may
- ** be used, for example, to add a regular-expression matching scalar
- ** function. The compiled version of the regular expression is stored as
- ** metadata associated with the SQL value passed as the regular expression
- ** pattern. The compiled regular expression can be reused on multiple
- ** invocations of the same function so that the original pattern string
- ** does not need to be recompiled on each invocation.
- **
- ** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata
- ** associated by the sqlite3_set_auxdata() function with the Nth argument
- ** value to the application-defined function. ^If no metadata has been ever
- ** been set for the Nth argument of the function, or if the corresponding
- ** function parameter has changed since the meta-data was set,
- ** then sqlite3_get_auxdata() returns a NULL pointer.
- **
- ** ^The sqlite3_set_auxdata() interface saves the metadata
- ** pointed to by its 3rd parameter as the metadata for the N-th
- ** argument of the application-defined function. Subsequent
- ** calls to sqlite3_get_auxdata() might return this data, if it has
- ** not been destroyed.
- ** ^If it is not NULL, SQLite will invoke the destructor
- ** function given by the 4th parameter to sqlite3_set_auxdata() on
- ** the metadata when the corresponding function parameter changes
- ** or when the SQL statement completes, whichever comes first.
- **
- ** SQLite is free to call the destructor and drop metadata on any
- ** parameter of any function at any time. ^The only guarantee is that
- ** the destructor will be called before the metadata is dropped.
- **
- ** ^(In practice, metadata is preserved between function calls for
- ** expressions that are constant at compile time. This includes literal
- ** values and [parameters].)^
- **
- ** These routines must be called from the same thread in which
- ** the SQL function is running.
- */
- SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
- SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
- /*
- ** CAPI3REF: Constants Defining Special Destructor Behavior
- **
- ** These are special values for the destructor that is passed in as the
- ** final argument to routines like [sqlite3_result_blob()]. ^If the destructor
- ** argument is SQLITE_STATIC, it means that the content pointer is constant
- ** and will never change. It does not need to be destroyed. ^The
- ** SQLITE_TRANSIENT value means that the content will likely change in
- ** the near future and that SQLite should make its own private copy of
- ** the content before returning.
- **
- ** The typedef is necessary to work around problems in certain
- ** C++ compilers. See ticket #2191.
- */
- typedef void (*sqlite3_destructor_type)(void*);
- #define SQLITE_STATIC ((sqlite3_destructor_type)0)
- #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)
- /*
- ** CAPI3REF: Setting The Result Of An SQL Function
- **
- ** These routines are used by the xFunc or xFinal callbacks that
- ** implement SQL functions and aggregates. See
- ** [sqlite3_create_function()] and [sqlite3_create_function16()]
- ** for additional information.
- **
- ** These functions work very much like the [parameter binding] family of
- ** functions used to bind values to host parameters in prepared statements.
- ** Refer to the [SQL parameter] documentation for additional information.
- **
- ** ^The sqlite3_result_blob() interface sets the result from
- ** an application-defined function to be the BLOB whose content is pointed
- ** to by the second parameter and which is N bytes long where N is the
- ** third parameter.
- **
- ** ^The sqlite3_result_zeroblob() interfaces set the result of
- ** the application-defined function to be a BLOB containing all zero
- ** bytes and N bytes in size, where N is the value of the 2nd parameter.
- **
- ** ^The sqlite3_result_double() interface sets the result from
- ** an application-defined function to be a floating point value specified
- ** by its 2nd argument.
- **
- ** ^The sqlite3_result_error() and sqlite3_result_error16() functions
- ** cause the implemented SQL function to throw an exception.
- ** ^SQLite uses the string pointed to by the
- ** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
- ** as the text of an error message. ^SQLite interprets the error
- ** message string from sqlite3_result_error() as UTF-8. ^SQLite
- ** interprets the string from sqlite3_result_error16() as UTF-16 in native
- ** byte order. ^If the third parameter to sqlite3_result_error()
- ** or sqlite3_result_error16() is negative then SQLite takes as the error
- ** message all text up through the first zero character.
- ** ^If the third parameter to sqlite3_result_error() or
- ** sqlite3_result_error16() is non-negative then SQLite takes that many
- ** bytes (not characters) from the 2nd parameter as the error message.
- ** ^The sqlite3_result_error() and sqlite3_result_error16()
- ** routines make a private copy of the error message text before
- ** they return. Hence, the calling function can deallocate or
- ** modify the text after they return without harm.
- ** ^The sqlite3_result_error_code() function changes the error code
- ** returned by SQLite as a result of an error in a function. ^By default,
- ** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error()
- ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
- **
- ** ^The sqlite3_result_toobig() interface causes SQLite to throw an error
- ** indicating that a string or BLOB is too long to represent.
- **
- ** ^The sqlite3_result_nomem() interface causes SQLite to throw an error
- ** indicating that a memory allocation failed.
- **
- ** ^The sqlite3_result_int() interface sets the return value
- ** of the application-defined function to be the 32-bit signed integer
- ** value given in the 2nd argument.
- ** ^The sqlite3_result_int64() interface sets the return value
- ** of the application-defined function to be the 64-bit signed integer
- ** value given in the 2nd argument.
- **
- ** ^The sqlite3_result_null() interface sets the return value
- ** of the application-defined function to be NULL.
- **
- ** ^The sqlite3_result_text(), sqlite3_result_text16(),
- ** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
- ** set the return value of the application-defined function to be
- ** a text string which is represented as UTF-8, UTF-16 native byte order,
- ** UTF-16 little endian, or UTF-16 big endian, respectively.
- ** ^SQLite takes the text result from the application from
- ** the 2nd parameter of the sqlite3_result_text* interfaces.
- ** ^If the 3rd parameter to the sqlite3_result_text* interfaces
- ** is negative, then SQLite takes result text from the 2nd parameter
- ** through the first zero character.
- ** ^If the 3rd parameter to the sqlite3_result_text* interfaces
- ** is non-negative, then as many bytes (not characters) of the text
- ** pointed to by the 2nd parameter are taken as the application-defined
- ** function result. If the 3rd parameter is non-negative, then it
- ** must be the byte offset into the string where the NUL terminator would
- ** appear if the string where NUL terminated. If any NUL characters occur
- ** in the string at a byte offset that is less than the value of the 3rd
- ** parameter, then the resulting string will contain embedded NULs and the
- ** result of expressions operating on strings with embedded NULs is undefined.
- ** ^If the 4th parameter to the sqlite3_result_text* interfaces
- ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
- ** function as the destructor on the text or BLOB result when it has
- ** finished using that result.
- ** ^If the 4th parameter to the sqlite3_result_text* interfaces or to
- ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
- ** assumes that the text or BLOB result is in constant space and does not
- ** copy the content of the parameter nor call a destructor on the content
- ** when it has finished using that result.
- ** ^If the 4th parameter to the sqlite3_result_text* interfaces
- ** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
- ** then SQLite makes a copy of the result into space obtained from
- ** from [sqlite3_malloc()] before it returns.
- **
- ** ^The sqlite3_result_value() interface sets the result of
- ** the application-defined function to be a copy the
- ** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The
- ** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
- ** so that the [sqlite3_value] specified in the parameter may change or
- ** be deallocated after sqlite3_result_value() returns without harm.
- ** ^A [protected sqlite3_value] object may always be used where an
- ** [unprotected sqlite3_value] object is required, so either
- ** kind of [sqlite3_value] object can be used with this interface.
- **
- ** If these routines are called from within the different thread
- ** than the one containing the application-defined function that received
- ** the [sqlite3_context] pointer, the results are undefined.
- */
- SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
- SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
- SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
- SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
- SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
- SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
- SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
- SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
- SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
- SQLITE_API void sqlite3_result_null(sqlite3_context*);
- SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
- SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
- SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
- SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
- SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
- SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
- /*
- ** CAPI3REF: Define New Collating Sequences
- **
- ** ^These functions add, remove, or modify a [collation] associated
- ** with the [database connection] specified as the first argument.
- **
- ** ^The name of the collation is a UTF-8 string
- ** for sqlite3_create_collation() and sqlite3_create_collation_v2()
- ** and a UTF-16 string in native byte order for sqlite3_create_collation16().
- ** ^Collation names that compare equal according to [sqlite3_strnicmp()] are
- ** considered to be the same name.
- **
- ** ^(The third argument (eTextRep) must be one of the constants:
- ** <ul>
- ** <li> [SQLITE_UTF8],
- ** <li> [SQLITE_UTF16LE],
- ** <li> [SQLITE_UTF16BE],
- ** <li> [SQLITE_UTF16], or
- ** <li> [SQLITE_UTF16_ALIGNED].
- ** </ul>)^
- ** ^The eTextRep argument determines the encoding of strings passed
- ** to the collating function callback, xCallback.
- ** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep
- ** force strings to be UTF16 with native byte order.
- ** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin
- ** on an even byte address.
- **
- ** ^The fourth argument, pArg, is an application data pointer that is passed
- ** through as the first argument to the collating function callback.
- **
- ** ^The fifth argument, xCallback, is a pointer to the collating function.
- ** ^Multiple collating functions can be registered using the same name but
- ** with different eTextRep parameters and SQLite will use whichever
- ** function requires the least amount of data transformation.
- ** ^If the xCallback argument is NULL then the collating function is
- ** deleted. ^When all collating functions having the same name are deleted,
- ** that collation is no longer usable.
- **
- ** ^The collating function callback is invoked with a copy of the pArg
- ** application data pointer and with two strings in the encoding specified
- ** by the eTextRep argument. The collating function must return an
- ** integer that is negative, zero, or positive
- ** if the first string is less than, equal to, or greater than the second,
- ** respectively. A collating function must always return the same answer
- ** given the same inputs. If two or more collating functions are registered
- ** to the same collation name (using different eTextRep values) then all
- ** must give an equivalent answer when invoked with equivalent strings.
- ** The collating function must obey the following properties for all
- ** strings A, B, and C:
- **
- ** <ol>
- ** <li> If A==B then B==A.
- ** <li> If A==B and B==C then A==C.
- ** <li> If A<B THEN B>A.
- ** <li> If A<B and B<C then A<C.
- ** </ol>
- **
- ** If a collating function fails any of the above constraints and that
- ** collating function is registered and used, then the behavior of SQLite
- ** is undefined.
- **
- ** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation()
- ** with the addition that the xDestroy callback is invoked on pArg when
- ** the collating function is deleted.
- ** ^Collating functions are deleted when they are overridden by later
- ** calls to the collation creation functions or when the
- ** [database connection] is closed using [sqlite3_close()].
- **
- ** ^The xDestroy callback is <u>not</u> called if the
- ** sqlite3_create_collation_v2() function fails. Applications that invoke
- ** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should
- ** check the return code and dispose of the application data pointer
- ** themselves rather than expecting SQLite to deal with it for them.
- ** This is different from every other SQLite interface. The inconsistency
- ** is unfortunate but cannot be changed without breaking backwards
- ** compatibility.
- **
- ** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
- */
- SQLITE_API int sqlite3_create_collation(
- sqlite3*,
- const char *zName,
- int eTextRep,
- void *pArg,
- int(*xCompare)(void*,int,const void*,int,const void*)
- );
- SQLITE_API int sqlite3_create_collation_v2(
- sqlite3*,
- const char *zName,
- int eTextRep,
- void *pArg,
- int(*xCompare)(void*,int,const void*,int,const void*),
- void(*xDestroy)(void*)
- );
- SQLITE_API int sqlite3_create_collation16(
- sqlite3*,
- const void *zName,
- int eTextRep,
- void *pArg,
- int(*xCompare)(void*,int,const void*,int,const void*)
- );
- /*
- ** CAPI3REF: Collation Needed Callbacks
- **
- ** ^To avoid having to register all collation sequences before a database
- ** can be used, a single callback function may be registered with the
- ** [database connection] to be invoked whenever an undefined collation
- ** sequence is required.
- **
- ** ^If the function is registered using the sqlite3_collation_needed() API,
- ** then it is passed the names of undefined collation sequences as strings
- ** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
- ** the names are passed as UTF-16 in machine native byte order.
- ** ^A call to either function replaces the existing collation-needed callback.
- **
- ** ^(When the callback is invoked, the first argument passed is a copy
- ** of the second argument to sqlite3_collation_needed() or
- ** sqlite3_collation_needed16(). The second argument is the database
- ** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE],
- ** or [SQLITE_UTF16LE], indicating the most desirable form of the collation
- ** sequence function required. The fourth parameter is the name of the
- ** required collation sequence.)^
- **
- ** The callback function should register the desired collation using
- ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
- ** [sqlite3_create_collation_v2()].
- */
- SQLITE_API int sqlite3_collation_needed(
- sqlite3*,
- void*,
- void(*)(void*,sqlite3*,int eTextRep,const char*)
- );
- SQLITE_API int sqlite3_collation_needed16(
- sqlite3*,
- void*,
- void(*)(void*,sqlite3*,int eTextRep,const void*)
- );
- #ifdef SQLITE_HAS_CODEC
- /*
- ** Specify the key for an encrypted database. This routine should be
- ** called right after sqlite3_open().
- **
- ** The code to implement this API is not available in the public release
- ** of SQLite.
- */
- SQLITE_API int sqlite3_key(
- sqlite3 *db, /* Database to be rekeyed */
- const void *pKey, int nKey /* The key */
- );
- /*
- ** Change the key on an open database. If the current database is not
- ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
- ** database is decrypted.
- **
- ** The code to implement this API is not available in the public release
- ** of SQLite.
- */
- SQLITE_API int sqlite3_rekey(
- sqlite3 *db, /* Database to be rekeyed */
- const void *pKey, int nKey /* The new key */
- );
- /*
- ** Specify the activation key for a SEE database. Unless
- ** activated, none of the SEE routines will work.
- */
- SQLITE_API void sqlite3_activate_see(
- const char *zPassPhrase /* Activation phrase */
- );
- #endif
- #ifdef SQLITE_ENABLE_CEROD
- /*
- ** Specify the activation key for a CEROD database. Unless
- ** activated, none of the CEROD routines will work.
- */
- SQLITE_API void sqlite3_activate_cerod(
- const char *zPassPhrase /* Activation phrase */
- );
- #endif
- /*
- ** CAPI3REF: Suspend Execution For A Short Time
- **
- ** The sqlite3_sleep() function causes the current thread to suspend execution
- ** for at least a number of milliseconds specified in its parameter.
- **
- ** If the operating system does not support sleep requests with
- ** millisecond time resolution, then the time will be rounded up to
- ** the nearest second. The number of milliseconds of sleep actually
- ** requested from the operating system is returned.
- **
- ** ^SQLite implements this interface by calling the xSleep()
- ** method of the default [sqlite3_vfs] object. If the xSleep() method
- ** of the default VFS is not implemented correctly, or not implemented at
- ** all, then the behavior of sqlite3_sleep() may deviate from the description
- ** in the previous paragraphs.
- */
- SQLITE_API int sqlite3_sleep(int);
- /*
- ** CAPI3REF: Name Of The Folder Holding Temporary Files
- **
- ** ^(If this global variable is made to point to a string which is
- ** the name of a folder (a.k.a. directory), then all temporary files
- ** created by SQLite when using a built-in [sqlite3_vfs | VFS]
- ** will be placed in that directory.)^ ^If this variable
- ** is a NULL pointer, then SQLite performs a search for an appropriate
- ** temporary file directory.
- **
- ** It is not safe to read or modify this variable in more than one
- ** thread at a time. It is not safe to read or modify this variable
- ** if a [database connection] is being used at the same time in a separate
- ** thread.
- ** It is intended that this variable be set once
- ** as part of process initialization and before any SQLite interface
- ** routines have been called and that this variable remain unchanged
- ** thereafter.
- **
- ** ^The [temp_store_directory pragma] may modify this variable and cause
- ** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore,
- ** the [temp_store_directory pragma] always assumes that any string
- ** that this variable points to is held in memory obtained from
- ** [sqlite3_malloc] and the pragma may attempt to free that memory
- ** using [sqlite3_free].
- ** Hence, if this variable is modified directly, either it should be
- ** made NULL or made to point to memory obtained from [sqlite3_malloc]
- ** or else the use of the [temp_store_directory pragma] should be avoided.
- */
- SQLITE_API char *sqlite3_temp_directory;
- /*
- ** CAPI3REF: Test For Auto-Commit Mode
- ** KEYWORDS: {autocommit mode}
- **
- ** ^The sqlite3_get_autocommit() interface returns non-zero or
- ** zero if the given database connection is or is not in autocommit mode,
- ** respectively. ^Autocommit mode is on by default.
- ** ^Autocommit mode is disabled by a [BEGIN] statement.
- ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
- **
- ** If certain kinds of errors occur on a statement within a multi-statement
- ** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
- ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
- ** transaction might be rolled back automatically. The only way to
- ** find out whether SQLite automatically rolled back the transaction after
- ** an error is to use this function.
- **
- ** If another thread changes the autocommit status of the database
- ** connection while this routine is running, then the return value
- ** is undefined.
- */
- SQLITE_API int sqlite3_get_autocommit(sqlite3*);
- /*
- ** CAPI3REF: Find The Database Handle Of A Prepared Statement
- **
- ** ^The sqlite3_db_handle interface returns the [database connection] handle
- ** to which a [prepared statement] belongs. ^The [database connection]
- ** returned by sqlite3_db_handle is the same [database connection]
- ** that was the first argument
- ** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
- ** create the statement in the first place.
- */
- SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
- /*
- ** CAPI3REF: Return The Filename For A Database Connection
- **
- ** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename
- ** associated with database N of connection D. ^The main database file
- ** has the name "main". If there is no attached database N on the database
- ** connection D, or if database N is a temporary or in-memory database, then
- ** a NULL pointer is returned.
- **
- ** ^The filename returned by this function is the output of the
- ** xFullPathname method of the [VFS]. ^In other words, the filename
- ** will be an absolute pathname, even if the filename used
- ** to open the database originally was a URI or relative pathname.
- */
- SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
- /*
- ** CAPI3REF: Find the next prepared statement
- **
- ** ^This interface returns a pointer to the next [prepared statement] after
- ** pStmt associated with the [database connection] pDb. ^If pStmt is NULL
- ** then this interface returns a pointer to the first prepared statement
- ** associated with the database connection pDb. ^If no prepared statement
- ** satisfies the conditions of this routine, it returns NULL.
- **
- ** The [database connection] pointer D in a call to
- ** [sqlite3_next_stmt(D,S)] must refer to an open database
- ** connection and in particular must not be a NULL pointer.
- */
- SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
- /*
- ** CAPI3REF: Commit And Rollback Notification Callbacks
- **
- ** ^The sqlite3_commit_hook() interface registers a callback
- ** function to be invoked whenever a transaction is [COMMIT | committed].
- ** ^Any callback set by a previous call to sqlite3_commit_hook()
- ** for the same database connection is overridden.
- ** ^The sqlite3_rollback_hook() interface registers a callback
- ** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
- ** ^Any callback set by a previous call to sqlite3_rollback_hook()
- ** for the same database connection is overridden.
- ** ^The pArg argument is passed through to the callback.
- ** ^If the callback on a commit hook function returns non-zero,
- ** then the commit is converted into a rollback.
- **
- ** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions
- ** return the P argument from the previous call of the same function
- ** on the same [database connection] D, or NULL for
- ** the first call for each function on D.
- **
- ** The commit and rollback hook callbacks are not reentrant.
- ** The callback implementation must not do anything that will modify
- ** the database connection that invoked the callback. Any actions
- ** to modify the database connection must be deferred until after the
- ** completion of the [sqlite3_step()] call that triggered the commit
- ** or rollback hook in the first place.
- ** Note that running any other SQL statements, including SELECT statements,
- ** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify
- ** the database connections for the meaning of "modify" in this paragraph.
- **
- ** ^Registering a NULL function disables the callback.
- **
- ** ^When the commit hook callback routine returns zero, the [COMMIT]
- ** operation is allowed to continue normally. ^If the commit hook
- ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
- ** ^The rollback hook is invoked on a rollback that results from a commit
- ** hook returning non-zero, just as it would be with any other rollback.
- **
- ** ^For the purposes of this API, a transaction is said to have been
- ** rolled back if an explicit "ROLLBACK" statement is executed, or
- ** an error or constraint causes an implicit rollback to occur.
- ** ^The rollback callback is not invoked if a transaction is
- ** automatically rolled back because the database connection is closed.
- **
- ** See also the [sqlite3_update_hook()] interface.
- */
- SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
- SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
- /*
- ** CAPI3REF: Data Change Notification Callbacks
- **
- ** ^The sqlite3_update_hook() interface registers a callback function
- ** with the [database connection] identified by the first argument
- ** to be invoked whenever a row is updated, inserted or deleted.
- ** ^Any callback set by a previous call to this function
- ** for the same database connection is overridden.
- **
- ** ^The second argument is a pointer to the function to invoke when a
- ** row is updated, inserted or deleted.
- ** ^The first argument to the callback is a copy of the third argument
- ** to sqlite3_update_hook().
- ** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],
- ** or [SQLITE_UPDATE], depending on the operation that caused the callback
- ** to be invoked.
- ** ^The third and fourth arguments to the callback contain pointers to the
- ** database and table name containing the affected row.
- ** ^The final callback parameter is the [rowid] of the row.
- ** ^In the case of an update, this is the [rowid] after the update takes place.
- **
- ** ^(The update hook is not invoked when internal system tables are
- ** modified (i.e. sqlite_master and sqlite_sequence).)^
- **
- ** ^In the current implementation, the update hook
- ** is not invoked when duplication rows are deleted because of an
- ** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook
- ** invoked when rows are deleted using the [truncate optimization].
- ** The exceptions defined in this paragraph might change in a future
- ** release of SQLite.
- **
- ** The update hook implementation must not do anything that will modify
- ** the database connection that invoked the update hook. Any actions
- ** to modify the database connection must be deferred until after the
- ** completion of the [sqlite3_step()] call that triggered the update hook.
- ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
- ** database connections for the meaning of "modify" in this paragraph.
- **
- ** ^The sqlite3_update_hook(D,C,P) function
- ** returns the P argument from the previous call
- ** on the same [database connection] D, or NULL for
- ** the first call on D.
- **
- ** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
- ** interfaces.
- */
- SQLITE_API void *sqlite3_update_hook(
- sqlite3*,
- void(*)(void *,int ,char const *,char const *,sqlite3_int64),
- void*
- );
- /*
- ** CAPI3REF: Enable Or Disable Shared Pager Cache
- ** KEYWORDS: {shared cache}
- **
- ** ^(This routine enables or disables the sharing of the database cache
- ** and schema data structures between [database connection | connections]
- ** to the same database. Sharing is enabled if the argument is true
- ** and disabled if the argument is false.)^
- **
- ** ^Cache sharing is enabled and disabled for an entire process.
- ** This is a change as of SQLite version 3.5.0. In prior versions of SQLite,
- ** sharing was enabled or disabled for each thread separately.
- **
- ** ^(The cache sharing mode set by this interface effects all subsequent
- ** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
- ** Existing database connections continue use the sharing mode
- ** that was in effect at the time they were opened.)^
- **
- ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
- ** successfully. An [error code] is returned otherwise.)^
- **
- ** ^Shared cache is disabled by default. But this might change in
- ** future releases of SQLite. Applications that care about shared
- ** cache setting should set it explicitly.
- **
- ** See Also: [SQLite Shared-Cache Mode]
- */
- SQLITE_API int sqlite3_enable_shared_cache(int);
- /*
- ** CAPI3REF: Attempt To Free Heap Memory
- **
- ** ^The sqlite3_release_memory() interface attempts to free N bytes
- ** of heap memory by deallocating non-essential memory allocations
- ** held by the database library. Memory used to cache database
- ** pages to improve performance is an example of non-essential memory.
- ** ^sqlite3_release_memory() returns the number of bytes actually freed,
- ** which might be more or less than the amount requested.
- ** ^The sqlite3_release_memory() routine is a no-op returning zero
- ** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT].
- **
- ** See also: [sqlite3_db_release_memory()]
- */
- SQLITE_API int sqlite3_release_memory(int);
- /*
- ** CAPI3REF: Free Memory Used By A Database Connection
- **
- ** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
- ** memory as possible from database connection D. Unlike the
- ** [sqlite3_release_memory()] interface, this interface is effect even
- ** when then [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
- ** omitted.
- **
- ** See also: [sqlite3_release_memory()]
- */
- SQLITE_API int sqlite3_db_release_memory(sqlite3*);
- /*
- ** CAPI3REF: Impose A Limit On Heap Size
- **
- ** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the
- ** soft limit on the amount of heap memory that may be allocated by SQLite.
- ** ^SQLite strives to keep heap memory utilization below the soft heap
- ** limit by reducing the number of pages held in the page cache
- ** as heap memory usages approaches the limit.
- ** ^The soft heap limit is "soft" because even though SQLite strives to stay
- ** below the limit, it will exceed the limit rather than generate
- ** an [SQLITE_NOMEM] error. In other words, the soft heap limit
- ** is advisory only.
- **
- ** ^The return value from sqlite3_soft_heap_limit64() is the size of
- ** the soft heap limit prior to the call, or negative in the case of an
- ** error. ^If the argument N is negative
- ** then no change is made to the soft heap limit. Hence, the current
- ** size of the soft heap limit can be determined by invoking
- ** sqlite3_soft_heap_limit64() with a negative argument.
- **
- ** ^If the argument N is zero then the soft heap limit is disabled.
- **
- ** ^(The soft heap limit is not enforced in the current implementation
- ** if one or more of following conditions are true:
- **
- ** <ul>
- ** <li> The soft heap limit is set to zero.
- ** <li> Memory accounting is disabled using a combination of the
- ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
- ** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
- ** <li> An alternative page cache implementation is specified using
- ** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...).
- ** <li> The page cache allocates from its own memory pool supplied
- ** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than
- ** from the heap.
- ** </ul>)^
- **
- ** Beginning with SQLite version 3.7.3, the soft heap limit is enforced
- ** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT]
- ** compile-time option is invoked. With [SQLITE_ENABLE_MEMORY_MANAGEMENT],
- ** the soft heap limit is enforced on every memory allocation. Without
- ** [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced
- ** when memory is allocated by the page cache. Testing suggests that because
- ** the page cache is the predominate memory user in SQLite, most
- ** applications will achieve adequate soft heap limit enforcement without
- ** the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT].
- **
- ** The circumstances under which SQLite will enforce the soft heap limit may
- ** changes in future releases of SQLite.
- */
- SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
- /*
- ** CAPI3REF: Deprecated Soft Heap Limit Interface
- ** DEPRECATED
- **
- ** This is a deprecated version of the [sqlite3_soft_heap_limit64()]
- ** interface. This routine is provided for historical compatibility
- ** only. All new applications should use the
- ** [sqlite3_soft_heap_limit64()] interface rather than this one.
- */
- SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
- /*
- ** CAPI3REF: Extract Metadata About A Column Of A Table
- **
- ** ^This routine returns metadata about a specific column of a specific
- ** database table accessible using the [database connection] handle
- ** passed as the first function argument.
- **
- ** ^The column is identified by the second, third and fourth parameters to
- ** this function. ^The second parameter is either the name of the database
- ** (i.e. "main", "temp", or an attached database) containing the specified
- ** table or NULL. ^If it is NULL, then all attached databases are searched
- ** for the table using the same algorithm used by the database engine to
- ** resolve unqualified table references.
- **
- ** ^The third and fourth parameters to this function are the table and column
- ** name of the desired column, respectively. Neither of these parameters
- ** may be NULL.
- **
- ** ^Metadata is returned by writing to the memory locations passed as the 5th
- ** and subsequent parameters to this function. ^Any of these arguments may be
- ** NULL, in which case the corresponding element of metadata is omitted.
- **
- ** ^(<blockquote>
- ** <table border="1">
- ** <tr><th> Parameter <th> Output<br>Type <th> Description
- **
- ** <tr><td> 5th <td> const char* <td> Data type
- ** <tr><td> 6th <td> const char* <td> Name of default collation sequence
- ** <tr><td> 7th <td> int <td> True if column has a NOT NULL constraint
- ** <tr><td> 8th <td> int <td> True if column is part of the PRIMARY KEY
- ** <tr><td> 9th <td> int <td> True if column is [AUTOINCREMENT]
- ** </table>
- ** </blockquote>)^
- **
- ** ^The memory pointed to by the character pointers returned for the
- ** declaration type and collation sequence is valid only until the next
- ** call to any SQLite API function.
- **
- ** ^If the specified table is actually a view, an [error code] is returned.
- **
- ** ^If the specified column is "rowid", "oid" or "_rowid_" and an
- ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
- ** parameters are set for the explicitly declared column. ^(If there is no
- ** explicitly declared [INTEGER PRIMARY KEY] column, then the output
- ** parameters are set as follows:
- **
- ** <pre>
- ** data type: "INTEGER"
- ** collation sequence: "BINARY"
- ** not null: 0
- ** primary key: 1
- ** auto increment: 0
- ** </pre>)^
- **
- ** ^(This function may load one or more schemas from database files. If an
- ** error occurs during this process, or if the requested table or column
- ** cannot be found, an [error code] is returned and an error message left
- ** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^
- **
- ** ^This API is only available if the library was compiled with the
- ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
- */
- SQLITE_API int sqlite3_table_column_metadata(
- sqlite3 *db, /* Connection handle */
- const char *zDbName, /* Database name or NULL */
- const char *zTableName, /* Table name */
- const char *zColumnName, /* Column name */
- char const **pzDataType, /* OUTPUT: Declared data type */
- char const **pzCollSeq, /* OUTPUT: Collation sequence name */
- int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
- int *pPrimaryKey, /* OUTPUT: True if column part of PK */
- int *pAutoinc /* OUTPUT: True if column is auto-increment */
- );
- /*
- ** CAPI3REF: Load An Extension
- **
- ** ^This interface loads an SQLite extension library from the named file.
- **
- ** ^The sqlite3_load_extension() interface attempts to load an
- ** SQLite extension library contained in the file zFile.
- **
- ** ^The entry point is zProc.
- ** ^zProc may be 0, in which case the name of the entry point
- ** defaults to "sqlite3_extension_init".
- ** ^The sqlite3_load_extension() interface returns
- ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
- ** ^If an error occurs and pzErrMsg is not 0, then the
- ** [sqlite3_load_extension()] interface shall attempt to
- ** fill *pzErrMsg with error message text stored in memory
- ** obtained from [sqlite3_malloc()]. The calling function
- ** should free this memory by calling [sqlite3_free()].
- **
- ** ^Extension loading must be enabled using
- ** [sqlite3_enable_load_extension()] prior to calling this API,
- ** otherwise an error will be returned.
- **
- ** See also the [load_extension() SQL function].
- */
- SQLITE_API int sqlite3_load_extension(
- sqlite3 *db, /* Load the extension into this database connection */
- const char *zFile, /* Name of the shared library containing extension */
- const char *zProc, /* Entry point. Derived from zFile if 0 */
- char **pzErrMsg /* Put error message here if not 0 */
- );
- /*
- ** CAPI3REF: Enable Or Disable Extension Loading
- **
- ** ^So as not to open security holes in older applications that are
- ** unprepared to deal with extension loading, and as a means of disabling
- ** extension loading while evaluating user-entered SQL, the following API
- ** is provided to turn the [sqlite3_load_extension()] mechanism on and off.
- **
- ** ^Extension loading is off by default. See ticket #1863.
- ** ^Call the sqlite3_enable_load_extension() routine with onoff==1
- ** to turn extension loading on and call it with onoff==0 to turn
- ** it back off again.
- */
- SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
- /*
- ** CAPI3REF: Automatically Load Statically Linked Extensions
- **
- ** ^This interface causes the xEntryPoint() function to be invoked for
- ** each new [database connection] that is created. The idea here is that
- ** xEntryPoint() is the entry point for a statically linked SQLite extension
- ** that is to be automatically loaded into all new database connections.
- **
- ** ^(Even though the function prototype shows that xEntryPoint() takes
- ** no arguments and returns void, SQLite invokes xEntryPoint() with three
- ** arguments and expects and integer result as if the signature of the
- ** entry point where as follows:
- **
- ** <blockquote><pre>
- ** int xEntryPoint(
- ** sqlite3 *db,
- ** const char **pzErrMsg,
- ** const struct sqlite3_api_routines *pThunk
- ** );
- ** </pre></blockquote>)^
- **
- ** If the xEntryPoint routine encounters an error, it should make *pzErrMsg
- ** point to an appropriate error message (obtained from [sqlite3_mprintf()])
- ** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg
- ** is NULL before calling the xEntryPoint(). ^SQLite will invoke
- ** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any
- ** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()],
- ** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail.
- **
- ** ^Calling sqlite3_auto_extension(X) with an entry point X that is already
- ** on the list of automatic extensions is a harmless no-op. ^No entry point
- ** will be called more than once for each database connection that is opened.
- **
- ** See also: [sqlite3_reset_auto_extension()].
- */
- SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
- /*
- ** CAPI3REF: Reset Automatic Extension Loading
- **
- ** ^This interface disables all automatic extensions previously
- ** registered using [sqlite3_auto_extension()].
- */
- SQLITE_API void sqlite3_reset_auto_extension(void);
- /*
- ** The interface to the virtual-table mechanism is currently considered
- ** to be experimental. The interface might change in incompatible ways.
- ** If this is a problem for you, do not use the interface at this time.
- **
- ** When the virtual-table mechanism stabilizes, we will declare the
- ** interface fixed, support it indefinitely, and remove this comment.
- */
- /*
- ** Structures used by the virtual table interface
- */
- typedef struct sqlite3_vtab sqlite3_vtab;
- typedef struct sqlite3_index_info sqlite3_index_info;
- typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
- typedef struct sqlite3_module sqlite3_module;
- /*
- ** CAPI3REF: Virtual Table Object
- ** KEYWORDS: sqlite3_module {virtual table module}
- **
- ** This structure, sometimes called a "virtual table module",
- ** defines the implementation of a [virtual tables].
- ** This structure consists mostly of methods for the module.
- **
- ** ^A virtual table module is created by filling in a persistent
- ** instance of this structure and passing a pointer to that instance
- ** to [sqlite3_create_module()] or [sqlite3_create_module_v2()].
- ** ^The registration remains valid until it is replaced by a different
- ** module or until the [database connection] closes. The content
- ** of this structure must not change while it is registered with
- ** any database connection.
- */
- struct sqlite3_module {
- int iVersion;
- int (*xCreate)(sqlite3*, void *pAux,
- int argc, const char *const*argv,
- sqlite3_vtab **ppVTab, char**);
- int (*xConnect)(sqlite3*, void *pAux,
- int argc, const char *const*argv,
- sqlite3_vtab **ppVTab, char**);
- int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
- int (*xDisconnect)(sqlite3_vtab *pVTab);
- int (*xDestroy)(sqlite3_vtab *pVTab);
- int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
- int (*xClose)(sqlite3_vtab_cursor*);
- int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
- int argc, sqlite3_value **argv);
- int (*xNext)(sqlite3_vtab_cursor*);
- int (*xEof)(sqlite3_vtab_cursor*);
- int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
- int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
- int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
- int (*xBegin)(sqlite3_vtab *pVTab);
- int (*xSync)(sqlite3_vtab *pVTab);
- int (*xCommit)(sqlite3_vtab *pVTab);
- int (*xRollback)(sqlite3_vtab *pVTab);
- int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
- void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
- void **ppArg);
- int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
- /* The methods above are in version 1 of the sqlite_module object. Those
- ** below are for version 2 and greater. */
- int (*xSavepoint)(sqlite3_vtab *pVTab, int);
- int (*xRelease)(sqlite3_vtab *pVTab, int);
- int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
- };
- /*
- ** CAPI3REF: Virtual Table Indexing Information
- ** KEYWORDS: sqlite3_index_info
- **
- ** The sqlite3_index_info structure and its substructures is used as part
- ** of the [virtual table] interface to
- ** pass information into and receive the reply from the [xBestIndex]
- ** method of a [virtual table module]. The fields under **Inputs** are the
- ** inputs to xBestIndex and are read-only. xBestIndex inserts its
- ** results into the **Outputs** fields.
- **
- ** ^(The aConstraint[] array records WHERE clause constraints of the form:
- **
- ** <blockquote>column OP expr</blockquote>
- **
- ** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is
- ** stored in aConstraint[].op using one of the
- ** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^
- ** ^(The index of the column is stored in
- ** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the
- ** expr on the right-hand side can be evaluated (and thus the constraint
- ** is usable) and false if it cannot.)^
- **
- ** ^The optimizer automatically inverts terms of the form "expr OP column"
- ** and makes other simplifications to the WHERE clause in an attempt to
- ** get as many WHERE clause terms into the form shown above as possible.
- ** ^The aConstraint[] array only reports WHERE clause terms that are
- ** relevant to the particular virtual table being queried.
- **
- ** ^Information about the ORDER BY clause is stored in aOrderBy[].
- ** ^Each term of aOrderBy records a column of the ORDER BY clause.
- **
- ** The [xBestIndex] method must fill aConstraintUsage[] with information
- ** about what parameters to pass to xFilter. ^If argvIndex>0 then
- ** the right-hand side of the corresponding aConstraint[] is evaluated
- ** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit
- ** is true, then the constraint is assumed to be fully handled by the
- ** virtual table and is not checked again by SQLite.)^
- **
- ** ^The idxNum and idxPtr values are recorded and passed into the
- ** [xFilter] method.
- ** ^[sqlite3_free()] is used to free idxPtr if and only if
- ** needToFreeIdxPtr is true.
- **
- ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in
- ** the correct order to satisfy the ORDER BY clause so that no separate
- ** sorting step is required.
- **
- ** ^The estimatedCost value is an estimate of the cost of doing the
- ** particular lookup. A full scan of a table with N entries should have
- ** a cost of N. A binary search of a table of N entries should have a
- ** cost of approximately log(N).
- */
- struct sqlite3_index_info {
- /* Inputs */
- int nConstraint; /* Number of entries in aConstraint */
- struct sqlite3_index_constraint {
- int iColumn; /* Column on left-hand side of constraint */
- unsigned char op; /* Constraint operator */
- unsigned char usable; /* True if this constraint is usable */
- int iTermOffset; /* Used internally - xBestIndex should ignore */
- } *aConstraint; /* Table of WHERE clause constraints */
- int nOrderBy; /* Number of terms in the ORDER BY clause */
- struct sqlite3_index_orderby {
- int iColumn; /* Column number */
- unsigned char desc; /* True for DESC. False for ASC. */
- } *aOrderBy; /* The ORDER BY clause */
- /* Outputs */
- struct sqlite3_index_constraint_usage {
- int argvIndex; /* if >0, constraint is part of argv to xFilter */
- unsigned char omit; /* Do not code a test for this constraint */
- } *aConstraintUsage;
- int idxNum; /* Number used to identify the index */
- char *idxStr; /* String, possibly obtained from sqlite3_malloc */
- int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */
- int orderByConsumed; /* True if output is already ordered */
- double estimatedCost; /* Estimated cost of using this index */
- };
- /*
- ** CAPI3REF: Virtual Table Constraint Operator Codes
- **
- ** These macros defined the allowed values for the
- ** [sqlite3_index_info].aConstraint[].op field. Each value represents
- ** an operator that is part of a constraint term in the wHERE clause of
- ** a query that uses a [virtual table].
- */
- #define SQLITE_INDEX_CONSTRAINT_EQ 2
- #define SQLITE_INDEX_CONSTRAINT_GT 4
- #define SQLITE_INDEX_CONSTRAINT_LE 8
- #define SQLITE_INDEX_CONSTRAINT_LT 16
- #define SQLITE_INDEX_CONSTRAINT_GE 32
- #define SQLITE_INDEX_CONSTRAINT_MATCH 64
- /*
- ** CAPI3REF: Register A Virtual Table Implementation
- **
- ** ^These routines are used to register a new [virtual table module] name.
- ** ^Module names must be registered before
- ** creating a new [virtual table] using the module and before using a
- ** preexisting [virtual table] for the module.
- **
- ** ^The module name is registered on the [database connection] specified
- ** by the first parameter. ^The name of the module is given by the
- ** second parameter. ^The third parameter is a pointer to
- ** the implementation of the [virtual table module]. ^The fourth
- ** parameter is an arbitrary client data pointer that is passed through
- ** into the [xCreate] and [xConnect] methods of the virtual table module
- ** when a new virtual table is be being created or reinitialized.
- **
- ** ^The sqlite3_create_module_v2() interface has a fifth parameter which
- ** is a pointer to a destructor for the pClientData. ^SQLite will
- ** invoke the destructor function (if it is not NULL) when SQLite
- ** no longer needs the pClientData pointer. ^The destructor will also
- ** be invoked if the call to sqlite3_create_module_v2() fails.
- ** ^The sqlite3_create_module()
- ** interface is equivalent to sqlite3_create_module_v2() with a NULL
- ** destructor.
- */
- SQLITE_API int sqlite3_create_module(
- sqlite3 *db, /* SQLite connection to register module with */
- const char *zName, /* Name of the module */
- const sqlite3_module *p, /* Methods for the module */
- void *pClientData /* Client data for xCreate/xConnect */
- );
- SQLITE_API int sqlite3_create_module_v2(
- sqlite3 *db, /* SQLite connection to register module with */
- const char *zName, /* Name of the module */
- const sqlite3_module *p, /* Methods for the module */
- void *pClientData, /* Client data for xCreate/xConnect */
- void(*xDestroy)(void*) /* Module destructor function */
- );
- /*
- ** CAPI3REF: Virtual Table Instance Object
- ** KEYWORDS: sqlite3_vtab
- **
- ** Every [virtual table module] implementation uses a subclass
- ** of this object to describe a particular instance
- ** of the [virtual table]. Each subclass will
- ** be tailored to the specific needs of the module implementation.
- ** The purpose of this superclass is to define certain fields that are
- ** common to all module implementations.
- **
- ** ^Virtual tables methods can set an error message by assigning a
- ** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should
- ** take care that any prior string is freed by a call to [sqlite3_free()]
- ** prior to assigning a new string to zErrMsg. ^After the error message
- ** is delivered up to the client application, the string will be automatically
- ** freed by sqlite3_free() and the zErrMsg field will be zeroed.
- */
- struct sqlite3_vtab {
- const sqlite3_module *pModule; /* The module for this virtual table */
- int nRef; /* NO LONGER USED */
- char *zErrMsg; /* Error message from sqlite3_mprintf() */
- /* Virtual table implementations will typically add additional fields */
- };
- /*
- ** CAPI3REF: Virtual Table Cursor Object
- ** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor}
- **
- ** Every [virtual table module] implementation uses a subclass of the
- ** following structure to describe cursors that point into the
- ** [virtual table] and are used
- ** to loop through the virtual table. Cursors are created using the
- ** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed
- ** by the [sqlite3_module.xClose | xClose] method. Cursors are used
- ** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods
- ** of the module. Each module implementation will define
- ** the content of a cursor structure to suit its own needs.
- **
- ** This superclass exists in order to define fields of the cursor that
- ** are common to all implementations.
- */
- struct sqlite3_vtab_cursor {
- sqlite3_vtab *pVtab; /* Virtual table of this cursor */
- /* Virtual table implementations will typically add additional fields */
- };
- /*
- ** CAPI3REF: Declare The Schema Of A Virtual Table
- **
- ** ^The [xCreate] and [xConnect] methods of a
- ** [virtual table module] call this interface
- ** to declare the format (the names and datatypes of the columns) of
- ** the virtual tables they implement.
- */
- SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
- /*
- ** CAPI3REF: Overload A Function For A Virtual Table
- **
- ** ^(Virtual tables can provide alternative implementations of functions
- ** using the [xFindFunction] method of the [virtual table module].
- ** But global versions of those functions
- ** must exist in order to be overloaded.)^
- **
- ** ^(This API makes sure a global version of a function with a particular
- ** name and number of parameters exists. If no such function exists
- ** before this API is called, a new function is created.)^ ^The implementation
- ** of the new function always causes an exception to be thrown. So
- ** the new function is not good for anything by itself. Its only
- ** purpose is to be a placeholder function that can be overloaded
- ** by a [virtual table].
- */
- SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
- /*
- ** The interface to the virtual-table mechanism defined above (back up
- ** to a comment remarkably similar to this one) is currently considered
- ** to be experimental. The interface might change in incompatible ways.
- ** If this is a problem for you, do not use the interface at this time.
- **
- ** When the virtual-table mechanism stabilizes, we will declare the
- ** interface fixed, support it indefinitely, and remove this comment.
- */
- /*
- ** CAPI3REF: A Handle To An Open BLOB
- ** KEYWORDS: {BLOB handle} {BLOB handles}
- **
- ** An instance of this object represents an open BLOB on which
- ** [sqlite3_blob_open | incremental BLOB I/O] can be performed.
- ** ^Objects of this type are created by [sqlite3_blob_open()]
- ** and destroyed by [sqlite3_blob_close()].
- ** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
- ** can be used to read or write small subsections of the BLOB.
- ** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
- */
- typedef struct sqlite3_blob sqlite3_blob;
- /*
- ** CAPI3REF: Open A BLOB For Incremental I/O
- **
- ** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
- ** in row iRow, column zColumn, table zTable in database zDb;
- ** in other words, the same BLOB that would be selected by:
- **
- ** <pre>
- ** SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
- ** </pre>)^
- **
- ** ^If the flags parameter is non-zero, then the BLOB is opened for read
- ** and write access. ^If it is zero, the BLOB is opened for read access.
- ** ^It is not possible to open a column that is part of an index or primary
- ** key for writing. ^If [foreign key constraints] are enabled, it is
- ** not possible to open a column that is part of a [child key] for writing.
- **
- ** ^Note that the database name is not the filename that contains
- ** the database but rather the symbolic name of the database that
- ** appears after the AS keyword when the database is connected using [ATTACH].
- ** ^For the main database file, the database name is "main".
- ** ^For TEMP tables, the database name is "temp".
- **
- ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
- ** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set
- ** to be a null pointer.)^
- ** ^This function sets the [database connection] error code and message
- ** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related
- ** functions. ^Note that the *ppBlob variable is always initialized in a
- ** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob
- ** regardless of the success or failure of this routine.
- **
- ** ^(If the row that a BLOB handle points to is modified by an
- ** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
- ** then the BLOB handle is marked as "expired".
- ** This is true if any column of the row is changed, even a column
- ** other than the one the BLOB handle is open on.)^
- ** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for
- ** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
- ** ^(Changes written into a BLOB prior to the BLOB expiring are not
- ** rolled back by the expiration of the BLOB. Such changes will eventually
- ** commit if the transaction continues to completion.)^
- **
- ** ^Use the [sqlite3_blob_bytes()] interface to determine the size of
- ** the opened blob. ^The size of a blob may not be changed by this
- ** interface. Use the [UPDATE] SQL command to change the size of a
- ** blob.
- **
- ** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
- ** and the built-in [zeroblob] SQL function can be used, if desired,
- ** to create an empty, zero-filled blob in which to read or write using
- ** this interface.
- **
- ** To avoid a resource leak, every open [BLOB handle] should eventually
- ** be released by a call to [sqlite3_blob_close()].
- */
- SQLITE_API int sqlite3_blob_open(
- sqlite3*,
- const char *zDb,
- const char *zTable,
- const char *zColumn,
- sqlite3_int64 iRow,
- int flags,
- sqlite3_blob **ppBlob
- );
- /*
- ** CAPI3REF: Move a BLOB Handle to a New Row
- **
- ** ^This function is used to move an existing blob handle so that it points
- ** to a different row of the same database table. ^The new row is identified
- ** by the rowid value passed as the second argument. Only the row can be
- ** changed. ^The database, table and column on which the blob handle is open
- ** remain the same. Moving an existing blob handle to a new row can be
- ** faster than closing the existing handle and opening a new one.
- **
- ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
- ** it must exist and there must be either a blob or text value stored in
- ** the nominated column.)^ ^If the new row is not present in the table, or if
- ** it does not contain a blob or text value, or if another error occurs, an
- ** SQLite error code is returned and the blob handle is considered aborted.
- ** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or
- ** [sqlite3_blob_reopen()] on an aborted blob handle immediately return
- ** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle
- ** always returns zero.
- **
- ** ^This function sets the database handle error code and message.
- */
- SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
- /*
- ** CAPI3REF: Close A BLOB Handle
- **
- ** ^Closes an open [BLOB handle].
- **
- ** ^Closing a BLOB shall cause the current transaction to commit
- ** if there are no other BLOBs, no pending prepared statements, and the
- ** database connection is in [autocommit mode].
- ** ^If any writes were made to the BLOB, they might be held in cache
- ** until the close operation if they will fit.
- **
- ** ^(Closing the BLOB often forces the changes
- ** out to disk and so if any I/O errors occur, they will likely occur
- ** at the time when the BLOB is closed. Any errors that occur during
- ** closing are reported as a non-zero return value.)^
- **
- ** ^(The BLOB is closed unconditionally. Even if this routine returns
- ** an error code, the BLOB is still closed.)^
- **
- ** ^Calling this routine with a null pointer (such as would be returned
- ** by a failed call to [sqlite3_blob_open()]) is a harmless no-op.
- */
- SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
- /*
- ** CAPI3REF: Return The Size Of An Open BLOB
- **
- ** ^Returns the size in bytes of the BLOB accessible via the
- ** successfully opened [BLOB handle] in its only argument. ^The
- ** incremental blob I/O routines can only read or overwriting existing
- ** blob content; they cannot change the size of a blob.
- **
- ** This routine only works on a [BLOB handle] which has been created
- ** by a prior successful call to [sqlite3_blob_open()] and which has not
- ** been closed by [sqlite3_blob_close()]. Passing any other pointer in
- ** to this routine results in undefined and probably undesirable behavior.
- */
- SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
- /*
- ** CAPI3REF: Read Data From A BLOB Incrementally
- **
- ** ^(This function is used to read data from an open [BLOB handle] into a
- ** caller-supplied buffer. N bytes of data are copied into buffer Z
- ** from the open BLOB, starting at offset iOffset.)^
- **
- ** ^If offset iOffset is less than N bytes from the end of the BLOB,
- ** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is
- ** less than zero, [SQLITE_ERROR] is returned and no data is read.
- ** ^The size of the blob (and hence the maximum value of N+iOffset)
- ** can be determined using the [sqlite3_blob_bytes()] interface.
- **
- ** ^An attempt to read from an expired [BLOB handle] fails with an
- ** error code of [SQLITE_ABORT].
- **
- ** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
- ** Otherwise, an [error code] or an [extended error code] is returned.)^
- **
- ** This routine only works on a [BLOB handle] which has been created
- ** by a prior successful call to [sqlite3_blob_open()] and which has not
- ** been closed by [sqlite3_blob_close()]. Passing any other pointer in
- ** to this routine results in undefined and probably undesirable behavior.
- **
- ** See also: [sqlite3_blob_write()].
- */
- SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
- /*
- ** CAPI3REF: Write Data Into A BLOB Incrementally
- **
- ** ^This function is used to write data into an open [BLOB handle] from a
- ** caller-supplied buffer. ^N bytes of data are copied from the buffer Z
- ** into the open BLOB, starting at offset iOffset.
- **
- ** ^If the [BLOB handle] passed as the first argument was not opened for
- ** writing (the flags parameter to [sqlite3_blob_open()] was zero),
- ** this function returns [SQLITE_READONLY].
- **
- ** ^This function may only modify the contents of the BLOB; it is
- ** not possible to increase the size of a BLOB using this API.
- ** ^If offset iOffset is less than N bytes from the end of the BLOB,
- ** [SQLITE_ERROR] is returned and no data is written. ^If N is
- ** less than zero [SQLITE_ERROR] is returned and no data is written.
- ** The size of the BLOB (and hence the maximum value of N+iOffset)
- ** can be determined using the [sqlite3_blob_bytes()] interface.
- **
- ** ^An attempt to write to an expired [BLOB handle] fails with an
- ** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred
- ** before the [BLOB handle] expired are not rolled back by the
- ** expiration of the handle, though of course those changes might
- ** have been overwritten by the statement that expired the BLOB handle
- ** or by other independent statements.
- **
- ** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
- ** Otherwise, an [error code] or an [extended error code] is returned.)^
- **
- ** This routine only works on a [BLOB handle] which has been created
- ** by a prior successful call to [sqlite3_blob_open()] and which has not
- ** been closed by [sqlite3_blob_close()]. Passing any other pointer in
- ** to this routine results in undefined and probably undesirable behavior.
- **
- ** See also: [sqlite3_blob_read()].
- */
- SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
- /*
- ** CAPI3REF: Virtual File System Objects
- **
- ** A virtual filesystem (VFS) is an [sqlite3_vfs] object
- ** that SQLite uses to interact
- ** with the underlying operating system. Most SQLite builds come with a
- ** single default VFS that is appropriate for the host computer.
- ** New VFSes can be registered and existing VFSes can be unregistered.
- ** The following interfaces are provided.
- **
- ** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name.
- ** ^Names are case sensitive.
- ** ^Names are zero-terminated UTF-8 strings.
- ** ^If there is no match, a NULL pointer is returned.
- ** ^If zVfsName is NULL then the default VFS is returned.
- **
- ** ^New VFSes are registered with sqlite3_vfs_register().
- ** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
- ** ^The same VFS can be registered multiple times without injury.
- ** ^To make an existing VFS into the default VFS, register it again
- ** with the makeDflt flag set. If two different VFSes with the
- ** same name are registered, the behavior is undefined. If a
- ** VFS is registered with a name that is NULL or an empty string,
- ** then the behavior is undefined.
- **
- ** ^Unregister a VFS with the sqlite3_vfs_unregister() interface.
- ** ^(If the default VFS is unregistered, another VFS is chosen as
- ** the default. The choice for the new VFS is arbitrary.)^
- */
- SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
- SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
- SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
- /*
- ** CAPI3REF: Mutexes
- **
- ** The SQLite core uses these routines for thread
- ** synchronization. Though they are intended for internal
- ** use by SQLite, code that links against SQLite is
- ** permitted to use any of these routines.
- **
- ** The SQLite source code contains multiple implementations
- ** of these mutex routines. An appropriate implementation
- ** is selected automatically at compile-time. ^(The following
- ** implementations are available in the SQLite core:
- **
- ** <ul>
- ** <li> SQLITE_MUTEX_OS2
- ** <li> SQLITE_MUTEX_PTHREADS
- ** <li> SQLITE_MUTEX_W32
- ** <li> SQLITE_MUTEX_NOOP
- ** </ul>)^
- **
- ** ^The SQLITE_MUTEX_NOOP implementation is a set of routines
- ** that does no real locking and is appropriate for use in
- ** a single-threaded application. ^The SQLITE_MUTEX_OS2,
- ** SQLITE_MUTEX_PTHREADS, and SQLITE_MUTEX_W32 implementations
- ** are appropriate for use on OS/2, Unix, and Windows.
- **
- ** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
- ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
- ** implementation is included with the library. In this case the
- ** application must supply a custom mutex implementation using the
- ** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function
- ** before calling sqlite3_initialize() or any other public sqlite3_
- ** function that calls sqlite3_initialize().)^
- **
- ** ^The sqlite3_mutex_alloc() routine allocates a new
- ** mutex and returns a pointer to it. ^If it returns NULL
- ** that means that a mutex could not be allocated. ^SQLite
- ** will unwind its stack and return an error. ^(The argument
- ** to sqlite3_mutex_alloc() is one of these integer constants:
- **
- ** <ul>
- ** <li> SQLITE_MUTEX_FAST
- ** <li> SQLITE_MUTEX_RECURSIVE
- ** <li> SQLITE_MUTEX_STATIC_MASTER
- ** <li> SQLITE_MUTEX_STATIC_MEM
- ** <li> SQLITE_MUTEX_STATIC_MEM2
- ** <li> SQLITE_MUTEX_STATIC_PRNG
- ** <li> SQLITE_MUTEX_STATIC_LRU
- ** <li> SQLITE_MUTEX_STATIC_LRU2
- ** </ul>)^
- **
- ** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
- ** cause sqlite3_mutex_alloc() to create
- ** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
- ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
- ** The mutex implementation does not need to make a distinction
- ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
- ** not want to. ^SQLite will only request a recursive mutex in
- ** cases where it really needs one. ^If a faster non-recursive mutex
- ** implementation is available on the host platform, the mutex subsystem
- ** might return such a mutex in response to SQLITE_MUTEX_FAST.
- **
- ** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other
- ** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return
- ** a pointer to a static preexisting mutex. ^Six static mutexes are
- ** used by the current version of SQLite. Future versions of SQLite
- ** may add additional static mutexes. Static mutexes are for internal
- ** use by SQLite only. Applications that use SQLite mutexes should
- ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
- ** SQLITE_MUTEX_RECURSIVE.
- **
- ** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
- ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
- ** returns a different mutex on every call. ^But for the static
- ** mutex types, the same mutex is returned on every call that has
- ** the same type number.
- **
- ** ^The sqlite3_mutex_free() routine deallocates a previously
- ** allocated dynamic mutex. ^SQLite is careful to deallocate every
- ** dynamic mutex that it allocates. The dynamic mutexes must not be in
- ** use when they are deallocated. Attempting to deallocate a static
- ** mutex results in undefined behavior. ^SQLite never deallocates
- ** a static mutex.
- **
- ** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- ** to enter a mutex. ^If another thread is already within the mutex,
- ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- ** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
- ** upon successful entry. ^(Mutexes created using
- ** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
- ** In such cases the,
- ** mutex must be exited an equal number of times before another thread
- ** can enter.)^ ^(If the same thread tries to enter any other
- ** kind of mutex more than once, the behavior is undefined.
- ** SQLite will never exhibit
- ** such behavior in its own use of mutexes.)^
- **
- ** ^(Some systems (for example, Windows 95) do not support the operation
- ** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try()
- ** will always return SQLITE_BUSY. The SQLite core only ever uses
- ** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^
- **
- ** ^The sqlite3_mutex_leave() routine exits a mutex that was
- ** previously entered by the same thread. ^(The behavior
- ** is undefined if the mutex is not currently entered by the
- ** calling thread or is not currently allocated. SQLite will
- ** never do either.)^
- **
- ** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
- ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
- ** behave as no-ops.
- **
- ** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
- */
- SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
- SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
- SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
- SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
- SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
- /*
- ** CAPI3REF: Mutex Methods Object
- **
- ** An instance of this structure defines the low-level routines
- ** used to allocate and use mutexes.
- **
- ** Usually, the default mutex implementations provided by SQLite are
- ** sufficient, however the user has the option of substituting a custom
- ** implementation for specialized deployments or systems for which SQLite
- ** does not provide a suitable implementation. In this case, the user
- ** creates and populates an instance of this structure to pass
- ** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
- ** Additionally, an instance of this structure can be used as an
- ** output variable when querying the system for the current mutex
- ** implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
- **
- ** ^The xMutexInit method defined by this structure is invoked as
- ** part of system initialization by the sqlite3_initialize() function.
- ** ^The xMutexInit routine is called by SQLite exactly once for each
- ** effective call to [sqlite3_initialize()].
- **
- ** ^The xMutexEnd method defined by this structure is invoked as
- ** part of system shutdown by the sqlite3_shutdown() function. The
- ** implementation of this method is expected to release all outstanding
- ** resources obtained by the mutex methods implementation, especially
- ** those obtained by the xMutexInit method. ^The xMutexEnd()
- ** interface is invoked exactly once for each call to [sqlite3_shutdown()].
- **
- ** ^(The remaining seven methods defined by this structure (xMutexAlloc,
- ** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
- ** xMutexNotheld) implement the following interfaces (respectively):
- **
- ** <ul>
- ** <li> [sqlite3_mutex_alloc()] </li>
- ** <li> [sqlite3_mutex_free()] </li>
- ** <li> [sqlite3_mutex_enter()] </li>
- ** <li> [sqlite3_mutex_try()] </li>
- ** <li> [sqlite3_mutex_leave()] </li>
- ** <li> [sqlite3_mutex_held()] </li>
- ** <li> [sqlite3_mutex_notheld()] </li>
- ** </ul>)^
- **
- ** The only difference is that the public sqlite3_XXX functions enumerated
- ** above silently ignore any invocations that pass a NULL pointer instead
- ** of a valid mutex handle. The implementations of the methods defined
- ** by this structure are not required to handle this case, the results
- ** of passing a NULL pointer instead of a valid mutex handle are undefined
- ** (i.e. it is acceptable to provide an implementation that segfaults if
- ** it is passed a NULL pointer).
- **
- ** The xMutexInit() method must be threadsafe. ^It must be harmless to
- ** invoke xMutexInit() multiple times within the same process and without
- ** intervening calls to xMutexEnd(). Second and subsequent calls to
- ** xMutexInit() must be no-ops.
- **
- ** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
- ** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory
- ** allocation for a static mutex. ^However xMutexAlloc() may use SQLite
- ** memory allocation for a fast or recursive mutex.
- **
- ** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
- ** called, but only if the prior call to xMutexInit returned SQLITE_OK.
- ** If xMutexInit fails in any way, it is expected to clean up after itself
- ** prior to returning.
- */
- typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
- struct sqlite3_mutex_methods {
- int (*xMutexInit)(void);
- int (*xMutexEnd)(void);
- sqlite3_mutex *(*xMutexAlloc)(int);
- void (*xMutexFree)(sqlite3_mutex *);
- void (*xMutexEnter)(sqlite3_mutex *);
- int (*xMutexTry)(sqlite3_mutex *);
- void (*xMutexLeave)(sqlite3_mutex *);
- int (*xMutexHeld)(sqlite3_mutex *);
- int (*xMutexNotheld)(sqlite3_mutex *);
- };
- /*
- ** CAPI3REF: Mutex Verification Routines
- **
- ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
- ** are intended for use inside assert() statements. ^The SQLite core
- ** never uses these routines except inside an assert() and applications
- ** are advised to follow the lead of the core. ^The SQLite core only
- ** provides implementations for these routines when it is compiled
- ** with the SQLITE_DEBUG flag. ^External mutex implementations
- ** are only required to provide these routines if SQLITE_DEBUG is
- ** defined and if NDEBUG is not defined.
- **
- ** ^These routines should return true if the mutex in their argument
- ** is held or not held, respectively, by the calling thread.
- **
- ** ^The implementation is not required to provide versions of these
- ** routines that actually work. If the implementation does not provide working
- ** versions of these routines, it should at least provide stubs that always
- ** return true so that one does not get spurious assertion failures.
- **
- ** ^If the argument to sqlite3_mutex_held() is a NULL pointer then
- ** the routine should return 1. This seems counter-intuitive since
- ** clearly the mutex cannot be held if it does not exist. But
- ** the reason the mutex does not exist is because the build is not
- ** using mutexes. And we do not want the assert() containing the
- ** call to sqlite3_mutex_held() to fail, so a non-zero return is
- ** the appropriate thing to do. ^The sqlite3_mutex_notheld()
- ** interface should also return 1 when given a NULL pointer.
- */
- #ifndef NDEBUG
- SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
- SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
- #endif
- /*
- ** CAPI3REF: Mutex Types
- **
- ** The [sqlite3_mutex_alloc()] interface takes a single argument
- ** which is one of these integer constants.
- **
- ** The set of static mutexes may change from one SQLite release to the
- ** next. Applications that override the built-in mutex logic must be
- ** prepared to accommodate additional static mutexes.
- */
- #define SQLITE_MUTEX_FAST 0
- #define SQLITE_MUTEX_RECURSIVE 1
- #define SQLITE_MUTEX_STATIC_MASTER 2
- #define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */
- #define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */
- #define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */
- #define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */
- #define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */
- #define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */
- #define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */
- /*
- ** CAPI3REF: Retrieve the mutex for a database connection
- **
- ** ^This interface returns a pointer the [sqlite3_mutex] object that
- ** serializes access to the [database connection] given in the argument
- ** when the [threading mode] is Serialized.
- ** ^If the [threading mode] is Single-thread or Multi-thread then this
- ** routine returns a NULL pointer.
- */
- SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
- /*
- ** CAPI3REF: Low-Level Control Of Database Files
- **
- ** ^The [sqlite3_file_control()] interface makes a direct call to the
- ** xFileControl method for the [sqlite3_io_methods] object associated
- ** with a particular database identified by the second argument. ^The
- ** name of the database is "main" for the main database or "temp" for the
- ** TEMP database, or the name that appears after the AS keyword for
- ** databases that are added using the [ATTACH] SQL command.
- ** ^A NULL pointer can be used in place of "main" to refer to the
- ** main database file.
- ** ^The third and fourth parameters to this routine
- ** are passed directly through to the second and third parameters of
- ** the xFileControl method. ^The return value of the xFileControl
- ** method becomes the return value of this routine.
- **
- ** ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes
- ** a pointer to the underlying [sqlite3_file] object to be written into
- ** the space pointed to by the 4th parameter. ^The SQLITE_FCNTL_FILE_POINTER
- ** case is a short-circuit path which does not actually invoke the
- ** underlying sqlite3_io_methods.xFileControl method.
- **
- ** ^If the second parameter (zDbName) does not match the name of any
- ** open database file, then SQLITE_ERROR is returned. ^This error
- ** code is not remembered and will not be recalled by [sqlite3_errcode()]
- ** or [sqlite3_errmsg()]. The underlying xFileControl method might
- ** also return SQLITE_ERROR. There is no way to distinguish between
- ** an incorrect zDbName and an SQLITE_ERROR return from the underlying
- ** xFileControl method.
- **
- ** See also: [SQLITE_FCNTL_LOCKSTATE]
- */
- SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
- /*
- ** CAPI3REF: Testing Interface
- **
- ** ^The sqlite3_test_control() interface is used to read out internal
- ** state of SQLite and to inject faults into SQLite for testing
- ** purposes. ^The first parameter is an operation code that determines
- ** the number, meaning, and operation of all subsequent parameters.
- **
- ** This interface is not for use by applications. It exists solely
- ** for verifying the correct operation of the SQLite library. Depending
- ** on how the SQLite library is compiled, this interface might not exist.
- **
- ** The details of the operation codes, their meanings, the parameters
- ** they take, and what they do are all subject to change without notice.
- ** Unlike most of the SQLite API, this function is not guaranteed to
- ** operate consistently from one release to the next.
- */
- SQLITE_API int sqlite3_test_control(int op, ...);
- /*
- ** CAPI3REF: Testing Interface Operation Codes
- **
- ** These constants are the valid operation code parameters used
- ** as the first argument to [sqlite3_test_control()].
- **
- ** These parameters and their meanings are subject to change
- ** without notice. These values are for testing purposes only.
- ** Applications should not use any of these parameters or the
- ** [sqlite3_test_control()] interface.
- */
- #define SQLITE_TESTCTRL_FIRST 5
- #define SQLITE_TESTCTRL_PRNG_SAVE 5
- #define SQLITE_TESTCTRL_PRNG_RESTORE 6
- #define SQLITE_TESTCTRL_PRNG_RESET 7
- #define SQLITE_TESTCTRL_BITVEC_TEST 8
- #define SQLITE_TESTCTRL_FAULT_INSTALL 9
- #define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10
- #define SQLITE_TESTCTRL_PENDING_BYTE 11
- #define SQLITE_TESTCTRL_ASSERT 12
- #define SQLITE_TESTCTRL_ALWAYS 13
- #define SQLITE_TESTCTRL_RESERVE 14
- #define SQLITE_TESTCTRL_OPTIMIZATIONS 15
- #define SQLITE_TESTCTRL_ISKEYWORD 16
- #define SQLITE_TESTCTRL_SCRATCHMALLOC 17
- #define SQLITE_TESTCTRL_LOCALTIME_FAULT 18
- #define SQLITE_TESTCTRL_EXPLAIN_STMT 19
- #define SQLITE_TESTCTRL_LAST 19
- /*
- ** CAPI3REF: SQLite Runtime Status
- **
- ** ^This interface is used to retrieve runtime status information
- ** about the performance of SQLite, and optionally to reset various
- ** highwater marks. ^The first argument is an integer code for
- ** the specific parameter to measure. ^(Recognized integer codes
- ** are of the form [status parameters | SQLITE_STATUS_...].)^
- ** ^The current value of the parameter is returned into *pCurrent.
- ** ^The highest recorded value is returned in *pHighwater. ^If the
- ** resetFlag is true, then the highest record value is reset after
- ** *pHighwater is written. ^(Some parameters do not record the highest
- ** value. For those parameters
- ** nothing is written into *pHighwater and the resetFlag is ignored.)^
- ** ^(Other parameters record only the highwater mark and not the current
- ** value. For these latter parameters nothing is written into *pCurrent.)^
- **
- ** ^The sqlite3_status() routine returns SQLITE_OK on success and a
- ** non-zero [error code] on failure.
- **
- ** This routine is threadsafe but is not atomic. This routine can be
- ** called while other threads are running the same or different SQLite
- ** interfaces. However the values returned in *pCurrent and
- ** *pHighwater reflect the status of SQLite at different points in time
- ** and it is possible that another thread might change the parameter
- ** in between the times when *pCurrent and *pHighwater are written.
- **
- ** See also: [sqlite3_db_status()]
- */
- SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
- /*
- ** CAPI3REF: Status Parameters
- ** KEYWORDS: {status parameters}
- **
- ** These integer constants designate various run-time status parameters
- ** that can be returned by [sqlite3_status()].
- **
- ** <dl>
- ** [[SQLITE_STATUS_MEMORY_USED]] ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
- ** <dd>This parameter is the current amount of memory checked out
- ** using [sqlite3_malloc()], either directly or indirectly. The
- ** figure includes calls made to [sqlite3_malloc()] by the application
- ** and internal memory usage by the SQLite library. Scratch memory
- ** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache
- ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
- ** this parameter. The amount returned is the sum of the allocation
- ** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^
- **
- ** [[SQLITE_STATUS_MALLOC_SIZE]] ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
- ** <dd>This parameter records the largest memory allocation request
- ** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their
- ** internal equivalents). Only the value returned in the
- ** *pHighwater parameter to [sqlite3_status()] is of interest.
- ** The value written into the *pCurrent parameter is undefined.</dd>)^
- **
- ** [[SQLITE_STATUS_MALLOC_COUNT]] ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>
- ** <dd>This parameter records the number of separate memory allocations
- ** currently checked out.</dd>)^
- **
- ** [[SQLITE_STATUS_PAGECACHE_USED]] ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
- ** <dd>This parameter returns the number of pages used out of the
- ** [pagecache memory allocator] that was configured using
- ** [SQLITE_CONFIG_PAGECACHE]. The
- ** value returned is in pages, not in bytes.</dd>)^
- **
- ** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]]
- ** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
- ** <dd>This parameter returns the number of bytes of page cache
- ** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]
- ** buffer and where forced to overflow to [sqlite3_malloc()]. The
- ** returned value includes allocations that overflowed because they
- ** where too large (they were larger than the "sz" parameter to
- ** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because
- ** no space was left in the page cache.</dd>)^
- **
- ** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
- ** <dd>This parameter records the largest memory allocation request
- ** handed to [pagecache memory allocator]. Only the value returned in the
- ** *pHighwater parameter to [sqlite3_status()] is of interest.
- ** The value written into the *pCurrent parameter is undefined.</dd>)^
- **
- ** [[SQLITE_STATUS_SCRATCH_USED]] ^(<dt>SQLITE_STATUS_SCRATCH_USED</dt>
- ** <dd>This parameter returns the number of allocations used out of the
- ** [scratch memory allocator] configured using
- ** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not
- ** in bytes. Since a single thread may only have one scratch allocation
- ** outstanding at time, this parameter also reports the number of threads
- ** using scratch memory at the same time.</dd>)^
- **
- ** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
- ** <dd>This parameter returns the number of bytes of scratch memory
- ** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
- ** buffer and where forced to overflow to [sqlite3_malloc()]. The values
- ** returned include overflows because the requested allocation was too
- ** larger (that is, because the requested allocation was larger than the
- ** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer
- ** slots were available.
- ** </dd>)^
- **
- ** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(<dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
- ** <dd>This parameter records the largest memory allocation request
- ** handed to [scratch memory allocator]. Only the value returned in the
- ** *pHighwater parameter to [sqlite3_status()] is of interest.
- ** The value written into the *pCurrent parameter is undefined.</dd>)^
- **
- ** [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
- ** <dd>This parameter records the deepest parser stack. It is only
- ** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^
- ** </dl>
- **
- ** New status parameters may be added from time to time.
- */
- #define SQLITE_STATUS_MEMORY_USED 0
- #define SQLITE_STATUS_PAGECACHE_USED 1
- #define SQLITE_STATUS_PAGECACHE_OVERFLOW 2
- #define SQLITE_STATUS_SCRATCH_USED 3
- #define SQLITE_STATUS_SCRATCH_OVERFLOW 4
- #define SQLITE_STATUS_MALLOC_SIZE 5
- #define SQLITE_STATUS_PARSER_STACK 6
- #define SQLITE_STATUS_PAGECACHE_SIZE 7
- #define SQLITE_STATUS_SCRATCH_SIZE 8
- #define SQLITE_STATUS_MALLOC_COUNT 9
- /*
- ** CAPI3REF: Database Connection Status
- **
- ** ^This interface is used to retrieve runtime status information
- ** about a single [database connection]. ^The first argument is the
- ** database connection object to be interrogated. ^The second argument
- ** is an integer constant, taken from the set of
- ** [SQLITE_DBSTATUS options], that
- ** determines the parameter to interrogate. The set of
- ** [SQLITE_DBSTATUS options] is likely
- ** to grow in future releases of SQLite.
- **
- ** ^The current value of the requested parameter is written into *pCur
- ** and the highest instantaneous value is written into *pHiwtr. ^If
- ** the resetFlg is true, then the highest instantaneous value is
- ** reset back down to the current value.
- **
- ** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
- ** non-zero [error code] on failure.
- **
- ** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
- */
- SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
- /*
- ** CAPI3REF: Status Parameters for database connections
- ** KEYWORDS: {SQLITE_DBSTATUS options}
- **
- ** These constants are the available integer "verbs" that can be passed as
- ** the second argument to the [sqlite3_db_status()] interface.
- **
- ** New verbs may be added in future releases of SQLite. Existing verbs
- ** might be discontinued. Applications should check the return code from
- ** [sqlite3_db_status()] to make sure that the call worked.
- ** The [sqlite3_db_status()] interface will return a non-zero error code
- ** if a discontinued or unsupported verb is invoked.
- **
- ** <dl>
- ** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
- ** <dd>This parameter returns the number of lookaside memory slots currently
- ** checked out.</dd>)^
- **
- ** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>
- ** <dd>This parameter returns the number malloc attempts that were
- ** satisfied using lookaside memory. Only the high-water value is meaningful;
- ** the current value is always zero.)^
- **
- ** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]
- ** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
- ** <dd>This parameter returns the number malloc attempts that might have
- ** been satisfied using lookaside memory but failed due to the amount of
- ** memory requested being larger than the lookaside slot size.
- ** Only the high-water value is meaningful;
- ** the current value is always zero.)^
- **
- ** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]
- ** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
- ** <dd>This parameter returns the number malloc attempts that might have
- ** been satisfied using lookaside memory but failed due to all lookaside
- ** memory already being in use.
- ** Only the high-water value is meaningful;
- ** the current value is always zero.)^
- **
- ** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
- ** <dd>This parameter returns the approximate number of of bytes of heap
- ** memory used by all pager caches associated with the database connection.)^
- ** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
- **
- ** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
- ** <dd>This parameter returns the approximate number of of bytes of heap
- ** memory used to store the schema for all databases associated
- ** with the connection - main, temp, and any [ATTACH]-ed databases.)^
- ** ^The full amount of memory used by the schemas is reported, even if the
- ** schema memory is shared with other database connections due to
- ** [shared cache mode] being enabled.
- ** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.
- **
- ** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
- ** <dd>This parameter returns the approximate number of of bytes of heap
- ** and lookaside memory used by all prepared statements associated with
- ** the database connection.)^
- ** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0.
- ** </dd>
- **
- ** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(<dt>SQLITE_DBSTATUS_CACHE_HIT</dt>
- ** <dd>This parameter returns the number of pager cache hits that have
- ** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT
- ** is always 0.
- ** </dd>
- **
- ** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(<dt>SQLITE_DBSTATUS_CACHE_MISS</dt>
- ** <dd>This parameter returns the number of pager cache misses that have
- ** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS
- ** is always 0.
- ** </dd>
- ** </dl>
- */
- #define SQLITE_DBSTATUS_LOOKASIDE_USED 0
- #define SQLITE_DBSTATUS_CACHE_USED 1
- #define SQLITE_DBSTATUS_SCHEMA_USED 2
- #define SQLITE_DBSTATUS_STMT_USED 3
- #define SQLITE_DBSTATUS_LOOKASIDE_HIT 4
- #define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5
- #define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6
- #define SQLITE_DBSTATUS_CACHE_HIT 7
- #define SQLITE_DBSTATUS_CACHE_MISS 8
- #define SQLITE_DBSTATUS_MAX 8 /* Largest defined DBSTATUS */
- /*
- ** CAPI3REF: Prepared Statement Status
- **
- ** ^(Each prepared statement maintains various
- ** [SQLITE_STMTSTATUS counters] that measure the number
- ** of times it has performed specific operations.)^ These counters can
- ** be used to monitor the performance characteristics of the prepared
- ** statements. For example, if the number of table steps greatly exceeds
- ** the number of table searches or result rows, that would tend to indicate
- ** that the prepared statement is using a full table scan rather than
- ** an index.
- **
- ** ^(This interface is used to retrieve and reset counter values from
- ** a [prepared statement]. The first argument is the prepared statement
- ** object to be interrogated. The second argument
- ** is an integer code for a specific [SQLITE_STMTSTATUS counter]
- ** to be interrogated.)^
- ** ^The current value of the requested counter is returned.
- ** ^If the resetFlg is true, then the counter is reset to zero after this
- ** interface call returns.
- **
- ** See also: [sqlite3_status()] and [sqlite3_db_status()].
- */
- SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
- /*
- ** CAPI3REF: Status Parameters for prepared statements
- ** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters}
- **
- ** These preprocessor macros define integer codes that name counter
- ** values associated with the [sqlite3_stmt_status()] interface.
- ** The meanings of the various counters are as follows:
- **
- ** <dl>
- ** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
- ** <dd>^This is the number of times that SQLite has stepped forward in
- ** a table as part of a full table scan. Large numbers for this counter
- ** may indicate opportunities for performance improvement through
- ** careful use of indices.</dd>
- **
- ** [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>
- ** <dd>^This is the number of sort operations that have occurred.
- ** A non-zero value in this counter may indicate an opportunity to
- ** improvement performance through careful use of indices.</dd>
- **
- ** [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>
- ** <dd>^This is the number of rows inserted into transient indices that
- ** were created automatically in order to help joins run faster.
- ** A non-zero value in this counter may indicate an opportunity to
- ** improvement performance by adding permanent indices that do not
- ** need to be reinitialized each time the statement is run.</dd>
- ** </dl>
- */
- #define SQLITE_STMTSTATUS_FULLSCAN_STEP 1
- #define SQLITE_STMTSTATUS_SORT 2
- #define SQLITE_STMTSTATUS_AUTOINDEX 3
- /*
- ** CAPI3REF: Custom Page Cache Object
- **
- ** The sqlite3_pcache type is opaque. It is implemented by
- ** the pluggable module. The SQLite core has no knowledge of
- ** its size or internal structure and never deals with the
- ** sqlite3_pcache object except by holding and passing pointers
- ** to the object.
- **
- ** See [sqlite3_pcache_methods2] for additional information.
- */
- typedef struct sqlite3_pcache sqlite3_pcache;
- /*
- ** CAPI3REF: Custom Page Cache Object
- **
- ** The sqlite3_pcache_page object represents a single page in the
- ** page cache. The page cache will allocate instances of this
- ** object. Various methods of the page cache use pointers to instances
- ** of this object as parameters or as their return value.
- **
- ** See [sqlite3_pcache_methods2] for additional information.
- */
- typedef struct sqlite3_pcache_page sqlite3_pcache_page;
- struct sqlite3_pcache_page {
- void *pBuf; /* The content of the page */
- void *pExtra; /* Extra information associated with the page */
- };
- /*
- ** CAPI3REF: Application Defined Page Cache.
- ** KEYWORDS: {page cache}
- **
- ** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can
- ** register an alternative page cache implementation by passing in an
- ** instance of the sqlite3_pcache_methods2 structure.)^
- ** In many applications, most of the heap memory allocated by
- ** SQLite is used for the page cache.
- ** By implementing a
- ** custom page cache using this API, an application can better control
- ** the amount of memory consumed by SQLite, the way in which
- ** that memory is allocated and released, and the policies used to
- ** determine exactly which parts of a database file are cached and for
- ** how long.
- **
- ** The alternative page cache mechanism is an
- ** extreme measure that is only needed by the most demanding applications.
- ** The built-in page cache is recommended for most uses.
- **
- ** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
- ** internal buffer by SQLite within the call to [sqlite3_config]. Hence
- ** the application may discard the parameter after the call to
- ** [sqlite3_config()] returns.)^
- **
- ** [[the xInit() page cache method]]
- ** ^(The xInit() method is called once for each effective
- ** call to [sqlite3_initialize()])^
- ** (usually only once during the lifetime of the process). ^(The xInit()
- ** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
- ** The intent of the xInit() method is to set up global data structures
- ** required by the custom page cache implementation.
- ** ^(If the xInit() method is NULL, then the
- ** built-in default page cache is used instead of the application defined
- ** page cache.)^
- **
- ** [[the xShutdown() page cache method]]
- ** ^The xShutdown() method is called by [sqlite3_shutdown()].
- ** It can be used to clean up
- ** any outstanding resources before process shutdown, if required.
- ** ^The xShutdown() method may be NULL.
- **
- ** ^SQLite automatically serializes calls to the xInit method,
- ** so the xInit method need not be threadsafe. ^The
- ** xShutdown method is only called from [sqlite3_shutdown()] so it does
- ** not need to be threadsafe either. All other methods must be threadsafe
- ** in multithreaded applications.
- **
- ** ^SQLite will never invoke xInit() more than once without an intervening
- ** call to xShutdown().
- **
- ** [[the xCreate() page cache methods]]
- ** ^SQLite invokes the xCreate() method to construct a new cache instance.
- ** SQLite will typically create one cache instance for each open database file,
- ** though this is not guaranteed. ^The
- ** first parameter, szPage, is the size in bytes of the pages that must
- ** be allocated by the cache. ^szPage will always a power of two. ^The
- ** second parameter szExtra is a number of bytes of extra storage
- ** associated with each page cache entry. ^The szExtra parameter will
- ** a number less than 250. SQLite will use the
- ** extra szExtra bytes on each page to store metadata about the underlying
- ** database page on disk. The value passed into szExtra depends
- ** on the SQLite version, the target platform, and how SQLite was compiled.
- ** ^The third argument to xCreate(), bPurgeable, is true if the cache being
- ** created will be used to cache database pages of a file stored on disk, or
- ** false if it is used for an in-memory database. The cache implementation
- ** does not have to do anything special based with the value of bPurgeable;
- ** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will
- ** never invoke xUnpin() except to deliberately delete a page.
- ** ^In other words, calls to xUnpin() on a cache with bPurgeable set to
- ** false will always have the "discard" flag set to true.
- ** ^Hence, a cache created with bPurgeable false will
- ** never contain any unpinned pages.
- **
- ** [[the xCachesize() page cache method]]
- ** ^(The xCachesize() method may be called at any time by SQLite to set the
- ** suggested maximum cache-size (number of pages stored by) the cache
- ** instance passed as the first argument. This is the value configured using
- ** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable
- ** parameter, the implementation is not required to do anything with this
- ** value; it is advisory only.
- **
- ** [[the xPagecount() page cache methods]]
- ** The xPagecount() method must return the number of pages currently
- ** stored in the cache, both pinned and unpinned.
- **
- ** [[the xFetch() page cache methods]]
- ** The xFetch() method locates a page in the cache and returns a pointer to
- ** an sqlite3_pcache_page object associated with that page, or a NULL pointer.
- ** The pBuf element of the returned sqlite3_pcache_page object will be a
- ** pointer to a buffer of szPage bytes used to store the content of a
- ** single database page. The pExtra element of sqlite3_pcache_page will be
- ** a pointer to the szExtra bytes of extra storage that SQLite has requested
- ** for each entry in the page cache.
- **
- ** The page to be fetched is determined by the key. ^The minimum key value
- ** is 1. After it has been retrieved using xFetch, the page is considered
- ** to be "pinned".
- **
- ** If the requested page is already in the page cache, then the page cache
- ** implementation must return a pointer to the page buffer with its content
- ** intact. If the requested page is not already in the cache, then the
- ** cache implementation should use the value of the createFlag
- ** parameter to help it determined what action to take:
- **
- ** <table border=1 width=85% align=center>
- ** <tr><th> createFlag <th> Behaviour when page is not already in cache
- ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
- ** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
- ** Otherwise return NULL.
- ** <tr><td> 2 <td> Make every effort to allocate a new page. Only return
- ** NULL if allocating a new page is effectively impossible.
- ** </table>
- **
- ** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite
- ** will only use a createFlag of 2 after a prior call with a createFlag of 1
- ** failed.)^ In between the to xFetch() calls, SQLite may
- ** attempt to unpin one or more cache pages by spilling the content of
- ** pinned pages to disk and synching the operating system disk cache.
- **
- ** [[the xUnpin() page cache method]]
- ** ^xUnpin() is called by SQLite with a pointer to a currently pinned page
- ** as its second argument. If the third parameter, discard, is non-zero,
- ** then the page must be evicted from the cache.
- ** ^If the discard parameter is
- ** zero, then the page may be discarded or retained at the discretion of
- ** page cache implementation. ^The page cache implementation
- ** may choose to evict unpinned pages at any time.
- **
- ** The cache must not perform any reference counting. A single
- ** call to xUnpin() unpins the page regardless of the number of prior calls
- ** to xFetch().
- **
- ** [[the xRekey() page cache methods]]
- ** The xRekey() method is used to change the key value associated with the
- ** page passed as the second argument. If the cache
- ** previously contains an entry associated with newKey, it must be
- ** discarded. ^Any prior cache entry associated with newKey is guaranteed not
- ** to be pinned.
- **
- ** When SQLite calls the xTruncate() method, the cache must discard all
- ** existing cache entries with page numbers (keys) greater than or equal
- ** to the value of the iLimit parameter passed to xTruncate(). If any
- ** of these pages are pinned, they are implicitly unpinned, meaning that
- ** they can be safely discarded.
- **
- ** [[the xDestroy() page cache method]]
- ** ^The xDestroy() method is used to delete a cache allocated by xCreate().
- ** All resources associated with the specified cache should be freed. ^After
- ** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]
- ** handle invalid, and will not use it with any other sqlite3_pcache_methods2
- ** functions.
- **
- ** [[the xShrink() page cache method]]
- ** ^SQLite invokes the xShrink() method when it wants the page cache to
- ** free up as much of heap memory as possible. The page cache implementation
- ** is not obligated to free any memory, but well-behaved implementations should
- ** do their best.
- */
- typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
- struct sqlite3_pcache_methods2 {
- int iVersion;
- void *pArg;
- int (*xInit)(void*);
- void (*xShutdown)(void*);
- sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable);
- void (*xCachesize)(sqlite3_pcache*, int nCachesize);
- int (*xPagecount)(sqlite3_pcache*);
- sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
- void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard);
- void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*,
- unsigned oldKey, unsigned newKey);
- void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
- void (*xDestroy)(sqlite3_pcache*);
- void (*xShrink)(sqlite3_pcache*);
- };
- /*
- ** This is the obsolete pcache_methods object that has now been replaced
- ** by sqlite3_pcache_methods2. This object is not used by SQLite. It is
- ** retained in the header file for backwards compatibility only.
- */
- typedef struct sqlite3_pcache_methods sqlite3_pcache_methods;
- struct sqlite3_pcache_methods {
- void *pArg;
- int (*xInit)(void*);
- void (*xShutdown)(void*);
- sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable);
- void (*xCachesize)(sqlite3_pcache*, int nCachesize);
- int (*xPagecount)(sqlite3_pcache*);
- void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
- void (*xUnpin)(sqlite3_pcache*, void*, int discard);
- void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey);
- void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
- void (*xDestroy)(sqlite3_pcache*);
- };
- /*
- ** CAPI3REF: Online Backup Object
- **
- ** The sqlite3_backup object records state information about an ongoing
- ** online backup operation. ^The sqlite3_backup object is created by
- ** a call to [sqlite3_backup_init()] and is destroyed by a call to
- ** [sqlite3_backup_finish()].
- **
- ** See Also: [Using the SQLite Online Backup API]
- */
- typedef struct sqlite3_backup sqlite3_backup;
- /*
- ** CAPI3REF: Online Backup API.
- **
- ** The backup API copies the content of one database into another.
- ** It is useful either for creating backups of databases or
- ** for copying in-memory databases to or from persistent files.
- **
- ** See Also: [Using the SQLite Online Backup API]
- **
- ** ^SQLite holds a write transaction open on the destination database file
- ** for the duration of the backup operation.
- ** ^The source database is read-locked only while it is being read;
- ** it is not locked continuously for the entire backup operation.
- ** ^Thus, the backup may be performed on a live source database without
- ** preventing other database connections from
- ** reading or writing to the source database while the backup is underway.
- **
- ** ^(To perform a backup operation:
- ** <ol>
- ** <li><b>sqlite3_backup_init()</b> is called once to initialize the
- ** backup,
- ** <li><b>sqlite3_backup_step()</b> is called one or more times to transfer
- ** the data between the two databases, and finally
- ** <li><b>sqlite3_backup_finish()</b> is called to release all resources
- ** associated with the backup operation.
- ** </ol>)^
- ** There should be exactly one call to sqlite3_backup_finish() for each
- ** successful call to sqlite3_backup_init().
- **
- ** [[sqlite3_backup_init()]] <b>sqlite3_backup_init()</b>
- **
- ** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the
- ** [database connection] associated with the destination database
- ** and the database name, respectively.
- ** ^The database name is "main" for the main database, "temp" for the
- ** temporary database, or the name specified after the AS keyword in
- ** an [ATTACH] statement for an attached database.
- ** ^The S and M arguments passed to
- ** sqlite3_backup_init(D,N,S,M) identify the [database connection]
- ** and database name of the source database, respectively.
- ** ^The source and destination [database connections] (parameters S and D)
- ** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
- ** an error.
- **
- ** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
- ** returned and an error code and error message are stored in the
- ** destination [database connection] D.
- ** ^The error code and message for the failed call to sqlite3_backup_init()
- ** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or
- ** [sqlite3_errmsg16()] functions.
- ** ^A successful call to sqlite3_backup_init() returns a pointer to an
- ** [sqlite3_backup] object.
- ** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and
- ** sqlite3_backup_finish() functions to perform the specified backup
- ** operation.
- **
- ** [[sqlite3_backup_step()]] <b>sqlite3_backup_step()</b>
- **
- ** ^Function sqlite3_backup_step(B,N) will copy up to N pages between
- ** the source and destination databases specified by [sqlite3_backup] object B.
- ** ^If N is negative, all remaining source pages are copied.
- ** ^If sqlite3_backup_step(B,N) successfully copies N pages and there
- ** are still more pages to be copied, then the function returns [SQLITE_OK].
- ** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
- ** from source to destination, then it returns [SQLITE_DONE].
- ** ^If an error occurs while running sqlite3_backup_step(B,N),
- ** then an [error code] is returned. ^As well as [SQLITE_OK] and
- ** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY],
- ** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an
- ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code.
- **
- ** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if
- ** <ol>
- ** <li> the destination database was opened read-only, or
- ** <li> the destination database is using write-ahead-log journaling
- ** and the destination and source page sizes differ, or
- ** <li> the destination database is an in-memory database and the
- ** destination and source page sizes differ.
- ** </ol>)^
- **
- ** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
- ** the [sqlite3_busy_handler | busy-handler function]
- ** is invoked (if one is specified). ^If the
- ** busy-handler returns non-zero before the lock is available, then
- ** [SQLITE_BUSY] is returned to the caller. ^In this case the call to
- ** sqlite3_backup_step() can be retried later. ^If the source
- ** [database connection]
- ** is being used to write to the source database when sqlite3_backup_step()
- ** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this
- ** case the call to sqlite3_backup_step() can be retried later on. ^(If
- ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or
- ** [SQLITE_READONLY] is returned, then
- ** there is no point in retrying the call to sqlite3_backup_step(). These
- ** errors are considered fatal.)^ The application must accept
- ** that the backup operation has failed and pass the backup operation handle
- ** to the sqlite3_backup_finish() to release associated resources.
- **
- ** ^The first call to sqlite3_backup_step() obtains an exclusive lock
- ** on the destination file. ^The exclusive lock is not released until either
- ** sqlite3_backup_finish() is called or the backup operation is complete
- ** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to
- ** sqlite3_backup_step() obtains a [shared lock] on the source database that
- ** lasts for the duration of the sqlite3_backup_step() call.
- ** ^Because the source database is not locked between calls to
- ** sqlite3_backup_step(), the source database may be modified mid-way
- ** through the backup process. ^If the source database is modified by an
- ** external process or via a database connection other than the one being
- ** used by the backup operation, then the backup will be automatically
- ** restarted by the next call to sqlite3_backup_step(). ^If the source
- ** database is modified by the using the same database connection as is used
- ** by the backup operation, then the backup database is automatically
- ** updated at the same time.
- **
- ** [[sqlite3_backup_finish()]] <b>sqlite3_backup_finish()</b>
- **
- ** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the
- ** application wishes to abandon the backup operation, the application
- ** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish().
- ** ^The sqlite3_backup_finish() interfaces releases all
- ** resources associated with the [sqlite3_backup] object.
- ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
- ** active write-transaction on the destination database is rolled back.
- ** The [sqlite3_backup] object is invalid
- ** and may not be used following a call to sqlite3_backup_finish().
- **
- ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
- ** sqlite3_backup_step() errors occurred, regardless or whether or not
- ** sqlite3_backup_step() completed.
- ** ^If an out-of-memory condition or IO error occurred during any prior
- ** sqlite3_backup_step() call on the same [sqlite3_backup] object, then
- ** sqlite3_backup_finish() returns the corresponding [error code].
- **
- ** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step()
- ** is not a permanent error and does not affect the return value of
- ** sqlite3_backup_finish().
- **
- ** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]]
- ** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
- **
- ** ^Each call to sqlite3_backup_step() sets two values inside
- ** the [sqlite3_backup] object: the number of pages still to be backed
- ** up and the total number of pages in the source database file.
- ** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces
- ** retrieve these two values, respectively.
- **
- ** ^The values returned by these functions are only updated by
- ** sqlite3_backup_step(). ^If the source database is modified during a backup
- ** operation, then the values are not updated to account for any extra
- ** pages that need to be updated or the size of the source database file
- ** changing.
- **
- ** <b>Concurrent Usage of Database Handles</b>
- **
- ** ^The source [database connection] may be used by the application for other
- ** purposes while a backup operation is underway or being initialized.
- ** ^If SQLite is compiled and configured to support threadsafe database
- ** connections, then the source database connection may be used concurrently
- ** from within other threads.
- **
- ** However, the application must guarantee that the destination
- ** [database connection] is not passed to any other API (by any thread) after
- ** sqlite3_backup_init() is called and before the corresponding call to
- ** sqlite3_backup_finish(). SQLite does not currently check to see
- ** if the application incorrectly accesses the destination [database connection]
- ** and so no error code is reported, but the operations may malfunction
- ** nevertheless. Use of the destination database connection while a
- ** backup is in progress might also also cause a mutex deadlock.
- **
- ** If running in [shared cache mode], the application must
- ** guarantee that the shared cache used by the destination database
- ** is not accessed while the backup is running. In practice this means
- ** that the application must guarantee that the disk file being
- ** backed up to is not accessed by any connection within the process,
- ** not just the specific connection that was passed to sqlite3_backup_init().
- **
- ** The [sqlite3_backup] object itself is partially threadsafe. Multiple
- ** threads may safely make multiple concurrent calls to sqlite3_backup_step().
- ** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount()
- ** APIs are not strictly speaking threadsafe. If they are invoked at the
- ** same time as another thread is invoking sqlite3_backup_step() it is
- ** possible that they return invalid values.
- */
- SQLITE_API sqlite3_backup *sqlite3_backup_init(
- sqlite3 *pDest, /* Destination database handle */
- const char *zDestName, /* Destination database name */
- sqlite3 *pSource, /* Source database handle */
- const char *zSourceName /* Source database name */
- );
- SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
- SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
- SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
- SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
- /*
- ** CAPI3REF: Unlock Notification
- **
- ** ^When running in shared-cache mode, a database operation may fail with
- ** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
- ** individual tables within the shared-cache cannot be obtained. See
- ** [SQLite Shared-Cache Mode] for a description of shared-cache locking.
- ** ^This API may be used to register a callback that SQLite will invoke
- ** when the connection currently holding the required lock relinquishes it.
- ** ^This API is only available if the library was compiled with the
- ** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
- **
- ** See Also: [Using the SQLite Unlock Notification Feature].
- **
- ** ^Shared-cache locks are released when a database connection concludes
- ** its current transaction, either by committing it or rolling it back.
- **
- ** ^When a connection (known as the blocked connection) fails to obtain a
- ** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
- ** identity of the database connection (the blocking connection) that
- ** has locked the required resource is stored internally. ^After an
- ** application receives an SQLITE_LOCKED error, it may call the
- ** sqlite3_unlock_notify() method with the blocked connection handle as
- ** the first argument to register for a callback that will be invoked
- ** when the blocking connections current transaction is concluded. ^The
- ** callback is invoked from within the [sqlite3_step] or [sqlite3_close]
- ** call that concludes the blocking connections transaction.
- **
- ** ^(If sqlite3_unlock_notify() is called in a multi-threaded application,
- ** there is a chance that the blocking connection will have already
- ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
- ** If this happens, then the specified callback is invoked immediately,
- ** from within the call to sqlite3_unlock_notify().)^
- **
- ** ^If the blocked connection is attempting to obtain a write-lock on a
- ** shared-cache table, and more than one other connection currently holds
- ** a read-lock on the same table, then SQLite arbitrarily selects one of
- ** the other connections to use as the blocking connection.
- **
- ** ^(There may be at most one unlock-notify callback registered by a
- ** blocked connection. If sqlite3_unlock_notify() is called when the
- ** blocked connection already has a registered unlock-notify callback,
- ** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
- ** called with a NULL pointer as its second argument, then any existing
- ** unlock-notify callback is canceled. ^The blocked connections
- ** unlock-notify callback may also be canceled by closing the blocked
- ** connection using [sqlite3_close()].
- **
- ** The unlock-notify callback is not reentrant. If an application invokes
- ** any sqlite3_xxx API functions from within an unlock-notify callback, a
- ** crash or deadlock may be the result.
- **
- ** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always
- ** returns SQLITE_OK.
- **
- ** <b>Callback Invocation Details</b>
- **
- ** When an unlock-notify callback is registered, the application provides a
- ** single void* pointer that is passed to the callback when it is invoked.
- ** However, the signature of the callback function allows SQLite to pass
- ** it an array of void* context pointers. The first argument passed to
- ** an unlock-notify callback is a pointer to an array of void* pointers,
- ** and the second is the number of entries in the array.
- **
- ** When a blocking connections transaction is concluded, there may be
- ** more than one blocked connection that has registered for an unlock-notify
- ** callback. ^If two or more such blocked connections have specified the
- ** same callback function, then instead of invoking the callback function
- ** multiple times, it is invoked once with the set of void* context pointers
- ** specified by the blocked connections bundled together into an array.
- ** This gives the application an opportunity to prioritize any actions
- ** related to the set of unblocked database connections.
- **
- ** <b>Deadlock Detection</b>
- **
- ** Assuming that after registering for an unlock-notify callback a
- ** database waits for the callback to be issued before taking any further
- ** action (a reasonable assumption), then using this API may cause the
- ** application to deadlock. For example, if connection X is waiting for
- ** connection Y's transaction to be concluded, and similarly connection
- ** Y is waiting on connection X's transaction, then neither connection
- ** will proceed and the system may remain deadlocked indefinitely.
- **
- ** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock
- ** detection. ^If a given call to sqlite3_unlock_notify() would put the
- ** system in a deadlocked state, then SQLITE_LOCKED is returned and no
- ** unlock-notify callback is registered. The system is said to be in
- ** a deadlocked state if connection A has registered for an unlock-notify
- ** callback on the conclusion of connection B's transaction, and connection
- ** B has itself registered for an unlock-notify callback when connection
- ** A's transaction is concluded. ^Indirect deadlock is also detected, so
- ** the system is also considered to be deadlocked if connection B has
- ** registered for an unlock-notify callback on the conclusion of connection
- ** C's transaction, where connection C is waiting on connection A. ^Any
- ** number of levels of indirection are allowed.
- **
- ** <b>The "DROP TABLE" Exception</b>
- **
- ** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost
- ** always appropriate to call sqlite3_unlock_notify(). There is however,
- ** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement,
- ** SQLite checks if there are any currently executing SELECT statements
- ** that belong to the same connection. If there are, SQLITE_LOCKED is
- ** returned. In this case there is no "blocking connection", so invoking
- ** sqlite3_unlock_notify() results in the unlock-notify callback being
- ** invoked immediately. If the application then re-attempts the "DROP TABLE"
- ** or "DROP INDEX" query, an infinite loop might be the result.
- **
- ** One way around this problem is to check the extended error code returned
- ** by an sqlite3_step() call. ^(If there is a blocking connection, then the
- ** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in
- ** the special "DROP TABLE/INDEX" case, the extended error code is just
- ** SQLITE_LOCKED.)^
- */
- SQLITE_API int sqlite3_unlock_notify(
- sqlite3 *pBlocked, /* Waiting connection */
- void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */
- void *pNotifyArg /* Argument to pass to xNotify */
- );
- /*
- ** CAPI3REF: String Comparison
- **
- ** ^The [sqlite3_strnicmp()] API allows applications and extensions to
- ** compare the contents of two buffers containing UTF-8 strings in a
- ** case-independent fashion, using the same definition of case independence
- ** that SQLite uses internally when comparing identifiers.
- */
- SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
- /*
- ** CAPI3REF: Error Logging Interface
- **
- ** ^The [sqlite3_log()] interface writes a message into the error log
- ** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].
- ** ^If logging is enabled, the zFormat string and subsequent arguments are
- ** used with [sqlite3_snprintf()] to generate the final output string.
- **
- ** The sqlite3_log() interface is intended for use by extensions such as
- ** virtual tables, collating functions, and SQL functions. While there is
- ** nothing to prevent an application from calling sqlite3_log(), doing so
- ** is considered bad form.
- **
- ** The zFormat string must not be NULL.
- **
- ** To avoid deadlocks and other threading problems, the sqlite3_log() routine
- ** will not use dynamically allocated memory. The log message is stored in
- ** a fixed-length buffer on the stack. If the log message is longer than
- ** a few hundred characters, it will be truncated to the length of the
- ** buffer.
- */
- SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
- /*
- ** CAPI3REF: Write-Ahead Log Commit Hook
- **
- ** ^The [sqlite3_wal_hook()] function is used to register a callback that
- ** will be invoked each time a database connection commits data to a
- ** [write-ahead log] (i.e. whenever a transaction is committed in
- ** [journal_mode | journal_mode=WAL mode]).
- **
- ** ^The callback is invoked by SQLite after the commit has taken place and
- ** the associated write-lock on the database released, so the implementation
- ** may read, write or [checkpoint] the database as required.
- **
- ** ^The first parameter passed to the callback function when it is invoked
- ** is a copy of the third parameter passed to sqlite3_wal_hook() when
- ** registering the callback. ^The second is a copy of the database handle.
- ** ^The third parameter is the name of the database that was written to -
- ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
- ** is the number of pages currently in the write-ahead log file,
- ** including those that were just committed.
- **
- ** The callback function should normally return [SQLITE_OK]. ^If an error
- ** code is returned, that error will propagate back up through the
- ** SQLite code base to cause the statement that provoked the callback
- ** to report an error, though the commit will have still occurred. If the
- ** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value
- ** that does not correspond to any valid SQLite error code, the results
- ** are undefined.
- **
- ** A single database handle may have at most a single write-ahead log callback
- ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
- ** previously registered write-ahead log callback. ^Note that the
- ** [sqlite3_wal_autocheckpoint()] interface and the
- ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
- ** those overwrite any prior [sqlite3_wal_hook()] settings.
- */
- SQLITE_API void *sqlite3_wal_hook(
- sqlite3*,
- int(*)(void *,sqlite3*,const char*,int),
- void*
- );
- /*
- ** CAPI3REF: Configure an auto-checkpoint
- **
- ** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around
- ** [sqlite3_wal_hook()] that causes any database on [database connection] D
- ** to automatically [checkpoint]
- ** after committing a transaction if there are N or
- ** more frames in the [write-ahead log] file. ^Passing zero or
- ** a negative value as the nFrame parameter disables automatic
- ** checkpoints entirely.
- **
- ** ^The callback registered by this function replaces any existing callback
- ** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback
- ** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism
- ** configured by this function.
- **
- ** ^The [wal_autocheckpoint pragma] can be used to invoke this interface
- ** from SQL.
- **
- ** ^Every new [database connection] defaults to having the auto-checkpoint
- ** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT]
- ** pages. The use of this interface
- ** is only necessary if the default setting is found to be suboptimal
- ** for a particular application.
- */
- SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
- /*
- ** CAPI3REF: Checkpoint a database
- **
- ** ^The [sqlite3_wal_checkpoint(D,X)] interface causes database named X
- ** on [database connection] D to be [checkpointed]. ^If X is NULL or an
- ** empty string, then a checkpoint is run on all databases of
- ** connection D. ^If the database connection D is not in
- ** [WAL | write-ahead log mode] then this interface is a harmless no-op.
- **
- ** ^The [wal_checkpoint pragma] can be used to invoke this interface
- ** from SQL. ^The [sqlite3_wal_autocheckpoint()] interface and the
- ** [wal_autocheckpoint pragma] can be used to cause this interface to be
- ** run whenever the WAL reaches a certain size threshold.
- **
- ** See also: [sqlite3_wal_checkpoint_v2()]
- */
- SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
- /*
- ** CAPI3REF: Checkpoint a database
- **
- ** Run a checkpoint operation on WAL database zDb attached to database
- ** handle db. The specific operation is determined by the value of the
- ** eMode parameter:
- **
- ** <dl>
- ** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
- ** Checkpoint as many frames as possible without waiting for any database
- ** readers or writers to finish. Sync the db file if all frames in the log
- ** are checkpointed. This mode is the same as calling
- ** sqlite3_wal_checkpoint(). The busy-handler callback is never invoked.
- **
- ** <dt>SQLITE_CHECKPOINT_FULL<dd>
- ** This mode blocks (calls the busy-handler callback) until there is no
- ** database writer and all readers are reading from the most recent database
- ** snapshot. It then checkpoints all frames in the log file and syncs the
- ** database file. This call blocks database writers while it is running,
- ** but not database readers.
- **
- ** <dt>SQLITE_CHECKPOINT_RESTART<dd>
- ** This mode works the same way as SQLITE_CHECKPOINT_FULL, except after
- ** checkpointing the log file it blocks (calls the busy-handler callback)
- ** until all readers are reading from the database file only. This ensures
- ** that the next client to write to the database file restarts the log file
- ** from the beginning. This call blocks database writers while it is running,
- ** but not database readers.
- ** </dl>
- **
- ** If pnLog is not NULL, then *pnLog is set to the total number of frames in
- ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
- ** the total number of checkpointed frames (including any that were already
- ** checkpointed when this function is called). *pnLog and *pnCkpt may be
- ** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK.
- ** If no values are available because of an error, they are both set to -1
- ** before returning to communicate this to the caller.
- **
- ** All calls obtain an exclusive "checkpoint" lock on the database file. If
- ** any other process is running a checkpoint operation at the same time, the
- ** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a
- ** busy-handler configured, it will not be invoked in this case.
- **
- ** The SQLITE_CHECKPOINT_FULL and RESTART modes also obtain the exclusive
- ** "writer" lock on the database file. If the writer lock cannot be obtained
- ** immediately, and a busy-handler is configured, it is invoked and the writer
- ** lock retried until either the busy-handler returns 0 or the lock is
- ** successfully obtained. The busy-handler is also invoked while waiting for
- ** database readers as described above. If the busy-handler returns 0 before
- ** the writer lock is obtained or while waiting for database readers, the
- ** checkpoint operation proceeds from that point in the same way as
- ** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
- ** without blocking any further. SQLITE_BUSY is returned in this case.
- **
- ** If parameter zDb is NULL or points to a zero length string, then the
- ** specified operation is attempted on all WAL databases. In this case the
- ** values written to output parameters *pnLog and *pnCkpt are undefined. If
- ** an SQLITE_BUSY error is encountered when processing one or more of the
- ** attached WAL databases, the operation is still attempted on any remaining
- ** attached databases and SQLITE_BUSY is returned to the caller. If any other
- ** error occurs while processing an attached database, processing is abandoned
- ** and the error code returned to the caller immediately. If no error
- ** (SQLITE_BUSY or otherwise) is encountered while processing the attached
- ** databases, SQLITE_OK is returned.
- **
- ** If database zDb is the name of an attached database that is not in WAL
- ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
- ** zDb is not NULL (or a zero length string) and is not the name of any
- ** attached database, SQLITE_ERROR is returned to the caller.
- */
- SQLITE_API int sqlite3_wal_checkpoint_v2(
- sqlite3 *db, /* Database handle */
- const char *zDb, /* Name of attached database (or NULL) */
- int eMode, /* SQLITE_CHECKPOINT_* value */
- int *pnLog, /* OUT: Size of WAL log in frames */
- int *pnCkpt /* OUT: Total number of frames checkpointed */
- );
- /*
- ** CAPI3REF: Checkpoint operation parameters
- **
- ** These constants can be used as the 3rd parameter to
- ** [sqlite3_wal_checkpoint_v2()]. See the [sqlite3_wal_checkpoint_v2()]
- ** documentation for additional information about the meaning and use of
- ** each of these values.
- */
- #define SQLITE_CHECKPOINT_PASSIVE 0
- #define SQLITE_CHECKPOINT_FULL 1
- #define SQLITE_CHECKPOINT_RESTART 2
- /*
- ** CAPI3REF: Virtual Table Interface Configuration
- **
- ** This function may be called by either the [xConnect] or [xCreate] method
- ** of a [virtual table] implementation to configure
- ** various facets of the virtual table interface.
- **
- ** If this interface is invoked outside the context of an xConnect or
- ** xCreate virtual table method then the behavior is undefined.
- **
- ** At present, there is only one option that may be configured using
- ** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].) Further options
- ** may be added in the future.
- */
- SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
- /*
- ** CAPI3REF: Virtual Table Configuration Options
- **
- ** These macros define the various options to the
- ** [sqlite3_vtab_config()] interface that [virtual table] implementations
- ** can use to customize and optimize their behavior.
- **
- ** <dl>
- ** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT
- ** <dd>Calls of the form
- ** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,
- ** where X is an integer. If X is zero, then the [virtual table] whose
- ** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not
- ** support constraints. In this configuration (which is the default) if
- ** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire
- ** statement is rolled back as if [ON CONFLICT | OR ABORT] had been
- ** specified as part of the users SQL statement, regardless of the actual
- ** ON CONFLICT mode specified.
- **
- ** If X is non-zero, then the virtual table implementation guarantees
- ** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before
- ** any modifications to internal or persistent data structures have been made.
- ** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite
- ** is able to roll back a statement or database transaction, and abandon
- ** or continue processing the current SQL statement as appropriate.
- ** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
- ** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
- ** had been ABORT.
- **
- ** Virtual table implementations that are required to handle OR REPLACE
- ** must do so within the [xUpdate] method. If a call to the
- ** [sqlite3_vtab_on_conflict()] function indicates that the current ON
- ** CONFLICT policy is REPLACE, the virtual table implementation should
- ** silently replace the appropriate rows within the xUpdate callback and
- ** return SQLITE_OK. Or, if this is not possible, it may return
- ** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT
- ** constraint handling.
- ** </dl>
- */
- #define SQLITE_VTAB_CONSTRAINT_SUPPORT 1
- /*
- ** CAPI3REF: Determine The Virtual Table Conflict Policy
- **
- ** This function may only be called from within a call to the [xUpdate] method
- ** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The
- ** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL],
- ** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode
- ** of the SQL statement that triggered the call to the [xUpdate] method of the
- ** [virtual table].
- */
- SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
- /*
- ** CAPI3REF: Conflict resolution modes
- **
- ** These constants are returned by [sqlite3_vtab_on_conflict()] to
- ** inform a [virtual table] implementation what the [ON CONFLICT] mode
- ** is for the SQL statement being evaluated.
- **
- ** Note that the [SQLITE_IGNORE] constant is also used as a potential
- ** return value from the [sqlite3_set_authorizer()] callback and that
- ** [SQLITE_ABORT] is also a [result code].
- */
- #define SQLITE_ROLLBACK 1
- /* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */
- #define SQLITE_FAIL 3
- /* #define SQLITE_ABORT 4 // Also an error code */
- #define SQLITE_REPLACE 5
- /*
- ** Undo the hack that converts floating point types to integer for
- ** builds on processors without floating point support.
- */
- #ifdef SQLITE_OMIT_FLOATING_POINT
- # undef double
- #endif
- #if 0
- } /* End of the 'extern "C"' block */
- #endif
- #endif
- /*
- ** 2010 August 30
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- */
- #ifndef _SQLITE3RTREE_H_
- #define _SQLITE3RTREE_H_
- #if 0
- extern "C" {
- #endif
- typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry;
- /*
- ** Register a geometry callback named zGeom that can be used as part of an
- ** R-Tree geometry query as follows:
- **
- ** SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
- */
- SQLITE_API int sqlite3_rtree_geometry_callback(
- sqlite3 *db,
- const char *zGeom,
- int (*xGeom)(sqlite3_rtree_geometry *, int nCoord, double *aCoord, int *pRes),
- void *pContext
- );
- /*
- ** A pointer to a structure of the following type is passed as the first
- ** argument to callbacks registered using rtree_geometry_callback().
- */
- struct sqlite3_rtree_geometry {
- void *pContext; /* Copy of pContext passed to s_r_g_c() */
- int nParam; /* Size of array aParam[] */
- double *aParam; /* Parameters passed to SQL geom function */
- void *pUser; /* Callback implementation user data */
- void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */
- };
- #if 0
- } /* end of the 'extern "C"' block */
- #endif
- #endif /* ifndef _SQLITE3RTREE_H_ */
- /************** End of sqlite3.h *********************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include hash.h in the middle of sqliteInt.h ******************/
- /************** Begin file hash.h ********************************************/
- /*
- ** 2001 September 22
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This is the header file for the generic hash-table implemenation
- ** used in SQLite.
- */
- #ifndef _SQLITE_HASH_H_
- #define _SQLITE_HASH_H_
- /* Forward declarations of structures. */
- typedef struct Hash Hash;
- typedef struct HashElem HashElem;
- /* A complete hash table is an instance of the following structure.
- ** The internals of this structure are intended to be opaque -- client
- ** code should not attempt to access or modify the fields of this structure
- ** directly. Change this structure only by using the routines below.
- ** However, some of the "procedures" and "functions" for modifying and
- ** accessing this structure are really macros, so we can't really make
- ** this structure opaque.
- **
- ** All elements of the hash table are on a single doubly-linked list.
- ** Hash.first points to the head of this list.
- **
- ** There are Hash.htsize buckets. Each bucket points to a spot in
- ** the global doubly-linked list. The contents of the bucket are the
- ** element pointed to plus the next _ht.count-1 elements in the list.
- **
- ** Hash.htsize and Hash.ht may be zero. In that case lookup is done
- ** by a linear search of the global list. For small tables, the
- ** Hash.ht table is never allocated because if there are few elements
- ** in the table, it is faster to do a linear search than to manage
- ** the hash table.
- */
- struct Hash {
- unsigned int htsize; /* Number of buckets in the hash table */
- unsigned int count; /* Number of entries in this table */
- HashElem *first; /* The first element of the array */
- struct _ht { /* the hash table */
- int count; /* Number of entries with this hash */
- HashElem *chain; /* Pointer to first entry with this hash */
- } *ht;
- };
- /* Each element in the hash table is an instance of the following
- ** structure. All elements are stored on a single doubly-linked list.
- **
- ** Again, this structure is intended to be opaque, but it can't really
- ** be opaque because it is used by macros.
- */
- struct HashElem {
- HashElem *next, *prev; /* Next and previous elements in the table */
- void *data; /* Data associated with this element */
- const char *pKey; int nKey; /* Key associated with this element */
- };
- /*
- ** Access routines. To delete, insert a NULL pointer.
- */
- SQLITE_PRIVATE void sqlite3HashInit(Hash*);
- SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
- SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
- SQLITE_PRIVATE void sqlite3HashClear(Hash*);
- /*
- ** Macros for looping over all elements of a hash table. The idiom is
- ** like this:
- **
- ** Hash h;
- ** HashElem *p;
- ** ...
- ** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){
- ** SomeStructure *pData = sqliteHashData(p);
- ** // do something with pData
- ** }
- */
- #define sqliteHashFirst(H) ((H)->first)
- #define sqliteHashNext(E) ((E)->next)
- #define sqliteHashData(E) ((E)->data)
- /* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */
- /* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */
- /*
- ** Number of entries in a hash table
- */
- /* #define sqliteHashCount(H) ((H)->count) // NOT USED */
- #endif /* _SQLITE_HASH_H_ */
- /************** End of hash.h ************************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include parse.h in the middle of sqliteInt.h *****************/
- /************** Begin file parse.h *******************************************/
- #define TK_SEMI 1
- #define TK_EXPLAIN 2
- #define TK_QUERY 3
- #define TK_PLAN 4
- #define TK_BEGIN 5
- #define TK_TRANSACTION 6
- #define TK_DEFERRED 7
- #define TK_IMMEDIATE 8
- #define TK_EXCLUSIVE 9
- #define TK_COMMIT 10
- #define TK_END 11
- #define TK_ROLLBACK 12
- #define TK_SAVEPOINT 13
- #define TK_RELEASE 14
- #define TK_TO 15
- #define TK_TABLE 16
- #define TK_CREATE 17
- #define TK_IF 18
- #define TK_NOT 19
- #define TK_EXISTS 20
- #define TK_TEMP 21
- #define TK_LP 22
- #define TK_RP 23
- #define TK_AS 24
- #define TK_COMMA 25
- #define TK_ID 26
- #define TK_INDEXED 27
- #define TK_ABORT 28
- #define TK_ACTION 29
- #define TK_AFTER 30
- #define TK_ANALYZE 31
- #define TK_ASC 32
- #define TK_ATTACH 33
- #define TK_BEFORE 34
- #define TK_BY 35
- #define TK_CASCADE 36
- #define TK_CAST 37
- #define TK_COLUMNKW 38
- #define TK_CONFLICT 39
- #define TK_DATABASE 40
- #define TK_DESC 41
- #define TK_DETACH 42
- #define TK_EACH 43
- #define TK_FAIL 44
- #define TK_FOR 45
- #define TK_IGNORE 46
- #define TK_INITIALLY 47
- #define TK_INSTEAD 48
- #define TK_LIKE_KW 49
- #define TK_MATCH 50
- #define TK_NO 51
- #define TK_KEY 52
- #define TK_OF 53
- #define TK_OFFSET 54
- #define TK_PRAGMA 55
- #define TK_RAISE 56
- #define TK_REPLACE 57
- #define TK_RESTRICT 58
- #define TK_ROW 59
- #define TK_TRIGGER 60
- #define TK_VACUUM 61
- #define TK_VIEW 62
- #define TK_VIRTUAL 63
- #define TK_REINDEX 64
- #define TK_RENAME 65
- #define TK_CTIME_KW 66
- #define TK_ANY 67
- #define TK_OR 68
- #define TK_AND 69
- #define TK_IS 70
- #define TK_BETWEEN 71
- #define TK_IN 72
- #define TK_ISNULL 73
- #define TK_NOTNULL 74
- #define TK_NE 75
- #define TK_EQ 76
- #define TK_GT 77
- #define TK_LE 78
- #define TK_LT 79
- #define TK_GE 80
- #define TK_ESCAPE 81
- #define TK_BITAND 82
- #define TK_BITOR 83
- #define TK_LSHIFT 84
- #define TK_RSHIFT 85
- #define TK_PLUS 86
- #define TK_MINUS 87
- #define TK_STAR 88
- #define TK_SLASH 89
- #define TK_REM 90
- #define TK_CONCAT 91
- #define TK_COLLATE 92
- #define TK_BITNOT 93
- #define TK_STRING 94
- #define TK_JOIN_KW 95
- #define TK_CONSTRAINT 96
- #define TK_DEFAULT 97
- #define TK_NULL 98
- #define TK_PRIMARY 99
- #define TK_UNIQUE 100
- #define TK_CHECK 101
- #define TK_REFERENCES 102
- #define TK_AUTOINCR 103
- #define TK_ON 104
- #define TK_INSERT 105
- #define TK_DELETE 106
- #define TK_UPDATE 107
- #define TK_SET 108
- #define TK_DEFERRABLE 109
- #define TK_FOREIGN 110
- #define TK_DROP 111
- #define TK_UNION 112
- #define TK_ALL 113
- #define TK_EXCEPT 114
- #define TK_INTERSECT 115
- #define TK_SELECT 116
- #define TK_DISTINCT 117
- #define TK_DOT 118
- #define TK_FROM 119
- #define TK_JOIN 120
- #define TK_USING 121
- #define TK_ORDER 122
- #define TK_GROUP 123
- #define TK_HAVING 124
- #define TK_LIMIT 125
- #define TK_WHERE 126
- #define TK_INTO 127
- #define TK_VALUES 128
- #define TK_INTEGER 129
- #define TK_FLOAT 130
- #define TK_BLOB 131
- #define TK_REGISTER 132
- #define TK_VARIABLE 133
- #define TK_CASE 134
- #define TK_WHEN 135
- #define TK_THEN 136
- #define TK_ELSE 137
- #define TK_INDEX 138
- #define TK_ALTER 139
- #define TK_ADD 140
- #define TK_TO_TEXT 141
- #define TK_TO_BLOB 142
- #define TK_TO_NUMERIC 143
- #define TK_TO_INT 144
- #define TK_TO_REAL 145
- #define TK_ISNOT 146
- #define TK_END_OF_FILE 147
- #define TK_ILLEGAL 148
- #define TK_SPACE 149
- #define TK_UNCLOSED_STRING 150
- #define TK_FUNCTION 151
- #define TK_COLUMN 152
- #define TK_AGG_FUNCTION 153
- #define TK_AGG_COLUMN 154
- #define TK_CONST_FUNC 155
- #define TK_UMINUS 156
- #define TK_UPLUS 157
- /************** End of parse.h ***********************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <assert.h>
- #include <stddef.h>
- /*
- ** If compiling for a processor that lacks floating point support,
- ** substitute integer for floating-point
- */
- #ifdef SQLITE_OMIT_FLOATING_POINT
- # define double sqlite_int64
- # define float sqlite_int64
- # define LONGDOUBLE_TYPE sqlite_int64
- # ifndef SQLITE_BIG_DBL
- # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
- # endif
- # define SQLITE_OMIT_DATETIME_FUNCS 1
- # define SQLITE_OMIT_TRACE 1
- # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
- # undef SQLITE_HAVE_ISNAN
- #endif
- #ifndef SQLITE_BIG_DBL
- # define SQLITE_BIG_DBL (1e99)
- #endif
- /*
- ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
- ** afterward. Having this macro allows us to cause the C compiler
- ** to omit code used by TEMP tables without messy #ifndef statements.
- */
- #ifdef SQLITE_OMIT_TEMPDB
- #define OMIT_TEMPDB 1
- #else
- #define OMIT_TEMPDB 0
- #endif
- /*
- ** The "file format" number is an integer that is incremented whenever
- ** the VDBE-level file format changes. The following macros define the
- ** the default file format for new databases and the maximum file format
- ** that the library can read.
- */
- #define SQLITE_MAX_FILE_FORMAT 4
- #ifndef SQLITE_DEFAULT_FILE_FORMAT
- # define SQLITE_DEFAULT_FILE_FORMAT 4
- #endif
- /*
- ** Determine whether triggers are recursive by default. This can be
- ** changed at run-time using a pragma.
- */
- #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
- # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
- #endif
- /*
- ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
- ** on the command-line
- */
- #ifndef SQLITE_TEMP_STORE
- # define SQLITE_TEMP_STORE 1
- #endif
- /*
- ** GCC does not define the offsetof() macro so we'll have to do it
- ** ourselves.
- */
- #ifndef offsetof
- #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
- #endif
- /*
- ** Check to see if this machine uses EBCDIC. (Yes, believe it or
- ** not, there are still machines out there that use EBCDIC.)
- */
- #if 'A' == '\301'
- # define SQLITE_EBCDIC 1
- #else
- # define SQLITE_ASCII 1
- #endif
- /*
- ** Integers of known sizes. These typedefs might change for architectures
- ** where the sizes very. Preprocessor macros are available so that the
- ** types can be conveniently redefined at compile-type. Like this:
- **
- ** cc '-DUINTPTR_TYPE=long long int' ...
- */
- #ifndef UINT32_TYPE
- # ifdef HAVE_UINT32_T
- # define UINT32_TYPE uint32_t
- # else
- # define UINT32_TYPE unsigned int
- # endif
- #endif
- #ifndef UINT16_TYPE
- # ifdef HAVE_UINT16_T
- # define UINT16_TYPE uint16_t
- # else
- # define UINT16_TYPE unsigned short int
- # endif
- #endif
- #ifndef INT16_TYPE
- # ifdef HAVE_INT16_T
- # define INT16_TYPE int16_t
- # else
- # define INT16_TYPE short int
- # endif
- #endif
- #ifndef UINT8_TYPE
- # ifdef HAVE_UINT8_T
- # define UINT8_TYPE uint8_t
- # else
- # define UINT8_TYPE unsigned char
- # endif
- #endif
- #ifndef INT8_TYPE
- # ifdef HAVE_INT8_T
- # define INT8_TYPE int8_t
- # else
- # define INT8_TYPE signed char
- # endif
- #endif
- #ifndef LONGDOUBLE_TYPE
- # define LONGDOUBLE_TYPE long double
- #endif
- typedef sqlite_int64 i64; /* 8-byte signed integer */
- typedef sqlite_uint64 u64; /* 8-byte unsigned integer */
- typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
- typedef UINT16_TYPE u16; /* 2-byte unsigned integer */
- typedef INT16_TYPE i16; /* 2-byte signed integer */
- typedef UINT8_TYPE u8; /* 1-byte unsigned integer */
- typedef INT8_TYPE i8; /* 1-byte signed integer */
- /*
- ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
- ** that can be stored in a u32 without loss of data. The value
- ** is 0x00000000ffffffff. But because of quirks of some compilers, we
- ** have to specify the value in the less intuitive manner shown:
- */
- #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
- /*
- ** The datatype used to store estimates of the number of rows in a
- ** table or index. This is an unsigned integer type. For 99.9% of
- ** the world, a 32-bit integer is sufficient. But a 64-bit integer
- ** can be used at compile-time if desired.
- */
- #ifdef SQLITE_64BIT_STATS
- typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */
- #else
- typedef u32 tRowcnt; /* 32-bit is the default */
- #endif
- /*
- ** Macros to determine whether the machine is big or little endian,
- ** evaluated at runtime.
- */
- #ifdef SQLITE_AMALGAMATION
- SQLITE_PRIVATE const int sqlite3one = 1;
- #else
- SQLITE_PRIVATE const int sqlite3one;
- #endif
- #if defined(i386) || defined(__i386__) || defined(_M_IX86)\
- || defined(__x86_64) || defined(__x86_64__)
- # define SQLITE_BIGENDIAN 0
- # define SQLITE_LITTLEENDIAN 1
- # define SQLITE_UTF16NATIVE SQLITE_UTF16LE
- #else
- # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
- # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
- # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
- #endif
- /*
- ** Constants for the largest and smallest possible 64-bit signed integers.
- ** These macros are designed to work correctly on both 32-bit and 64-bit
- ** compilers.
- */
- #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
- #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
- /*
- ** Round up a number to the next larger multiple of 8. This is used
- ** to force 8-byte alignment on 64-bit architectures.
- */
- #define ROUND8(x) (((x)+7)&~7)
- /*
- ** Round down to the nearest multiple of 8
- */
- #define ROUNDDOWN8(x) ((x)&~7)
- /*
- ** Assert that the pointer X is aligned to an 8-byte boundary. This
- ** macro is used only within assert() to verify that the code gets
- ** all alignment restrictions correct.
- **
- ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
- ** underlying malloc() implemention might return us 4-byte aligned
- ** pointers. In that case, only verify 4-byte alignment.
- */
- #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
- # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)
- #else
- # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
- #endif
- /*
- ** An instance of the following structure is used to store the busy-handler
- ** callback for a given sqlite handle.
- **
- ** The sqlite.busyHandler member of the sqlite struct contains the busy
- ** callback for the database handle. Each pager opened via the sqlite
- ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
- ** callback is currently invoked only from within pager.c.
- */
- typedef struct BusyHandler BusyHandler;
- struct BusyHandler {
- int (*xFunc)(void *,int); /* The busy callback */
- void *pArg; /* First arg to busy callback */
- int nBusy; /* Incremented with each busy call */
- };
- /*
- ** Name of the master database table. The master database table
- ** is a special table that holds the names and attributes of all
- ** user tables and indices.
- */
- #define MASTER_NAME "sqlite_master"
- #define TEMP_MASTER_NAME "sqlite_temp_master"
- /*
- ** The root-page of the master database table.
- */
- #define MASTER_ROOT 1
- /*
- ** The name of the schema table.
- */
- #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
- /*
- ** A convenience macro that returns the number of elements in
- ** an array.
- */
- #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
- /*
- ** The following value as a destructor means to use sqlite3DbFree().
- ** This is an internal extension to SQLITE_STATIC and SQLITE_TRANSIENT.
- */
- #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3DbFree)
- /*
- ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
- ** not support Writable Static Data (WSD) such as global and static variables.
- ** All variables must either be on the stack or dynamically allocated from
- ** the heap. When WSD is unsupported, the variable declarations scattered
- ** throughout the SQLite code must become constants instead. The SQLITE_WSD
- ** macro is used for this purpose. And instead of referencing the variable
- ** directly, we use its constant as a key to lookup the run-time allocated
- ** buffer that holds real variable. The constant is also the initializer
- ** for the run-time allocated buffer.
- **
- ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
- ** macros become no-ops and have zero performance impact.
- */
- #ifdef SQLITE_OMIT_WSD
- #define SQLITE_WSD const
- #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
- #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
- SQLITE_API int sqlite3_wsd_init(int N, int J);
- SQLITE_API void *sqlite3_wsd_find(void *K, int L);
- #else
- #define SQLITE_WSD
- #define GLOBAL(t,v) v
- #define sqlite3GlobalConfig sqlite3Config
- #endif
- /*
- ** The following macros are used to suppress compiler warnings and to
- ** make it clear to human readers when a function parameter is deliberately
- ** left unused within the body of a function. This usually happens when
- ** a function is called via a function pointer. For example the
- ** implementation of an SQL aggregate step callback may not use the
- ** parameter indicating the number of arguments passed to the aggregate,
- ** if it knows that this is enforced elsewhere.
- **
- ** When a function parameter is not used at all within the body of a function,
- ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
- ** However, these macros may also be used to suppress warnings related to
- ** parameters that may or may not be used depending on compilation options.
- ** For example those parameters only used in assert() statements. In these
- ** cases the parameters are named as per the usual conventions.
- */
- #define UNUSED_PARAMETER(x) (void)(x)
- #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
- /*
- ** Forward references to structures
- */
- typedef struct AggInfo AggInfo;
- typedef struct AuthContext AuthContext;
- typedef struct AutoincInfo AutoincInfo;
- typedef struct Bitvec Bitvec;
- typedef struct CollSeq CollSeq;
- typedef struct Column Column;
- typedef struct Db Db;
- typedef struct Schema Schema;
- typedef struct Expr Expr;
- typedef struct ExprList ExprList;
- typedef struct ExprSpan ExprSpan;
- typedef struct FKey FKey;
- typedef struct FuncDestructor FuncDestructor;
- typedef struct FuncDef FuncDef;
- typedef struct FuncDefHash FuncDefHash;
- typedef struct IdList IdList;
- typedef struct Index Index;
- typedef struct IndexSample IndexSample;
- typedef struct KeyClass KeyClass;
- typedef struct KeyInfo KeyInfo;
- typedef struct Lookaside Lookaside;
- typedef struct LookasideSlot LookasideSlot;
- typedef struct Module Module;
- typedef struct NameContext NameContext;
- typedef struct Parse Parse;
- typedef struct RowSet RowSet;
- typedef struct Savepoint Savepoint;
- typedef struct Select Select;
- typedef struct SrcList SrcList;
- typedef struct StrAccum StrAccum;
- typedef struct Table Table;
- typedef struct TableLock TableLock;
- typedef struct Token Token;
- typedef struct Trigger Trigger;
- typedef struct TriggerPrg TriggerPrg;
- typedef struct TriggerStep TriggerStep;
- typedef struct UnpackedRecord UnpackedRecord;
- typedef struct VTable VTable;
- typedef struct VtabCtx VtabCtx;
- typedef struct Walker Walker;
- typedef struct WherePlan WherePlan;
- typedef struct WhereInfo WhereInfo;
- typedef struct WhereLevel WhereLevel;
- /*
- ** Defer sourcing vdbe.h and btree.h until after the "u8" and
- ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
- ** pointer types (i.e. FuncDef) defined above.
- */
- /************** Include btree.h in the middle of sqliteInt.h *****************/
- /************** Begin file btree.h *******************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This header file defines the interface that the sqlite B-Tree file
- ** subsystem. See comments in the source code for a detailed description
- ** of what each interface routine does.
- */
- #ifndef _BTREE_H_
- #define _BTREE_H_
- /* TODO: This definition is just included so other modules compile. It
- ** needs to be revisited.
- */
- #define SQLITE_N_BTREE_META 10
- /*
- ** If defined as non-zero, auto-vacuum is enabled by default. Otherwise
- ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
- */
- #ifndef SQLITE_DEFAULT_AUTOVACUUM
- #define SQLITE_DEFAULT_AUTOVACUUM 0
- #endif
- #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */
- #define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */
- #define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */
- /*
- ** Forward declarations of structure
- */
- typedef struct Btree Btree;
- typedef struct BtCursor BtCursor;
- typedef struct BtShared BtShared;
- SQLITE_PRIVATE int sqlite3BtreeOpen(
- sqlite3_vfs *pVfs, /* VFS to use with this b-tree */
- const char *zFilename, /* Name of database file to open */
- sqlite3 *db, /* Associated database connection */
- Btree **ppBtree, /* Return open Btree* here */
- int flags, /* Flags */
- int vfsFlags /* Flags passed through to VFS open */
- );
- /* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the
- ** following values.
- **
- ** NOTE: These values must match the corresponding PAGER_ values in
- ** pager.h.
- */
- #define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */
- #define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */
- #define BTREE_MEMORY 4 /* This is an in-memory DB */
- #define BTREE_SINGLE 8 /* The file contains at most 1 b-tree */
- #define BTREE_UNORDERED 16 /* Use of a hash implementation is OK */
- SQLITE_PRIVATE int sqlite3BtreeClose(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int);
- SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(Btree*,int,int,int);
- SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix);
- SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int);
- SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int);
- SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int);
- SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *);
- SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int);
- SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster);
- SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int);
- SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int);
- SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags);
- SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*);
- SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *));
- SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree);
- SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock);
- SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int);
- SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *);
- SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *);
- SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *);
- SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *);
- /* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR
- ** of the flags shown below.
- **
- ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
- ** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data
- ** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With
- ** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored
- ** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL
- ** indices.)
- */
- #define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */
- #define BTREE_BLOBKEY 2 /* Table has keys only - no data */
- SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*);
- SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*);
- SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int);
- SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
- SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
- /*
- ** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta
- ** should be one of the following values. The integer values are assigned
- ** to constants so that the offset of the corresponding field in an
- ** SQLite database header may be found using the following formula:
- **
- ** offset = 36 + (idx * 4)
- **
- ** For example, the free-page-count field is located at byte offset 36 of
- ** the database file header. The incr-vacuum-flag field is located at
- ** byte offset 64 (== 36+4*7).
- */
- #define BTREE_FREE_PAGE_COUNT 0
- #define BTREE_SCHEMA_VERSION 1
- #define BTREE_FILE_FORMAT 2
- #define BTREE_DEFAULT_CACHE_SIZE 3
- #define BTREE_LARGEST_ROOT_PAGE 4
- #define BTREE_TEXT_ENCODING 5
- #define BTREE_USER_VERSION 6
- #define BTREE_INCR_VACUUM 7
- SQLITE_PRIVATE int sqlite3BtreeCursor(
- Btree*, /* BTree containing table to open */
- int iTable, /* Index of root page */
- int wrFlag, /* 1 for writing. 0 for read-only */
- struct KeyInfo*, /* First argument to compare function */
- BtCursor *pCursor /* Space to write cursor structure */
- );
- SQLITE_PRIVATE int sqlite3BtreeCursorSize(void);
- SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*);
- SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*);
- SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
- BtCursor*,
- UnpackedRecord *pUnKey,
- i64 intKey,
- int bias,
- int *pRes
- );
- SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*, int*);
- SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*);
- SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
- const void *pData, int nData,
- int nZero, int bias, int seekResult);
- SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes);
- SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes);
- SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes);
- SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*);
- SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes);
- SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize);
- SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
- SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt);
- SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt);
- SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
- SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
- SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64);
- SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor*);
- SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*);
- SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);
- SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
- SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *);
- SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *);
- SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion);
- #ifndef NDEBUG
- SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*);
- #endif
- #ifndef SQLITE_OMIT_BTREECOUNT
- SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *, i64 *);
- #endif
- #ifdef SQLITE_TEST
- SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int);
- SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*);
- #endif
- #ifndef SQLITE_OMIT_WAL
- SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
- #endif
- /*
- ** If we are not using shared cache, then there is no need to
- ** use mutexes to access the BtShared structures. So make the
- ** Enter and Leave procedures no-ops.
- */
- #ifndef SQLITE_OMIT_SHARED_CACHE
- SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*);
- SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*);
- #else
- # define sqlite3BtreeEnter(X)
- # define sqlite3BtreeEnterAll(X)
- #endif
- #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE
- SQLITE_PRIVATE int sqlite3BtreeSharable(Btree*);
- SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*);
- SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*);
- SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*);
- SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*);
- #ifndef NDEBUG
- /* These routines are used inside assert() statements only. */
- SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*);
- SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*);
- SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*);
- #endif
- #else
- # define sqlite3BtreeSharable(X) 0
- # define sqlite3BtreeLeave(X)
- # define sqlite3BtreeEnterCursor(X)
- # define sqlite3BtreeLeaveCursor(X)
- # define sqlite3BtreeLeaveAll(X)
- # define sqlite3BtreeHoldsMutex(X) 1
- # define sqlite3BtreeHoldsAllMutexes(X) 1
- # define sqlite3SchemaMutexHeld(X,Y,Z) 1
- #endif
- #endif /* _BTREE_H_ */
- /************** End of btree.h ***********************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include vdbe.h in the middle of sqliteInt.h ******************/
- /************** Begin file vdbe.h ********************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** Header file for the Virtual DataBase Engine (VDBE)
- **
- ** This header defines the interface to the virtual database engine
- ** or VDBE. The VDBE implements an abstract machine that runs a
- ** simple program to access and modify the underlying database.
- */
- #ifndef _SQLITE_VDBE_H_
- #define _SQLITE_VDBE_H_
- /* #include <stdio.h> */
- /*
- ** A single VDBE is an opaque structure named "Vdbe". Only routines
- ** in the source file sqliteVdbe.c are allowed to see the insides
- ** of this structure.
- */
- typedef struct Vdbe Vdbe;
- /*
- ** The names of the following types declared in vdbeInt.h are required
- ** for the VdbeOp definition.
- */
- typedef struct VdbeFunc VdbeFunc;
- typedef struct Mem Mem;
- typedef struct SubProgram SubProgram;
- /*
- ** A single instruction of the virtual machine has an opcode
- ** and as many as three operands. The instruction is recorded
- ** as an instance of the following structure:
- */
- struct VdbeOp {
- u8 opcode; /* What operation to perform */
- signed char p4type; /* One of the P4_xxx constants for p4 */
- u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */
- u8 p5; /* Fifth parameter is an unsigned character */
- int p1; /* First operand */
- int p2; /* Second parameter (often the jump destination) */
- int p3; /* The third parameter */
- union { /* fourth parameter */
- int i; /* Integer value if p4type==P4_INT32 */
- void *p; /* Generic pointer */
- char *z; /* Pointer to data for string (char array) types */
- i64 *pI64; /* Used when p4type is P4_INT64 */
- double *pReal; /* Used when p4type is P4_REAL */
- FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */
- VdbeFunc *pVdbeFunc; /* Used when p4type is P4_VDBEFUNC */
- CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */
- Mem *pMem; /* Used when p4type is P4_MEM */
- VTable *pVtab; /* Used when p4type is P4_VTAB */
- KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */
- int *ai; /* Used when p4type is P4_INTARRAY */
- SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */
- int (*xAdvance)(BtCursor *, int *);
- } p4;
- #ifdef SQLITE_DEBUG
- char *zComment; /* Comment to improve readability */
- #endif
- #ifdef VDBE_PROFILE
- int cnt; /* Number of times this instruction was executed */
- u64 cycles; /* Total time spent executing this instruction */
- #endif
- };
- typedef struct VdbeOp VdbeOp;
- /*
- ** A sub-routine used to implement a trigger program.
- */
- struct SubProgram {
- VdbeOp *aOp; /* Array of opcodes for sub-program */
- int nOp; /* Elements in aOp[] */
- int nMem; /* Number of memory cells required */
- int nCsr; /* Number of cursors required */
- int nOnce; /* Number of OP_Once instructions */
- void *token; /* id that may be used to recursive triggers */
- SubProgram *pNext; /* Next sub-program already visited */
- };
- /*
- ** A smaller version of VdbeOp used for the VdbeAddOpList() function because
- ** it takes up less space.
- */
- struct VdbeOpList {
- u8 opcode; /* What operation to perform */
- signed char p1; /* First operand */
- signed char p2; /* Second parameter (often the jump destination) */
- signed char p3; /* Third parameter */
- };
- typedef struct VdbeOpList VdbeOpList;
- /*
- ** Allowed values of VdbeOp.p4type
- */
- #define P4_NOTUSED 0 /* The P4 parameter is not used */
- #define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */
- #define P4_STATIC (-2) /* Pointer to a static string */
- #define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */
- #define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */
- #define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */
- #define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */
- #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
- #define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */
- #define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */
- #define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */
- #define P4_REAL (-12) /* P4 is a 64-bit floating point value */
- #define P4_INT64 (-13) /* P4 is a 64-bit signed integer */
- #define P4_INT32 (-14) /* P4 is a 32-bit signed integer */
- #define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */
- #define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */
- #define P4_ADVANCE (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */
- /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
- ** is made. That copy is freed when the Vdbe is finalized. But if the
- ** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used. It still
- ** gets freed when the Vdbe is finalized so it still should be obtained
- ** from a single sqliteMalloc(). But no copy is made and the calling
- ** function should *not* try to free the KeyInfo.
- */
- #define P4_KEYINFO_HANDOFF (-16)
- #define P4_KEYINFO_STATIC (-17)
- /*
- ** The Vdbe.aColName array contains 5n Mem structures, where n is the
- ** number of columns of data returned by the statement.
- */
- #define COLNAME_NAME 0
- #define COLNAME_DECLTYPE 1
- #define COLNAME_DATABASE 2
- #define COLNAME_TABLE 3
- #define COLNAME_COLUMN 4
- #ifdef SQLITE_ENABLE_COLUMN_METADATA
- # define COLNAME_N 5 /* Number of COLNAME_xxx symbols */
- #else
- # ifdef SQLITE_OMIT_DECLTYPE
- # define COLNAME_N 1 /* Store only the name */
- # else
- # define COLNAME_N 2 /* Store the name and decltype */
- # endif
- #endif
- /*
- ** The following macro converts a relative address in the p2 field
- ** of a VdbeOp structure into a negative number so that
- ** sqlite3VdbeAddOpList() knows that the address is relative. Calling
- ** the macro again restores the address.
- */
- #define ADDR(X) (-1-(X))
- /*
- ** The makefile scans the vdbe.c source file and creates the "opcodes.h"
- ** header file that defines a number for each opcode used by the VDBE.
- */
- /************** Include opcodes.h in the middle of vdbe.h ********************/
- /************** Begin file opcodes.h *****************************************/
- /* Automatically generated. Do not edit */
- /* See the mkopcodeh.awk script for details */
- #define OP_Goto 1
- #define OP_Gosub 2
- #define OP_Return 3
- #define OP_Yield 4
- #define OP_HaltIfNull 5
- #define OP_Halt 6
- #define OP_Integer 7
- #define OP_Int64 8
- #define OP_Real 130 /* same as TK_FLOAT */
- #define OP_String8 94 /* same as TK_STRING */
- #define OP_String 9
- #define OP_Null 10
- #define OP_Blob 11
- #define OP_Variable 12
- #define OP_Move 13
- #define OP_Copy 14
- #define OP_SCopy 15
- #define OP_ResultRow 16
- #define OP_Concat 91 /* same as TK_CONCAT */
- #define OP_Add 86 /* same as TK_PLUS */
- #define OP_Subtract 87 /* same as TK_MINUS */
- #define OP_Multiply 88 /* same as TK_STAR */
- #define OP_Divide 89 /* same as TK_SLASH */
- #define OP_Remainder 90 /* same as TK_REM */
- #define OP_CollSeq 17
- #define OP_Function 18
- #define OP_BitAnd 82 /* same as TK_BITAND */
- #define OP_BitOr 83 /* same as TK_BITOR */
- #define OP_ShiftLeft 84 /* same as TK_LSHIFT */
- #define OP_ShiftRight 85 /* same as TK_RSHIFT */
- #define OP_AddImm 20
- #define OP_MustBeInt 21
- #define OP_RealAffinity 22
- #define OP_ToText 141 /* same as TK_TO_TEXT */
- #define OP_ToBlob 142 /* same as TK_TO_BLOB */
- #define OP_ToNumeric 143 /* same as TK_TO_NUMERIC*/
- #define OP_ToInt 144 /* same as TK_TO_INT */
- #define OP_ToReal 145 /* same as TK_TO_REAL */
- #define OP_Eq 76 /* same as TK_EQ */
- #define OP_Ne 75 /* same as TK_NE */
- #define OP_Lt 79 /* same as TK_LT */
- #define OP_Le 78 /* same as TK_LE */
- #define OP_Gt 77 /* same as TK_GT */
- #define OP_Ge 80 /* same as TK_GE */
- #define OP_Permutation 23
- #define OP_Compare 24
- #define OP_Jump 25
- #define OP_And 69 /* same as TK_AND */
- #define OP_Or 68 /* same as TK_OR */
- #define OP_Not 19 /* same as TK_NOT */
- #define OP_BitNot 93 /* same as TK_BITNOT */
- #define OP_Once 26
- #define OP_If 27
- #define OP_IfNot 28
- #define OP_IsNull 73 /* same as TK_ISNULL */
- #define OP_NotNull 74 /* same as TK_NOTNULL */
- #define OP_Column 29
- #define OP_Affinity 30
- #define OP_MakeRecord 31
- #define OP_Count 32
- #define OP_Savepoint 33
- #define OP_AutoCommit 34
- #define OP_Transaction 35
- #define OP_ReadCookie 36
- #define OP_SetCookie 37
- #define OP_VerifyCookie 38
- #define OP_OpenRead 39
- #define OP_OpenWrite 40
- #define OP_OpenAutoindex 41
- #define OP_OpenEphemeral 42
- #define OP_SorterOpen 43
- #define OP_OpenPseudo 44
- #define OP_Close 45
- #define OP_SeekLt 46
- #define OP_SeekLe 47
- #define OP_SeekGe 48
- #define OP_SeekGt 49
- #define OP_Seek 50
- #define OP_NotFound 51
- #define OP_Found 52
- #define OP_IsUnique 53
- #define OP_NotExists 54
- #define OP_Sequence 55
- #define OP_NewRowid 56
- #define OP_Insert 57
- #define OP_InsertInt 58
- #define OP_Delete 59
- #define OP_ResetCount 60
- #define OP_SorterCompare 61
- #define OP_SorterData 62
- #define OP_RowKey 63
- #define OP_RowData 64
- #define OP_Rowid 65
- #define OP_NullRow 66
- #define OP_Last 67
- #define OP_SorterSort 70
- #define OP_Sort 71
- #define OP_Rewind 72
- #define OP_SorterNext 81
- #define OP_Prev 92
- #define OP_Next 95
- #define OP_SorterInsert 96
- #define OP_IdxInsert 97
- #define OP_IdxDelete 98
- #define OP_IdxRowid 99
- #define OP_IdxLT 100
- #define OP_IdxGE 101
- #define OP_Destroy 102
- #define OP_Clear 103
- #define OP_CreateIndex 104
- #define OP_CreateTable 105
- #define OP_ParseSchema 106
- #define OP_LoadAnalysis 107
- #define OP_DropTable 108
- #define OP_DropIndex 109
- #define OP_DropTrigger 110
- #define OP_IntegrityCk 111
- #define OP_RowSetAdd 112
- #define OP_RowSetRead 113
- #define OP_RowSetTest 114
- #define OP_Program 115
- #define OP_Param 116
- #define OP_FkCounter 117
- #define OP_FkIfZero 118
- #define OP_MemMax 119
- #define OP_IfPos 120
- #define OP_IfNeg 121
- #define OP_IfZero 122
- #define OP_AggStep 123
- #define OP_AggFinal 124
- #define OP_Checkpoint 125
- #define OP_JournalMode 126
- #define OP_Vacuum 127
- #define OP_IncrVacuum 128
- #define OP_Expire 129
- #define OP_TableLock 131
- #define OP_VBegin 132
- #define OP_VCreate 133
- #define OP_VDestroy 134
- #define OP_VOpen 135
- #define OP_VFilter 136
- #define OP_VColumn 137
- #define OP_VNext 138
- #define OP_VRename 139
- #define OP_VUpdate 140
- #define OP_Pagecount 146
- #define OP_MaxPgcnt 147
- #define OP_Trace 148
- #define OP_Noop 149
- #define OP_Explain 150
- /* Properties such as "out2" or "jump" that are specified in
- ** comments following the "case" for each opcode in the vdbe.c
- ** are encoded into bitvectors as follows:
- */
- #define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */
- #define OPFLG_OUT2_PRERELEASE 0x0002 /* out2-prerelease: */
- #define OPFLG_IN1 0x0004 /* in1: P1 is an input */
- #define OPFLG_IN2 0x0008 /* in2: P2 is an input */
- #define OPFLG_IN3 0x0010 /* in3: P3 is an input */
- #define OPFLG_OUT2 0x0020 /* out2: P2 is an output */
- #define OPFLG_OUT3 0x0040 /* out3: P3 is an output */
- #define OPFLG_INITIALIZER {\
- /* 0 */ 0x00, 0x01, 0x01, 0x04, 0x04, 0x10, 0x00, 0x02,\
- /* 8 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x24, 0x24,\
- /* 16 */ 0x00, 0x00, 0x00, 0x24, 0x04, 0x05, 0x04, 0x00,\
- /* 24 */ 0x00, 0x01, 0x01, 0x05, 0x05, 0x00, 0x00, 0x00,\
- /* 32 */ 0x02, 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00,\
- /* 40 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,\
- /* 48 */ 0x11, 0x11, 0x08, 0x11, 0x11, 0x11, 0x11, 0x02,\
- /* 56 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
- /* 64 */ 0x00, 0x02, 0x00, 0x01, 0x4c, 0x4c, 0x01, 0x01,\
- /* 72 */ 0x01, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\
- /* 80 */ 0x15, 0x01, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\
- /* 88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x01, 0x24, 0x02, 0x01,\
- /* 96 */ 0x08, 0x08, 0x00, 0x02, 0x01, 0x01, 0x02, 0x00,\
- /* 104 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
- /* 112 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x00, 0x01, 0x08,\
- /* 120 */ 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00,\
- /* 128 */ 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,\
- /* 136 */ 0x01, 0x00, 0x01, 0x00, 0x00, 0x04, 0x04, 0x04,\
- /* 144 */ 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00,}
- /************** End of opcodes.h *********************************************/
- /************** Continuing where we left off in vdbe.h ***********************/
- /*
- ** Prototypes for the VDBE interface. See comments on the implementation
- ** for a description of what each of these routines does.
- */
- SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*);
- SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int);
- SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int);
- SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int);
- SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
- SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
- SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
- SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
- SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
- SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
- SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
- SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
- SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
- SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
- SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr);
- SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
- SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
- SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
- SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeDeleteObject(sqlite3*,Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*);
- SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);
- SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*);
- #ifdef SQLITE_DEBUG
- SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int);
- SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*);
- #endif
- SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*);
- SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int);
- SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
- SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*);
- SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
- SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*);
- SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*);
- SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8);
- SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int);
- #ifndef SQLITE_OMIT_TRACE
- SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*);
- #endif
- SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*);
- SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
- SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *, char *, int, char **);
- #ifndef SQLITE_OMIT_TRIGGER
- SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
- #endif
- #ifndef NDEBUG
- SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...);
- # define VdbeComment(X) sqlite3VdbeComment X
- SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
- # define VdbeNoopComment(X) sqlite3VdbeNoopComment X
- #else
- # define VdbeComment(X)
- # define VdbeNoopComment(X)
- #endif
- #endif
- /************** End of vdbe.h ************************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include pager.h in the middle of sqliteInt.h *****************/
- /************** Begin file pager.h *******************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This header file defines the interface that the sqlite page cache
- ** subsystem. The page cache subsystem reads and writes a file a page
- ** at a time and provides a journal for rollback.
- */
- #ifndef _PAGER_H_
- #define _PAGER_H_
- /*
- ** Default maximum size for persistent journal files. A negative
- ** value means no limit. This value may be overridden using the
- ** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit".
- */
- #ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
- #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1
- #endif
- /*
- ** The type used to represent a page number. The first page in a file
- ** is called page 1. 0 is used to represent "not a page".
- */
- typedef u32 Pgno;
- /*
- ** Each open file is managed by a separate instance of the "Pager" structure.
- */
- typedef struct Pager Pager;
- /*
- ** Handle type for pages.
- */
- typedef struct PgHdr DbPage;
- /*
- ** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
- ** reserved for working around a windows/posix incompatibility). It is
- ** used in the journal to signify that the remainder of the journal file
- ** is devoted to storing a master journal name - there are no more pages to
- ** roll back. See comments for function writeMasterJournal() in pager.c
- ** for details.
- */
- #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
- /*
- ** Allowed values for the flags parameter to sqlite3PagerOpen().
- **
- ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
- */
- #define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */
- #define PAGER_NO_READLOCK 0x0002 /* Omit readlocks on readonly files */
- #define PAGER_MEMORY 0x0004 /* In-memory database */
- /*
- ** Valid values for the second argument to sqlite3PagerLockingMode().
- */
- #define PAGER_LOCKINGMODE_QUERY -1
- #define PAGER_LOCKINGMODE_NORMAL 0
- #define PAGER_LOCKINGMODE_EXCLUSIVE 1
- /*
- ** Numeric constants that encode the journalmode.
- */
- #define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */
- #define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */
- #define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */
- #define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */
- #define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */
- #define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */
- #define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */
- /*
- ** The remainder of this file contains the declarations of the functions
- ** that make up the Pager sub-system API. See source code comments for
- ** a detailed description of each routine.
- */
- /* Open and close a Pager connection. */
- SQLITE_PRIVATE int sqlite3PagerOpen(
- sqlite3_vfs*,
- Pager **ppPager,
- const char*,
- int,
- int,
- int,
- void(*)(DbPage*)
- );
- SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
- SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*);
- /* Functions used to configure a Pager object. */
- SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
- SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int);
- SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int);
- SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int);
- SQLITE_PRIVATE void sqlite3PagerShrink(Pager*);
- SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int,int);
- SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int);
- SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *, int);
- SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager*);
- SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager*);
- SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64);
- SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*);
- /* Functions used to obtain and release page references. */
- SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
- #define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0)
- SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
- SQLITE_PRIVATE void sqlite3PagerRef(DbPage*);
- SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*);
- /* Operations on page references. */
- SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*);
- SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*);
- SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
- SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*);
- SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *);
- SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *);
- /* Functions used to manage pager transactions and savepoints. */
- SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*);
- SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int);
- SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int);
- SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*);
- SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
- SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*);
- SQLITE_PRIVATE int sqlite3PagerRollback(Pager*);
- SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
- SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
- SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
- SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*);
- SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
- SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
- SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
- SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager);
- /* Functions used to query pager state and configuration. */
- SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);
- SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*);
- SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*);
- SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*);
- SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*);
- SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*);
- SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*);
- SQLITE_PRIVATE int sqlite3PagerNosync(Pager*);
- SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*);
- SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*);
- SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *, int, int, int *);
- SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *);
- /* Functions used to truncate the database file. */
- SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
- #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL)
- SQLITE_PRIVATE void *sqlite3PagerCodec(DbPage *);
- #endif
- /* Functions to support testing and debugging. */
- #if !defined(NDEBUG) || defined(SQLITE_TEST)
- SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
- SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*);
- #endif
- #ifdef SQLITE_TEST
- SQLITE_PRIVATE int *sqlite3PagerStats(Pager*);
- SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*);
- void disable_simulated_io_errors(void);
- void enable_simulated_io_errors(void);
- #else
- # define disable_simulated_io_errors()
- # define enable_simulated_io_errors()
- #endif
- #endif /* _PAGER_H_ */
- /************** End of pager.h ***********************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include pcache.h in the middle of sqliteInt.h ****************/
- /************** Begin file pcache.h ******************************************/
- /*
- ** 2008 August 05
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This header file defines the interface that the sqlite page cache
- ** subsystem.
- */
- #ifndef _PCACHE_H_
- typedef struct PgHdr PgHdr;
- typedef struct PCache PCache;
- /*
- ** Every page in the cache is controlled by an instance of the following
- ** structure.
- */
- struct PgHdr {
- sqlite3_pcache_page *pPage; /* Pcache object page handle */
- void *pData; /* Page data */
- void *pExtra; /* Extra content */
- PgHdr *pDirty; /* Transient list of dirty pages */
- Pgno pgno; /* Page number for this page */
- Pager *pPager; /* The pager this page is part of */
- #ifdef SQLITE_CHECK_PAGES
- u32 pageHash; /* Hash of page content */
- #endif
- u16 flags; /* PGHDR flags defined below */
- /**********************************************************************
- ** Elements above are public. All that follows is private to pcache.c
- ** and should not be accessed by other modules.
- */
- i16 nRef; /* Number of users of this page */
- PCache *pCache; /* Cache that owns this page */
- PgHdr *pDirtyNext; /* Next element in list of dirty pages */
- PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */
- };
- /* Bit values for PgHdr.flags */
- #define PGHDR_DIRTY 0x002 /* Page has changed */
- #define PGHDR_NEED_SYNC 0x004 /* Fsync the rollback journal before
- ** writing this page to the database */
- #define PGHDR_NEED_READ 0x008 /* Content is unread */
- #define PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */
- #define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */
- /* Initialize and shutdown the page cache subsystem */
- SQLITE_PRIVATE int sqlite3PcacheInitialize(void);
- SQLITE_PRIVATE void sqlite3PcacheShutdown(void);
- /* Page cache buffer management:
- ** These routines implement SQLITE_CONFIG_PAGECACHE.
- */
- SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n);
- /* Create a new pager cache.
- ** Under memory stress, invoke xStress to try to make pages clean.
- ** Only clean and unpinned pages can be reclaimed.
- */
- SQLITE_PRIVATE void sqlite3PcacheOpen(
- int szPage, /* Size of every page */
- int szExtra, /* Extra space associated with each page */
- int bPurgeable, /* True if pages are on backing store */
- int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
- void *pStress, /* Argument to xStress */
- PCache *pToInit /* Preallocated space for the PCache */
- );
- /* Modify the page-size after the cache has been created. */
- SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int);
- /* Return the size in bytes of a PCache object. Used to preallocate
- ** storage space.
- */
- SQLITE_PRIVATE int sqlite3PcacheSize(void);
- /* One release per successful fetch. Page is pinned until released.
- ** Reference counted.
- */
- SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
- SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*);
- SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */
- SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */
- SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */
- SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */
- /* Change a page number. Used by incr-vacuum. */
- SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
- /* Remove all pages with pgno>x. Reset the cache if x==0 */
- SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
- /* Get a list of all dirty pages in the cache, sorted by page number */
- SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*);
- /* Reset and close the cache object */
- SQLITE_PRIVATE void sqlite3PcacheClose(PCache*);
- /* Clear flags from pages of the page cache */
- SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *);
- /* Discard the contents of the cache */
- SQLITE_PRIVATE void sqlite3PcacheClear(PCache*);
- /* Return the total number of outstanding page references */
- SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*);
- /* Increment the reference count of an existing page */
- SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*);
- SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*);
- /* Return the total number of pages stored in the cache */
- SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*);
- #if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
- /* Iterate through all dirty pages currently stored in the cache. This
- ** interface is only available if SQLITE_CHECK_PAGES is defined when the
- ** library is built.
- */
- SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
- #endif
- /* Set and get the suggested cache-size for the specified pager-cache.
- **
- ** If no global maximum is configured, then the system attempts to limit
- ** the total number of pages cached by purgeable pager-caches to the sum
- ** of the suggested cache-sizes.
- */
- SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int);
- #ifdef SQLITE_TEST
- SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *);
- #endif
- /* Free up as much memory as possible from the page cache */
- SQLITE_PRIVATE void sqlite3PcacheShrink(PCache*);
- #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
- /* Try to return memory used by the pcache module to the main memory heap */
- SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int);
- #endif
- #ifdef SQLITE_TEST
- SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*);
- #endif
- SQLITE_PRIVATE void sqlite3PCacheSetDefault(void);
- #endif /* _PCACHE_H_ */
- /************** End of pcache.h **********************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include os.h in the middle of sqliteInt.h ********************/
- /************** Begin file os.h **********************************************/
- /*
- ** 2001 September 16
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This header file (together with is companion C source-code file
- ** "os.c") attempt to abstract the underlying operating system so that
- ** the SQLite library will work on both POSIX and windows systems.
- **
- ** This header file is #include-ed by sqliteInt.h and thus ends up
- ** being included by every source file.
- */
- #ifndef _SQLITE_OS_H_
- #define _SQLITE_OS_H_
- /*
- ** Figure out if we are dealing with Unix, Windows, or some other
- ** operating system. After the following block of preprocess macros,
- ** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER
- ** will defined to either 1 or 0. One of the four will be 1. The other
- ** three will be 0.
- */
- #if defined(SQLITE_OS_OTHER)
- # if SQLITE_OS_OTHER==1
- # undef SQLITE_OS_UNIX
- # define SQLITE_OS_UNIX 0
- # undef SQLITE_OS_WIN
- # define SQLITE_OS_WIN 0
- # undef SQLITE_OS_OS2
- # define SQLITE_OS_OS2 0
- # else
- # undef SQLITE_OS_OTHER
- # endif
- #endif
- #if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER)
- # define SQLITE_OS_OTHER 0
- # ifndef SQLITE_OS_WIN
- # if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
- # define SQLITE_OS_WIN 1
- # define SQLITE_OS_UNIX 0
- # define SQLITE_OS_OS2 0
- # elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__)
- # define SQLITE_OS_WIN 0
- # define SQLITE_OS_UNIX 0
- # define SQLITE_OS_OS2 1
- # else
- # define SQLITE_OS_WIN 0
- # define SQLITE_OS_UNIX 1
- # define SQLITE_OS_OS2 0
- # endif
- # else
- # define SQLITE_OS_UNIX 0
- # define SQLITE_OS_OS2 0
- # endif
- #else
- # ifndef SQLITE_OS_WIN
- # define SQLITE_OS_WIN 0
- # endif
- #endif
- /*
- ** Define the maximum size of a temporary filename
- */
- #if SQLITE_OS_WIN
- # include <windows.h>
- # define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
- #elif SQLITE_OS_OS2
- # if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY)
- # include <os2safe.h> /* has to be included before os2.h for linking to work */
- # endif
- # define INCL_DOSDATETIME
- # define INCL_DOSFILEMGR
- # define INCL_DOSERRORS
- # define INCL_DOSMISC
- # define INCL_DOSPROCESS
- # define INCL_DOSMODULEMGR
- # define INCL_DOSSEMAPHORES
- # include <os2.h>
- # include <uconv.h>
- # define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP)
- #else
- # define SQLITE_TEMPNAME_SIZE 200
- #endif
- /*
- ** Determine if we are dealing with Windows NT.
- */
- #if defined(_WIN32_WINNT)
- # define SQLITE_OS_WINNT 1
- #else
- # define SQLITE_OS_WINNT 0
- #endif
- /*
- ** Determine if we are dealing with WindowsCE - which has a much
- ** reduced API.
- */
- #if defined(_WIN32_WCE)
- # define SQLITE_OS_WINCE 1
- #else
- # define SQLITE_OS_WINCE 0
- #endif
- /* If the SET_FULLSYNC macro is not defined above, then make it
- ** a no-op
- */
- #ifndef SET_FULLSYNC
- # define SET_FULLSYNC(x,y)
- #endif
- /*
- ** The default size of a disk sector
- */
- #ifndef SQLITE_DEFAULT_SECTOR_SIZE
- # define SQLITE_DEFAULT_SECTOR_SIZE 4096
- #endif
- /*
- ** Temporary files are named starting with this prefix followed by 16 random
- ** alphanumeric characters, and no file extension. They are stored in the
- ** OS's standard temporary file directory, and are deleted prior to exit.
- ** If sqlite is being embedded in another program, you may wish to change the
- ** prefix to reflect your program's name, so that if your program exits
- ** prematurely, old temporary files can be easily identified. This can be done
- ** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line.
- **
- ** 2006-10-31: The default prefix used to be "sqlite_". But then
- ** Mcafee started using SQLite in their anti-virus product and it
- ** started putting files with the "sqlite" name in the c:/temp folder.
- ** This annoyed many windows users. Those users would then do a
- ** Google search for "sqlite", find the telephone numbers of the
- ** developers and call to wake them up at night and complain.
- ** For this reason, the default name prefix is changed to be "sqlite"
- ** spelled backwards. So the temp files are still identified, but
- ** anybody smart enough to figure out the code is also likely smart
- ** enough to know that calling the developer will not help get rid
- ** of the file.
- */
- #ifndef SQLITE_TEMP_FILE_PREFIX
- # define SQLITE_TEMP_FILE_PREFIX "etilqs_"
- #endif
- /*
- ** The following values may be passed as the second argument to
- ** sqlite3OsLock(). The various locks exhibit the following semantics:
- **
- ** SHARED: Any number of processes may hold a SHARED lock simultaneously.
- ** RESERVED: A single process may hold a RESERVED lock on a file at
- ** any time. Other processes may hold and obtain new SHARED locks.
- ** PENDING: A single process may hold a PENDING lock on a file at
- ** any one time. Existing SHARED locks may persist, but no new
- ** SHARED locks may be obtained by other processes.
- ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
- **
- ** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
- ** process that requests an EXCLUSIVE lock may actually obtain a PENDING
- ** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to
- ** sqlite3OsLock().
- */
- #define NO_LOCK 0
- #define SHARED_LOCK 1
- #define RESERVED_LOCK 2
- #define PENDING_LOCK 3
- #define EXCLUSIVE_LOCK 4
- /*
- ** File Locking Notes: (Mostly about windows but also some info for Unix)
- **
- ** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
- ** those functions are not available. So we use only LockFile() and
- ** UnlockFile().
- **
- ** LockFile() prevents not just writing but also reading by other processes.
- ** A SHARED_LOCK is obtained by locking a single randomly-chosen
- ** byte out of a specific range of bytes. The lock byte is obtained at
- ** random so two separate readers can probably access the file at the
- ** same time, unless they are unlucky and choose the same lock byte.
- ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
- ** There can only be one writer. A RESERVED_LOCK is obtained by locking
- ** a single byte of the file that is designated as the reserved lock byte.
- ** A PENDING_LOCK is obtained by locking a designated byte different from
- ** the RESERVED_LOCK byte.
- **
- ** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available,
- ** which means we can use reader/writer locks. When reader/writer locks
- ** are used, the lock is placed on the same range of bytes that is used
- ** for probabilistic locking in Win95/98/ME. Hence, the locking scheme
- ** will support two or more Win95 readers or two or more WinNT readers.
- ** But a single Win95 reader will lock out all WinNT readers and a single
- ** WinNT reader will lock out all other Win95 readers.
- **
- ** The following #defines specify the range of bytes used for locking.
- ** SHARED_SIZE is the number of bytes available in the pool from which
- ** a random byte is selected for a shared lock. The pool of bytes for
- ** shared locks begins at SHARED_FIRST.
- **
- ** The same locking strategy and
- ** byte ranges are used for Unix. This leaves open the possiblity of having
- ** clients on win95, winNT, and unix all talking to the same shared file
- ** and all locking correctly. To do so would require that samba (or whatever
- ** tool is being used for file sharing) implements locks correctly between
- ** windows and unix. I'm guessing that isn't likely to happen, but by
- ** using the same locking range we are at least open to the possibility.
- **
- ** Locking in windows is manditory. For this reason, we cannot store
- ** actual data in the bytes used for locking. The pager never allocates
- ** the pages involved in locking therefore. SHARED_SIZE is selected so
- ** that all locks will fit on a single page even at the minimum page size.
- ** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE
- ** is set high so that we don't have to allocate an unused page except
- ** for very large databases. But one should test the page skipping logic
- ** by setting PENDING_BYTE low and running the entire regression suite.
- **
- ** Changing the value of PENDING_BYTE results in a subtly incompatible
- ** file format. Depending on how it is changed, you might not notice
- ** the incompatibility right away, even running a full regression test.
- ** The default location of PENDING_BYTE is the first byte past the
- ** 1GB boundary.
- **
- */
- #ifdef SQLITE_OMIT_WSD
- # define PENDING_BYTE (0x40000000)
- #else
- # define PENDING_BYTE sqlite3PendingByte
- #endif
- #define RESERVED_BYTE (PENDING_BYTE+1)
- #define SHARED_FIRST (PENDING_BYTE+2)
- #define SHARED_SIZE 510
- /*
- ** Wrapper around OS specific sqlite3_os_init() function.
- */
- SQLITE_PRIVATE int sqlite3OsInit(void);
- /*
- ** Functions for accessing sqlite3_file methods
- */
- SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file*);
- SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset);
- SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset);
- SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size);
- SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int);
- SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize);
- SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int);
- SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int);
- SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut);
- SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*);
- SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file*,int,void*);
- #define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
- SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id);
- SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
- SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **);
- SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int);
- SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id);
- SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int);
- /*
- ** Functions for accessing sqlite3_vfs methods
- */
- SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *);
- SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int);
- SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut);
- SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *);
- #ifndef SQLITE_OMIT_LOAD_EXTENSION
- SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *);
- SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *);
- SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void);
- SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *);
- #endif /* SQLITE_OMIT_LOAD_EXTENSION */
- SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *);
- SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int);
- SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *, sqlite3_int64*);
- /*
- ** Convenience functions for opening and closing files using
- ** sqlite3_malloc() to obtain space for the file-handle structure.
- */
- SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*);
- SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *);
- #endif /* _SQLITE_OS_H_ */
- /************** End of os.h **************************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /************** Include mutex.h in the middle of sqliteInt.h *****************/
- /************** Begin file mutex.h *******************************************/
- /*
- ** 2007 August 28
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains the common header for all mutex implementations.
- ** The sqliteInt.h header #includes this file so that it is available
- ** to all source files. We break it out in an effort to keep the code
- ** better organized.
- **
- ** NOTE: source files should *not* #include this header file directly.
- ** Source files should #include the sqliteInt.h file and let that file
- ** include this one indirectly.
- */
- /*
- ** Figure out what version of the code to use. The choices are
- **
- ** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The
- ** mutexes implemention cannot be overridden
- ** at start-time.
- **
- ** SQLITE_MUTEX_NOOP For single-threaded applications. No
- ** mutual exclusion is provided. But this
- ** implementation can be overridden at
- ** start-time.
- **
- ** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix.
- **
- ** SQLITE_MUTEX_W32 For multi-threaded applications on Win32.
- **
- ** SQLITE_MUTEX_OS2 For multi-threaded applications on OS/2.
- */
- #if !SQLITE_THREADSAFE
- # define SQLITE_MUTEX_OMIT
- #endif
- #if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP)
- # if SQLITE_OS_UNIX
- # define SQLITE_MUTEX_PTHREADS
- # elif SQLITE_OS_WIN
- # define SQLITE_MUTEX_W32
- # elif SQLITE_OS_OS2
- # define SQLITE_MUTEX_OS2
- # else
- # define SQLITE_MUTEX_NOOP
- # endif
- #endif
- #ifdef SQLITE_MUTEX_OMIT
- /*
- ** If this is a no-op implementation, implement everything as macros.
- */
- #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8)
- #define sqlite3_mutex_free(X)
- #define sqlite3_mutex_enter(X)
- #define sqlite3_mutex_try(X) SQLITE_OK
- #define sqlite3_mutex_leave(X)
- #define sqlite3_mutex_held(X) ((void)(X),1)
- #define sqlite3_mutex_notheld(X) ((void)(X),1)
- #define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8)
- #define sqlite3MutexInit() SQLITE_OK
- #define sqlite3MutexEnd()
- #define MUTEX_LOGIC(X)
- #else
- #define MUTEX_LOGIC(X) X
- #endif /* defined(SQLITE_MUTEX_OMIT) */
- /************** End of mutex.h ***********************************************/
- /************** Continuing where we left off in sqliteInt.h ******************/
- /*
- ** Each database file to be accessed by the system is an instance
- ** of the following structure. There are normally two of these structures
- ** in the sqlite.aDb[] array. aDb[0] is the main database file and
- ** aDb[1] is the database file used to hold temporary tables. Additional
- ** databases may be attached.
- */
- struct Db {
- char *zName; /* Name of this database */
- Btree *pBt; /* The B*Tree structure for this database file */
- u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
- u8 safety_level; /* How aggressive at syncing data to disk */
- Schema *pSchema; /* Pointer to database schema (possibly shared) */
- };
- /*
- ** An instance of the following structure stores a database schema.
- **
- ** Most Schema objects are associated with a Btree. The exception is
- ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
- ** In shared cache mode, a single Schema object can be shared by multiple
- ** Btrees that refer to the same underlying BtShared object.
- **
- ** Schema objects are automatically deallocated when the last Btree that
- ** references them is destroyed. The TEMP Schema is manually freed by
- ** sqlite3_close().
- *
- ** A thread must be holding a mutex on the corresponding Btree in order
- ** to access Schema content. This implies that the thread must also be
- ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
- ** For a TEMP Schema, only the connection mutex is required.
- */
- struct Schema {
- int schema_cookie; /* Database schema version number for this file */
- int iGeneration; /* Generation counter. Incremented with each change */
- Hash tblHash; /* All tables indexed by name */
- Hash idxHash; /* All (named) indices indexed by name */
- Hash trigHash; /* All triggers indexed by name */
- Hash fkeyHash; /* All foreign keys by referenced table name */
- Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */
- u8 file_format; /* Schema format version for this file */
- u8 enc; /* Text encoding used by this database */
- u16 flags; /* Flags associated with this schema */
- int cache_size; /* Number of pages to use in the cache */
- };
- /*
- ** These macros can be used to test, set, or clear bits in the
- ** Db.pSchema->flags field.
- */
- #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P))
- #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0)
- #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P)
- #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P)
- /*
- ** Allowed values for the DB.pSchema->flags field.
- **
- ** The DB_SchemaLoaded flag is set after the database schema has been
- ** read into internal hash tables.
- **
- ** DB_UnresetViews means that one or more views have column names that
- ** have been filled out. If the schema changes, these column names might
- ** changes and so the view will need to be reset.
- */
- #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
- #define DB_UnresetViews 0x0002 /* Some views have defined column names */
- #define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
- /*
- ** The number of different kinds of things that can be limited
- ** using the sqlite3_limit() interface.
- */
- #define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1)
- /*
- ** Lookaside malloc is a set of fixed-size buffers that can be used
- ** to satisfy small transient memory allocation requests for objects
- ** associated with a particular database connection. The use of
- ** lookaside malloc provides a significant performance enhancement
- ** (approx 10%) by avoiding numerous malloc/free requests while parsing
- ** SQL statements.
- **
- ** The Lookaside structure holds configuration information about the
- ** lookaside malloc subsystem. Each available memory allocation in
- ** the lookaside subsystem is stored on a linked list of LookasideSlot
- ** objects.
- **
- ** Lookaside allocations are only allowed for objects that are associated
- ** with a particular database connection. Hence, schema information cannot
- ** be stored in lookaside because in shared cache mode the schema information
- ** is shared by multiple database connections. Therefore, while parsing
- ** schema information, the Lookaside.bEnabled flag is cleared so that
- ** lookaside allocations are not used to construct the schema objects.
- */
- struct Lookaside {
- u16 sz; /* Size of each buffer in bytes */
- u8 bEnabled; /* False to disable new lookaside allocations */
- u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */
- int nOut; /* Number of buffers currently checked out */
- int mxOut; /* Highwater mark for nOut */
- int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */
- LookasideSlot *pFree; /* List of available buffers */
- void *pStart; /* First byte of available memory space */
- void *pEnd; /* First byte past end of available space */
- };
- struct LookasideSlot {
- LookasideSlot *pNext; /* Next buffer in the list of free buffers */
- };
- /*
- ** A hash table for function definitions.
- **
- ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
- ** Collisions are on the FuncDef.pHash chain.
- */
- struct FuncDefHash {
- FuncDef *a[23]; /* Hash table for functions */
- };
- /*
- ** Each database connection is an instance of the following structure.
- **
- ** The sqlite.lastRowid records the last insert rowid generated by an
- ** insert statement. Inserts on views do not affect its value. Each
- ** trigger has its own context, so that lastRowid can be updated inside
- ** triggers as usual. The previous value will be restored once the trigger
- ** exits. Upon entering a before or instead of trigger, lastRowid is no
- ** longer (since after version 2.8.12) reset to -1.
- **
- ** The sqlite.nChange does not count changes within triggers and keeps no
- ** context. It is reset at start of sqlite3_exec.
- ** The sqlite.lsChange represents the number of changes made by the last
- ** insert, update, or delete statement. It remains constant throughout the
- ** length of a statement and is then updated by OP_SetCounts. It keeps a
- ** context stack just like lastRowid so that the count of changes
- ** within a trigger is not seen outside the trigger. Changes to views do not
- ** affect the value of lsChange.
- ** The sqlite.csChange keeps track of the number of current changes (since
- ** the last statement) and is used to update sqlite_lsChange.
- **
- ** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16
- ** store the most recent error code and, if applicable, string. The
- ** internal function sqlite3Error() is used to set these variables
- ** consistently.
- */
- struct sqlite3 {
- sqlite3_vfs *pVfs; /* OS Interface */
- int nDb; /* Number of backends currently in use */
- Db *aDb; /* All backends */
- int flags; /* Miscellaneous flags. See below */
- unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */
- int errCode; /* Most recent error code (SQLITE_*) */
- int errMask; /* & result codes with this before returning */
- u8 autoCommit; /* The auto-commit flag. */
- u8 temp_store; /* 1: file 2: memory 0: default */
- u8 mallocFailed; /* True if we have seen a malloc failure */
- u8 dfltLockMode; /* Default locking-mode for attached dbs */
- signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */
- u8 suppressErr; /* Do not issue error messages if true */
- u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
- int nextPagesize; /* Pagesize after VACUUM if >0 */
- int nTable; /* Number of tables in the database */
- CollSeq *pDfltColl; /* The default collating sequence (BINARY) */
- i64 lastRowid; /* ROWID of most recent insert (see above) */
- u32 magic; /* Magic number for detect library misuse */
- int nChange; /* Value returned by sqlite3_changes() */
- int nTotalChange; /* Value returned by sqlite3_total_changes() */
- sqlite3_mutex *mutex; /* Connection mutex */
- int aLimit[SQLITE_N_LIMIT]; /* Limits */
- struct sqlite3InitInfo { /* Information used during initialization */
- int iDb; /* When back is being initialized */
- int newTnum; /* Rootpage of table being initialized */
- u8 busy; /* TRUE if currently initializing */
- u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
- } init;
- int nExtension; /* Number of loaded extensions */
- void **aExtension; /* Array of shared library handles */
- struct Vdbe *pVdbe; /* List of active virtual machines */
- int activeVdbeCnt; /* Number of VDBEs currently executing */
- int writeVdbeCnt; /* Number of active VDBEs that are writing */
- int vdbeExecCnt; /* Number of nested calls to VdbeExec() */
- void (*xTrace)(void*,const char*); /* Trace function */
- void *pTraceArg; /* Argument to the trace function */
- void (*xProfile)(void*,const char*,u64); /* Profiling function */
- void *pProfileArg; /* Argument to profile function */
- void *pCommitArg; /* Argument to xCommitCallback() */
- int (*xCommitCallback)(void*); /* Invoked at every commit. */
- void *pRollbackArg; /* Argument to xRollbackCallback() */
- void (*xRollbackCallback)(void*); /* Invoked at every commit. */
- void *pUpdateArg;
- void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
- #ifndef SQLITE_OMIT_WAL
- int (*xWalCallback)(void *, sqlite3 *, const char *, int);
- void *pWalArg;
- #endif
- void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
- void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
- void *pCollNeededArg;
- sqlite3_value *pErr; /* Most recent error message */
- char *zErrMsg; /* Most recent error message (UTF-8 encoded) */
- char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */
- union {
- volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
- double notUsed1; /* Spacer */
- } u1;
- Lookaside lookaside; /* Lookaside malloc configuration */
- #ifndef SQLITE_OMIT_AUTHORIZATION
- int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
- /* Access authorization function */
- void *pAuthArg; /* 1st argument to the access auth function */
- #endif
- #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
- int (*xProgress)(void *); /* The progress callback */
- void *pProgressArg; /* Argument to the progress callback */
- int nProgressOps; /* Number of opcodes for progress callback */
- #endif
- #ifndef SQLITE_OMIT_VIRTUALTABLE
- Hash aModule; /* populated by sqlite3_create_module() */
- VtabCtx *pVtabCtx; /* Context for active vtab connect/create */
- VTable **aVTrans; /* Virtual tables with open transactions */
- int nVTrans; /* Allocated size of aVTrans */
- VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */
- #endif
- FuncDefHash aFunc; /* Hash table of connection functions */
- Hash aCollSeq; /* All collating sequences */
- BusyHandler busyHandler; /* Busy callback */
- int busyTimeout; /* Busy handler timeout, in msec */
- Db aDbStatic[2]; /* Static space for the 2 default backends */
- Savepoint *pSavepoint; /* List of active savepoints */
- int nSavepoint; /* Number of non-transaction savepoints */
- int nStatement; /* Number of nested statement-transactions */
- u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
- i64 nDeferredCons; /* Net deferred constraints this transaction. */
- int *pnBytesFreed; /* If not NULL, increment this in DbFree() */
- #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
- /* The following variables are all protected by the STATIC_MASTER
- ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
- **
- ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
- ** unlock so that it can proceed.
- **
- ** When X.pBlockingConnection==Y, that means that something that X tried
- ** tried to do recently failed with an SQLITE_LOCKED error due to locks
- ** held by Y.
- */
- sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
- sqlite3 *pUnlockConnection; /* Connection to watch for unlock */
- void *pUnlockArg; /* Argument to xUnlockNotify */
- void (*xUnlockNotify)(void **, int); /* Unlock notify callback */
- sqlite3 *pNextBlocked; /* Next in list of all blocked connections */
- #endif
- };
- /*
- ** A macro to discover the encoding of a database.
- */
- #define ENC(db) ((db)->aDb[0].pSchema->enc)
- /*
- ** Possible values for the sqlite3.flags.
- */
- #define SQLITE_VdbeTrace 0x00000100 /* True to trace VDBE execution */
- #define SQLITE_InternChanges 0x00000200 /* Uncommitted Hash table changes */
- #define SQLITE_FullColNames 0x00000400 /* Show full column names on SELECT */
- #define SQLITE_ShortColNames 0x00000800 /* Show short columns names */
- #define SQLITE_CountRows 0x00001000 /* Count rows changed by INSERT, */
- /* DELETE, or UPDATE and return */
- /* the count using a callback. */
- #define SQLITE_NullCallback 0x00002000 /* Invoke the callback once if the */
- /* result set is empty */
- #define SQLITE_SqlTrace 0x00004000 /* Debug print SQL as it executes */
- #define SQLITE_VdbeListing 0x00008000 /* Debug listings of VDBE programs */
- #define SQLITE_WriteSchema 0x00010000 /* OK to update SQLITE_MASTER */
- #define SQLITE_NoReadlock 0x00020000 /* Readlocks are omitted when
- ** accessing read-only databases */
- #define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */
- #define SQLITE_ReadUncommitted 0x0080000 /* For shared-cache mode */
- #define SQLITE_LegacyFileFmt 0x00100000 /* Create new databases in format 1 */
- #define SQLITE_FullFSync 0x00200000 /* Use full fsync on the backend */
- #define SQLITE_CkptFullFSync 0x00400000 /* Use full fsync for checkpoint */
- #define SQLITE_RecoveryMode 0x00800000 /* Ignore schema errors */
- #define SQLITE_ReverseOrder 0x01000000 /* Reverse unordered SELECTs */
- #define SQLITE_RecTriggers 0x02000000 /* Enable recursive triggers */
- #define SQLITE_ForeignKeys 0x04000000 /* Enforce foreign key constraints */
- #define SQLITE_AutoIndex 0x08000000 /* Enable automatic indexes */
- #define SQLITE_PreferBuiltin 0x10000000 /* Preference to built-in funcs */
- #define SQLITE_LoadExtension 0x20000000 /* Enable load_extension */
- #define SQLITE_EnableTrigger 0x40000000 /* True to enable triggers */
- /*
- ** Bits of the sqlite3.flags field that are used by the
- ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface.
- ** These must be the low-order bits of the flags field.
- */
- #define SQLITE_QueryFlattener 0x01 /* Disable query flattening */
- #define SQLITE_ColumnCache 0x02 /* Disable the column cache */
- #define SQLITE_IndexSort 0x04 /* Disable indexes for sorting */
- #define SQLITE_IndexSearch 0x08 /* Disable indexes for searching */
- #define SQLITE_IndexCover 0x10 /* Disable index covering table */
- #define SQLITE_GroupByOrder 0x20 /* Disable GROUPBY cover of ORDERBY */
- #define SQLITE_FactorOutConst 0x40 /* Disable factoring out constants */
- #define SQLITE_IdxRealAsInt 0x80 /* Store REAL as INT in indices */
- #define SQLITE_DistinctOpt 0x80 /* DISTINCT using indexes */
- #define SQLITE_OptMask 0xff /* Mask of all disablable opts */
- /*
- ** Possible values for the sqlite.magic field.
- ** The numbers are obtained at random and have no special meaning, other
- ** than being distinct from one another.
- */
- #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */
- #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */
- #define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */
- #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */
- #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */
- /*
- ** Each SQL function is defined by an instance of the following
- ** structure. A pointer to this structure is stored in the sqlite.aFunc
- ** hash table. When multiple functions have the same name, the hash table
- ** points to a linked list of these structures.
- */
- struct FuncDef {
- i16 nArg; /* Number of arguments. -1 means unlimited */
- u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */
- u8 flags; /* Some combination of SQLITE_FUNC_* */
- void *pUserData; /* User data parameter */
- FuncDef *pNext; /* Next function with same name */
- void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
- void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
- void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
- char *zName; /* SQL name of the function. */
- FuncDef *pHash; /* Next with a different name but the same hash */
- FuncDestructor *pDestructor; /* Reference counted destructor function */
- };
- /*
- ** This structure encapsulates a user-function destructor callback (as
- ** configured using create_function_v2()) and a reference counter. When
- ** create_function_v2() is called to create a function with a destructor,
- ** a single object of this type is allocated. FuncDestructor.nRef is set to
- ** the number of FuncDef objects created (either 1 or 3, depending on whether
- ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
- ** member of each of the new FuncDef objects is set to point to the allocated
- ** FuncDestructor.
- **
- ** Thereafter, when one of the FuncDef objects is deleted, the reference
- ** count on this object is decremented. When it reaches 0, the destructor
- ** is invoked and the FuncDestructor structure freed.
- */
- struct FuncDestructor {
- int nRef;
- void (*xDestroy)(void *);
- void *pUserData;
- };
- /*
- ** Possible values for FuncDef.flags
- */
- #define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */
- #define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */
- #define SQLITE_FUNC_EPHEM 0x04 /* Ephemeral. Delete with VDBE */
- #define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */
- #define SQLITE_FUNC_PRIVATE 0x10 /* Allowed for internal use only */
- #define SQLITE_FUNC_COUNT 0x20 /* Built-in count(*) aggregate */
- #define SQLITE_FUNC_COALESCE 0x40 /* Built-in coalesce() or ifnull() function */
- /*
- ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
- ** used to create the initializers for the FuncDef structures.
- **
- ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
- ** Used to create a scalar function definition of a function zName
- ** implemented by C function xFunc that accepts nArg arguments. The
- ** value passed as iArg is cast to a (void*) and made available
- ** as the user-data (sqlite3_user_data()) for the function. If
- ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
- **
- ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
- ** Used to create an aggregate function definition implemented by
- ** the C functions xStep and xFinal. The first four parameters
- ** are interpreted in the same way as the first 4 parameters to
- ** FUNCTION().
- **
- ** LIKEFUNC(zName, nArg, pArg, flags)
- ** Used to create a scalar function definition of a function zName
- ** that accepts nArg arguments and is implemented by a call to C
- ** function likeFunc. Argument pArg is cast to a (void *) and made
- ** available as the function user-data (sqlite3_user_data()). The
- ** FuncDef.flags variable is set to the value passed as the flags
- ** parameter.
- */
- #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
- {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \
- SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
- #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
- {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \
- pArg, 0, xFunc, 0, 0, #zName, 0, 0}
- #define LIKEFUNC(zName, nArg, arg, flags) \
- {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
- #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
- {nArg, SQLITE_UTF8, nc*SQLITE_FUNC_NEEDCOLL, \
- SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
- /*
- ** All current savepoints are stored in a linked list starting at
- ** sqlite3.pSavepoint. The first element in the list is the most recently
- ** opened savepoint. Savepoints are added to the list by the vdbe
- ** OP_Savepoint instruction.
- */
- struct Savepoint {
- char *zName; /* Savepoint name (nul-terminated) */
- i64 nDeferredCons; /* Number of deferred fk violations */
- Savepoint *pNext; /* Parent savepoint (if any) */
- };
- /*
- ** The following are used as the second parameter to sqlite3Savepoint(),
- ** and as the P1 argument to the OP_Savepoint instruction.
- */
- #define SAVEPOINT_BEGIN 0
- #define SAVEPOINT_RELEASE 1
- #define SAVEPOINT_ROLLBACK 2
- /*
- ** Each SQLite module (virtual table definition) is defined by an
- ** instance of the following structure, stored in the sqlite3.aModule
- ** hash table.
- */
- struct Module {
- const sqlite3_module *pModule; /* Callback pointers */
- const char *zName; /* Name passed to create_module() */
- void *pAux; /* pAux passed to create_module() */
- void (*xDestroy)(void *); /* Module destructor function */
- };
- /*
- ** information about each column of an SQL table is held in an instance
- ** of this structure.
- */
- struct Column {
- char *zName; /* Name of this column */
- Expr *pDflt; /* Default value of this column */
- char *zDflt; /* Original text of the default value */
- char *zType; /* Data type for this column */
- char *zColl; /* Collating sequence. If NULL, use the default */
- u8 notNull; /* True if there is a NOT NULL constraint */
- u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */
- char affinity; /* One of the SQLITE_AFF_... values */
- #ifndef SQLITE_OMIT_VIRTUALTABLE
- u8 isHidden; /* True if this column is 'hidden' */
- #endif
- };
- /*
- ** A "Collating Sequence" is defined by an instance of the following
- ** structure. Conceptually, a collating sequence consists of a name and
- ** a comparison routine that defines the order of that sequence.
- **
- ** There may two separate implementations of the collation function, one
- ** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that
- ** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine
- ** native byte order. When a collation sequence is invoked, SQLite selects
- ** the version that will require the least expensive encoding
- ** translations, if any.
- **
- ** The CollSeq.pUser member variable is an extra parameter that passed in
- ** as the first argument to the UTF-8 comparison function, xCmp.
- ** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function,
- ** xCmp16.
- **
- ** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the
- ** collating sequence is undefined. Indices built on an undefined
- ** collating sequence may not be read or written.
- */
- struct CollSeq {
- char *zName; /* Name of the collating sequence, UTF-8 encoded */
- u8 enc; /* Text encoding handled by xCmp() */
- void *pUser; /* First argument to xCmp() */
- int (*xCmp)(void*,int, const void*, int, const void*);
- void (*xDel)(void*); /* Destructor for pUser */
- };
- /*
- ** A sort order can be either ASC or DESC.
- */
- #define SQLITE_SO_ASC 0 /* Sort in ascending order */
- #define SQLITE_SO_DESC 1 /* Sort in ascending order */
- /*
- ** Column affinity types.
- **
- ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
- ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
- ** the speed a little by numbering the values consecutively.
- **
- ** But rather than start with 0 or 1, we begin with 'a'. That way,
- ** when multiple affinity types are concatenated into a string and
- ** used as the P4 operand, they will be more readable.
- **
- ** Note also that the numeric types are grouped together so that testing
- ** for a numeric type is a single comparison.
- */
- #define SQLITE_AFF_TEXT 'a'
- #define SQLITE_AFF_NONE 'b'
- #define SQLITE_AFF_NUMERIC 'c'
- #define SQLITE_AFF_INTEGER 'd'
- #define SQLITE_AFF_REAL 'e'
- #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
- /*
- ** The SQLITE_AFF_MASK values masks off the significant bits of an
- ** affinity value.
- */
- #define SQLITE_AFF_MASK 0x67
- /*
- ** Additional bit values that can be ORed with an affinity without
- ** changing the affinity.
- */
- #define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */
- #define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */
- #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
- /*
- ** An object of this type is created for each virtual table present in
- ** the database schema.
- **
- ** If the database schema is shared, then there is one instance of this
- ** structure for each database connection (sqlite3*) that uses the shared
- ** schema. This is because each database connection requires its own unique
- ** instance of the sqlite3_vtab* handle used to access the virtual table
- ** implementation. sqlite3_vtab* handles can not be shared between
- ** database connections, even when the rest of the in-memory database
- ** schema is shared, as the implementation often stores the database
- ** connection handle passed to it via the xConnect() or xCreate() method
- ** during initialization internally. This database connection handle may
- ** then be used by the virtual table implementation to access real tables
- ** within the database. So that they appear as part of the callers
- ** transaction, these accesses need to be made via the same database
- ** connection as that used to execute SQL operations on the virtual table.
- **
- ** All VTable objects that correspond to a single table in a shared
- ** database schema are initially stored in a linked-list pointed to by
- ** the Table.pVTable member variable of the corresponding Table object.
- ** When an sqlite3_prepare() operation is required to access the virtual
- ** table, it searches the list for the VTable that corresponds to the
- ** database connection doing the preparing so as to use the correct
- ** sqlite3_vtab* handle in the compiled query.
- **
- ** When an in-memory Table object is deleted (for example when the
- ** schema is being reloaded for some reason), the VTable objects are not
- ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
- ** immediately. Instead, they are moved from the Table.pVTable list to
- ** another linked list headed by the sqlite3.pDisconnect member of the
- ** corresponding sqlite3 structure. They are then deleted/xDisconnected
- ** next time a statement is prepared using said sqlite3*. This is done
- ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
- ** Refer to comments above function sqlite3VtabUnlockList() for an
- ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
- ** list without holding the corresponding sqlite3.mutex mutex.
- **
- ** The memory for objects of this type is always allocated by
- ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
- ** the first argument.
- */
- struct VTable {
- sqlite3 *db; /* Database connection associated with this table */
- Module *pMod; /* Pointer to module implementation */
- sqlite3_vtab *pVtab; /* Pointer to vtab instance */
- int nRef; /* Number of pointers to this structure */
- u8 bConstraint; /* True if constraints are supported */
- int iSavepoint; /* Depth of the SAVEPOINT stack */
- VTable *pNext; /* Next in linked list (see above) */
- };
- /*
- ** Each SQL table is represented in memory by an instance of the
- ** following structure.
- **
- ** Table.zName is the name of the table. The case of the original
- ** CREATE TABLE statement is stored, but case is not significant for
- ** comparisons.
- **
- ** Table.nCol is the number of columns in this table. Table.aCol is a
- ** pointer to an array of Column structures, one for each column.
- **
- ** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
- ** the column that is that key. Otherwise Table.iPKey is negative. Note
- ** that the datatype of the PRIMARY KEY must be INTEGER for this field to
- ** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of
- ** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid
- ** is generated for each row of the table. TF_HasPrimaryKey is set if
- ** the table has any PRIMARY KEY, INTEGER or otherwise.
- **
- ** Table.tnum is the page number for the root BTree page of the table in the
- ** database file. If Table.iDb is the index of the database table backend
- ** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that
- ** holds temporary tables and indices. If TF_Ephemeral is set
- ** then the table is stored in a file that is automatically deleted
- ** when the VDBE cursor to the table is closed. In this case Table.tnum
- ** refers VDBE cursor number that holds the table open, not to the root
- ** page number. Transient tables are used to hold the results of a
- ** sub-query that appears instead of a real table name in the FROM clause
- ** of a SELECT statement.
- */
- struct Table {
- char *zName; /* Name of the table or view */
- int iPKey; /* If not negative, use aCol[iPKey] as the primary key */
- int nCol; /* Number of columns in this table */
- Column *aCol; /* Information about each column */
- Index *pIndex; /* List of SQL indexes on this table. */
- int tnum; /* Root BTree node for this table (see note above) */
- tRowcnt nRowEst; /* Estimated rows in table - from sqlite_stat1 table */
- Select *pSelect; /* NULL for tables. Points to definition if a view. */
- u16 nRef; /* Number of pointers to this Table */
- u8 tabFlags; /* Mask of TF_* values */
- u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
- FKey *pFKey; /* Linked list of all foreign keys in this table */
- char *zColAff; /* String defining the affinity of each column */
- #ifndef SQLITE_OMIT_CHECK
- Expr *pCheck; /* The AND of all CHECK constraints */
- #endif
- #ifndef SQLITE_OMIT_ALTERTABLE
- int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
- #endif
- #ifndef SQLITE_OMIT_VIRTUALTABLE
- VTable *pVTable; /* List of VTable objects. */
- int nModuleArg; /* Number of arguments to the module */
- char **azModuleArg; /* Text of all module args. [0] is module name */
- #endif
- Trigger *pTrigger; /* List of triggers stored in pSchema */
- Schema *pSchema; /* Schema that contains this table */
- Table *pNextZombie; /* Next on the Parse.pZombieTab list */
- };
- /*
- ** Allowed values for Tabe.tabFlags.
- */
- #define TF_Readonly 0x01 /* Read-only system table */
- #define TF_Ephemeral 0x02 /* An ephemeral table */
- #define TF_HasPrimaryKey 0x04 /* Table has a primary key */
- #define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */
- #define TF_Virtual 0x10 /* Is a virtual table */
- #define TF_NeedMetadata 0x20 /* aCol[].zType and aCol[].pColl missing */
- /*
- ** Test to see whether or not a table is a virtual table. This is
- ** done as a macro so that it will be optimized out when virtual
- ** table support is omitted from the build.
- */
- #ifndef SQLITE_OMIT_VIRTUALTABLE
- # define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)
- # define IsHiddenColumn(X) ((X)->isHidden)
- #else
- # define IsVirtual(X) 0
- # define IsHiddenColumn(X) 0
- #endif
- /*
- ** Each foreign key constraint is an instance of the following structure.
- **
- ** A foreign key is associated with two tables. The "from" table is
- ** the table that contains the REFERENCES clause that creates the foreign
- ** key. The "to" table is the table that is named in the REFERENCES clause.
- ** Consider this example:
- **
- ** CREATE TABLE ex1(
- ** a INTEGER PRIMARY KEY,
- ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
- ** );
- **
- ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
- **
- ** Each REFERENCES clause generates an instance of the following structure
- ** which is attached to the from-table. The to-table need not exist when
- ** the from-table is created. The existence of the to-table is not checked.
- */
- struct FKey {
- Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */
- FKey *pNextFrom; /* Next foreign key in pFrom */
- char *zTo; /* Name of table that the key points to (aka: Parent) */
- FKey *pNextTo; /* Next foreign key on table named zTo */
- FKey *pPrevTo; /* Previous foreign key on table named zTo */
- int nCol; /* Number of columns in this key */
- /* EV: R-30323-21917 */
- u8 isDeferred; /* True if constraint checking is deferred till COMMIT */
- u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */
- Trigger *apTrigger[2]; /* Triggers for aAction[] actions */
- struct sColMap { /* Mapping of columns in pFrom to columns in zTo */
- int iFrom; /* Index of column in pFrom */
- char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */
- } aCol[1]; /* One entry for each of nCol column s */
- };
- /*
- ** SQLite supports many different ways to resolve a constraint
- ** error. ROLLBACK processing means that a constraint violation
- ** causes the operation in process to fail and for the current transaction
- ** to be rolled back. ABORT processing means the operation in process
- ** fails and any prior changes from that one operation are backed out,
- ** but the transaction is not rolled back. FAIL processing means that
- ** the operation in progress stops and returns an error code. But prior
- ** changes due to the same operation are not backed out and no rollback
- ** occurs. IGNORE means that the particular row that caused the constraint
- ** error is not inserted or updated. Processing continues and no error
- ** is returned. REPLACE means that preexisting database rows that caused
- ** a UNIQUE constraint violation are removed so that the new insert or
- ** update can proceed. Processing continues and no error is reported.
- **
- ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
- ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
- ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
- ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
- ** referenced table row is propagated into the row that holds the
- ** foreign key.
- **
- ** The following symbolic values are used to record which type
- ** of action to take.
- */
- #define OE_None 0 /* There is no constraint to check */
- #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
- #define OE_Abort 2 /* Back out changes but do no rollback transaction */
- #define OE_Fail 3 /* Stop the operation but leave all prior changes */
- #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
- #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
- #define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
- #define OE_SetNull 7 /* Set the foreign key value to NULL */
- #define OE_SetDflt 8 /* Set the foreign key value to its default */
- #define OE_Cascade 9 /* Cascade the changes */
- #define OE_Default 99 /* Do whatever the default action is */
- /*
- ** An instance of the following structure is passed as the first
- ** argument to sqlite3VdbeKeyCompare and is used to control the
- ** comparison of the two index keys.
- */
- struct KeyInfo {
- sqlite3 *db; /* The database connection */
- u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
- u16 nField; /* Number of entries in aColl[] */
- u8 *aSortOrder; /* Sort order for each column. May be NULL */
- CollSeq *aColl[1]; /* Collating sequence for each term of the key */
- };
- /*
- ** An instance of the following structure holds information about a
- ** single index record that has already been parsed out into individual
- ** values.
- **
- ** A record is an object that contains one or more fields of data.
- ** Records are used to store the content of a table row and to store
- ** the key of an index. A blob encoding of a record is created by
- ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
- ** OP_Column opcode.
- **
- ** This structure holds a record that has already been disassembled
- ** into its constituent fields.
- */
- struct UnpackedRecord {
- KeyInfo *pKeyInfo; /* Collation and sort-order information */
- u16 nField; /* Number of entries in apMem[] */
- u8 flags; /* Boolean settings. UNPACKED_... below */
- i64 rowid; /* Used by UNPACKED_PREFIX_SEARCH */
- Mem *aMem; /* Values */
- };
- /*
- ** Allowed values of UnpackedRecord.flags
- */
- #define UNPACKED_INCRKEY 0x01 /* Make this key an epsilon larger */
- #define UNPACKED_PREFIX_MATCH 0x02 /* A prefix match is considered OK */
- #define UNPACKED_PREFIX_SEARCH 0x04 /* Ignore final (rowid) field */
- /*
- ** Each SQL index is represented in memory by an
- ** instance of the following structure.
- **
- ** The columns of the table that are to be indexed are described
- ** by the aiColumn[] field of this structure. For example, suppose
- ** we have the following table and index:
- **
- ** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
- ** CREATE INDEX Ex2 ON Ex1(c3,c1);
- **
- ** In the Table structure describing Ex1, nCol==3 because there are
- ** three columns in the table. In the Index structure describing
- ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
- ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
- ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
- ** The second column to be indexed (c1) has an index of 0 in
- ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
- **
- ** The Index.onError field determines whether or not the indexed columns
- ** must be unique and what to do if they are not. When Index.onError=OE_None,
- ** it means this is not a unique index. Otherwise it is a unique index
- ** and the value of Index.onError indicate the which conflict resolution
- ** algorithm to employ whenever an attempt is made to insert a non-unique
- ** element.
- */
- struct Index {
- char *zName; /* Name of this index */
- int nColumn; /* Number of columns in the table used by this index */
- int *aiColumn; /* Which columns are used by this index. 1st is 0 */
- tRowcnt *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */
- Table *pTable; /* The SQL table being indexed */
- int tnum; /* Page containing root of this index in database file */
- u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
- u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */
- u8 bUnordered; /* Use this index for == or IN queries only */
- char *zColAff; /* String defining the affinity of each column */
- Index *pNext; /* The next index associated with the same table */
- Schema *pSchema; /* Schema containing this index */
- u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */
- char **azColl; /* Array of collation sequence names for index */
- #ifdef SQLITE_ENABLE_STAT3
- int nSample; /* Number of elements in aSample[] */
- tRowcnt avgEq; /* Average nEq value for key values not in aSample */
- IndexSample *aSample; /* Samples of the left-most key */
- #endif
- };
- /*
- ** Each sample stored in the sqlite_stat3 table is represented in memory
- ** using a structure of this type. See documentation at the top of the
- ** analyze.c source file for additional information.
- */
- struct IndexSample {
- union {
- char *z; /* Value if eType is SQLITE_TEXT or SQLITE_BLOB */
- double r; /* Value if eType is SQLITE_FLOAT */
- i64 i; /* Value if eType is SQLITE_INTEGER */
- } u;
- u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */
- int nByte; /* Size in byte of text or blob. */
- tRowcnt nEq; /* Est. number of rows where the key equals this sample */
- tRowcnt nLt; /* Est. number of rows where key is less than this sample */
- tRowcnt nDLt; /* Est. number of distinct keys less than this sample */
- };
- /*
- ** Each token coming out of the lexer is an instance of
- ** this structure. Tokens are also used as part of an expression.
- **
- ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
- ** may contain random values. Do not make any assumptions about Token.dyn
- ** and Token.n when Token.z==0.
- */
- struct Token {
- const char *z; /* Text of the token. Not NULL-terminated! */
- unsigned int n; /* Number of characters in this token */
- };
- /*
- ** An instance of this structure contains information needed to generate
- ** code for a SELECT that contains aggregate functions.
- **
- ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
- ** pointer to this structure. The Expr.iColumn field is the index in
- ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
- ** code for that node.
- **
- ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
- ** original Select structure that describes the SELECT statement. These
- ** fields do not need to be freed when deallocating the AggInfo structure.
- */
- struct AggInfo {
- u8 directMode; /* Direct rendering mode means take data directly
- ** from source tables rather than from accumulators */
- u8 useSortingIdx; /* In direct mode, reference the sorting index rather
- ** than the source table */
- int sortingIdx; /* Cursor number of the sorting index */
- int sortingIdxPTab; /* Cursor number of pseudo-table */
- ExprList *pGroupBy; /* The group by clause */
- int nSortingColumn; /* Number of columns in the sorting index */
- struct AggInfo_col { /* For each column used in source tables */
- Table *pTab; /* Source table */
- int iTable; /* Cursor number of the source table */
- int iColumn; /* Column number within the source table */
- int iSorterColumn; /* Column number in the sorting index */
- int iMem; /* Memory location that acts as accumulator */
- Expr *pExpr; /* The original expression */
- } *aCol;
- int nColumn; /* Number of used entries in aCol[] */
- int nColumnAlloc; /* Number of slots allocated for aCol[] */
- int nAccumulator; /* Number of columns that show through to the output.
- ** Additional columns are used only as parameters to
- ** aggregate functions */
- struct AggInfo_func { /* For each aggregate function */
- Expr *pExpr; /* Expression encoding the function */
- FuncDef *pFunc; /* The aggregate function implementation */
- int iMem; /* Memory location that acts as accumulator */
- int iDistinct; /* Ephemeral table used to enforce DISTINCT */
- } *aFunc;
- int nFunc; /* Number of entries in aFunc[] */
- int nFuncAlloc; /* Number of slots allocated for aFunc[] */
- };
- /*
- ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
- ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
- ** than 32767 we have to make it 32-bit. 16-bit is preferred because
- ** it uses less memory in the Expr object, which is a big memory user
- ** in systems with lots of prepared statements. And few applications
- ** need more than about 10 or 20 variables. But some extreme users want
- ** to have prepared statements with over 32767 variables, and for them
- ** the option is available (at compile-time).
- */
- #if SQLITE_MAX_VARIABLE_NUMBER<=32767
- typedef i16 ynVar;
- #else
- typedef int ynVar;
- #endif
- /*
- ** Each node of an expression in the parse tree is an instance
- ** of this structure.
- **
- ** Expr.op is the opcode. The integer parser token codes are reused
- ** as opcodes here. For example, the parser defines TK_GE to be an integer
- ** code representing the ">=" operator. This same integer code is reused
- ** to represent the greater-than-or-equal-to operator in the expression
- ** tree.
- **
- ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
- ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
- ** the expression is a variable (TK_VARIABLE), then Expr.token contains the
- ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
- ** then Expr.token contains the name of the function.
- **
- ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
- ** binary operator. Either or both may be NULL.
- **
- ** Expr.x.pList is a list of arguments if the expression is an SQL function,
- ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
- ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
- ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
- ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
- ** valid.
- **
- ** An expression of the form ID or ID.ID refers to a column in a table.
- ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
- ** the integer cursor number of a VDBE cursor pointing to that table and
- ** Expr.iColumn is the column number for the specific column. If the
- ** expression is used as a result in an aggregate SELECT, then the
- ** value is also stored in the Expr.iAgg column in the aggregate so that
- ** it can be accessed after all aggregates are computed.
- **
- ** If the expression is an unbound variable marker (a question mark
- ** character '?' in the original SQL) then the Expr.iTable holds the index
- ** number for that variable.
- **
- ** If the expression is a subquery then Expr.iColumn holds an integer
- ** register number containing the result of the subquery. If the
- ** subquery gives a constant result, then iTable is -1. If the subquery
- ** gives a different answer at different times during statement processing
- ** then iTable is the address of a subroutine that computes the subquery.
- **
- ** If the Expr is of type OP_Column, and the table it is selecting from
- ** is a disk table or the "old.*" pseudo-table, then pTab points to the
- ** corresponding table definition.
- **
- ** ALLOCATION NOTES:
- **
- ** Expr objects can use a lot of memory space in database schema. To
- ** help reduce memory requirements, sometimes an Expr object will be
- ** truncated. And to reduce the number of memory allocations, sometimes
- ** two or more Expr objects will be stored in a single memory allocation,
- ** together with Expr.zToken strings.
- **
- ** If the EP_Reduced and EP_TokenOnly flags are set when
- ** an Expr object is truncated. When EP_Reduced is set, then all
- ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
- ** are contained within the same memory allocation. Note, however, that
- ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
- ** allocated, regardless of whether or not EP_Reduced is set.
- */
- struct Expr {
- u8 op; /* Operation performed by this node */
- char affinity; /* The affinity of the column or 0 if not a column */
- u16 flags; /* Various flags. EP_* See below */
- union {
- char *zToken; /* Token value. Zero terminated and dequoted */
- int iValue; /* Non-negative integer value if EP_IntValue */
- } u;
- /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
- ** space is allocated for the fields below this point. An attempt to
- ** access them will result in a segfault or malfunction.
- *********************************************************************/
- Expr *pLeft; /* Left subnode */
- Expr *pRight; /* Right subnode */
- union {
- ExprList *pList; /* Function arguments or in "<expr> IN (<expr-list)" */
- Select *pSelect; /* Used for sub-selects and "<expr> IN (<select>)" */
- } x;
- CollSeq *pColl; /* The collation type of the column or 0 */
- /* If the EP_Reduced flag is set in the Expr.flags mask, then no
- ** space is allocated for the fields below this point. An attempt to
- ** access them will result in a segfault or malfunction.
- *********************************************************************/
- int iTable; /* TK_COLUMN: cursor number of table holding column
- ** TK_REGISTER: register number
- ** TK_TRIGGER: 1 -> new, 0 -> old */
- ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid.
- ** TK_VARIABLE: variable number (always >= 1). */
- i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
- i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */
- u8 flags2; /* Second set of flags. EP2_... */
- u8 op2; /* If a TK_REGISTER, the original value of Expr.op */
- AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
- Table *pTab; /* Table for TK_COLUMN expressions. */
- #if SQLITE_MAX_EXPR_DEPTH>0
- int nHeight; /* Height of the tree headed by this node */
- #endif
- };
- /*
- ** The following are the meanings of bits in the Expr.flags field.
- */
- #define EP_FromJoin 0x0001 /* Originated in ON or USING clause of a join */
- #define EP_Agg 0x0002 /* Contains one or more aggregate functions */
- #define EP_Resolved 0x0004 /* IDs have been resolved to COLUMNs */
- #define EP_Error 0x0008 /* Expression contains one or more errors */
- #define EP_Distinct 0x0010 /* Aggregate function with DISTINCT keyword */
- #define EP_VarSelect 0x0020 /* pSelect is correlated, not constant */
- #define EP_DblQuoted 0x0040 /* token.z was originally in "..." */
- #define EP_InfixFunc 0x0080 /* True for an infix function: LIKE, GLOB, etc */
- #define EP_ExpCollate 0x0100 /* Collating sequence specified explicitly */
- #define EP_FixedDest 0x0200 /* Result needed in a specific register */
- #define EP_IntValue 0x0400 /* Integer value contained in u.iValue */
- #define EP_xIsSelect 0x0800 /* x.pSelect is valid (otherwise x.pList is) */
- #define EP_Hint 0x1000 /* Optimizer hint. Not required for correctness */
- #define EP_Reduced 0x2000 /* Expr struct is EXPR_REDUCEDSIZE bytes only */
- #define EP_TokenOnly 0x4000 /* Expr struct is EXPR_TOKENONLYSIZE bytes only */
- #define EP_Static 0x8000 /* Held in memory not obtained from malloc() */
- /*
- ** The following are the meanings of bits in the Expr.flags2 field.
- */
- #define EP2_MallocedToken 0x0001 /* Need to sqlite3DbFree() Expr.zToken */
- #define EP2_Irreducible 0x0002 /* Cannot EXPRDUP_REDUCE this Expr */
- /*
- ** The pseudo-routine sqlite3ExprSetIrreducible sets the EP2_Irreducible
- ** flag on an expression structure. This flag is used for VV&A only. The
- ** routine is implemented as a macro that only works when in debugging mode,
- ** so as not to burden production code.
- */
- #ifdef SQLITE_DEBUG
- # define ExprSetIrreducible(X) (X)->flags2 |= EP2_Irreducible
- #else
- # define ExprSetIrreducible(X)
- #endif
- /*
- ** These macros can be used to test, set, or clear bits in the
- ** Expr.flags field.
- */
- #define ExprHasProperty(E,P) (((E)->flags&(P))==(P))
- #define ExprHasAnyProperty(E,P) (((E)->flags&(P))!=0)
- #define ExprSetProperty(E,P) (E)->flags|=(P)
- #define ExprClearProperty(E,P) (E)->flags&=~(P)
- /*
- ** Macros to determine the number of bytes required by a normal Expr
- ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
- ** and an Expr struct with the EP_TokenOnly flag set.
- */
- #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
- #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
- #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
- /*
- ** Flags passed to the sqlite3ExprDup() function. See the header comment
- ** above sqlite3ExprDup() for details.
- */
- #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
- /*
- ** A list of expressions. Each expression may optionally have a
- ** name. An expr/name combination can be used in several ways, such
- ** as the list of "expr AS ID" fields following a "SELECT" or in the
- ** list of "ID = expr" items in an UPDATE. A list of expressions can
- ** also be used as the argument to a function, in which case the a.zName
- ** field is not used.
- */
- struct ExprList {
- int nExpr; /* Number of expressions on the list */
- int nAlloc; /* Number of entries allocated below */
- int iECursor; /* VDBE Cursor associated with this ExprList */
- struct ExprList_item {
- Expr *pExpr; /* The list of expressions */
- char *zName; /* Token associated with this expression */
- char *zSpan; /* Original text of the expression */
- u8 sortOrder; /* 1 for DESC or 0 for ASC */
- u8 done; /* A flag to indicate when processing is finished */
- u16 iOrderByCol; /* For ORDER BY, column number in result set */
- u16 iAlias; /* Index into Parse.aAlias[] for zName */
- } *a; /* One entry for each expression */
- };
- /*
- ** An instance of this structure is used by the parser to record both
- ** the parse tree for an expression and the span of input text for an
- ** expression.
- */
- struct ExprSpan {
- Expr *pExpr; /* The expression parse tree */
- const char *zStart; /* First character of input text */
- const char *zEnd; /* One character past the end of input text */
- };
- /*
- ** An instance of this structure can hold a simple list of identifiers,
- ** such as the list "a,b,c" in the following statements:
- **
- ** INSERT INTO t(a,b,c) VALUES ...;
- ** CREATE INDEX idx ON t(a,b,c);
- ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
- **
- ** The IdList.a.idx field is used when the IdList represents the list of
- ** column names after a table name in an INSERT statement. In the statement
- **
- ** INSERT INTO t(a,b,c) ...
- **
- ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
- */
- struct IdList {
- struct IdList_item {
- char *zName; /* Name of the identifier */
- int idx; /* Index in some Table.aCol[] of a column named zName */
- } *a;
- int nId; /* Number of identifiers on the list */
- int nAlloc; /* Number of entries allocated for a[] below */
- };
- /*
- ** The bitmask datatype defined below is used for various optimizations.
- **
- ** Changing this from a 64-bit to a 32-bit type limits the number of
- ** tables in a join to 32 instead of 64. But it also reduces the size
- ** of the library by 738 bytes on ix86.
- */
- typedef u64 Bitmask;
- /*
- ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
- */
- #define BMS ((int)(sizeof(Bitmask)*8))
- /*
- ** The following structure describes the FROM clause of a SELECT statement.
- ** Each table or subquery in the FROM clause is a separate element of
- ** the SrcList.a[] array.
- **
- ** With the addition of multiple database support, the following structure
- ** can also be used to describe a particular table such as the table that
- ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
- ** such a table must be a simple name: ID. But in SQLite, the table can
- ** now be identified by a database name, a dot, then the table name: ID.ID.
- **
- ** The jointype starts out showing the join type between the current table
- ** and the next table on the list. The parser builds the list this way.
- ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
- ** jointype expresses the join between the table and the previous table.
- **
- ** In the colUsed field, the high-order bit (bit 63) is set if the table
- ** contains more than 63 columns and the 64-th or later column is used.
- */
- struct SrcList {
- i16 nSrc; /* Number of tables or subqueries in the FROM clause */
- i16 nAlloc; /* Number of entries allocated in a[] below */
- struct SrcList_item {
- char *zDatabase; /* Name of database holding this table */
- char *zName; /* Name of the table */
- char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
- Table *pTab; /* An SQL table corresponding to zName */
- Select *pSelect; /* A SELECT statement used in place of a table name */
- int addrFillSub; /* Address of subroutine to manifest a subquery */
- int regReturn; /* Register holding return address of addrFillSub */
- u8 jointype; /* Type of join between this able and the previous */
- u8 notIndexed; /* True if there is a NOT INDEXED clause */
- u8 isCorrelated; /* True if sub-query is correlated */
- #ifndef SQLITE_OMIT_EXPLAIN
- u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */
- #endif
- int iCursor; /* The VDBE cursor number used to access this table */
- Expr *pOn; /* The ON clause of a join */
- IdList *pUsing; /* The USING clause of a join */
- Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
- char *zIndex; /* Identifier from "INDEXED BY <zIndex>" clause */
- Index *pIndex; /* Index structure corresponding to zIndex, if any */
- } a[1]; /* One entry for each identifier on the list */
- };
- /*
- ** Permitted values of the SrcList.a.jointype field
- */
- #define JT_INNER 0x0001 /* Any kind of inner or cross join */
- #define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
- #define JT_NATURAL 0x0004 /* True for a "natural" join */
- #define JT_LEFT 0x0008 /* Left outer join */
- #define JT_RIGHT 0x0010 /* Right outer join */
- #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
- #define JT_ERROR 0x0040 /* unknown or unsupported join type */
- /*
- ** A WherePlan object holds information that describes a lookup
- ** strategy.
- **
- ** This object is intended to be opaque outside of the where.c module.
- ** It is included here only so that that compiler will know how big it
- ** is. None of the fields in this object should be used outside of
- ** the where.c module.
- **
- ** Within the union, pIdx is only used when wsFlags&WHERE_INDEXED is true.
- ** pTerm is only used when wsFlags&WHERE_MULTI_OR is true. And pVtabIdx
- ** is only used when wsFlags&WHERE_VIRTUALTABLE is true. It is never the
- ** case that more than one of these conditions is true.
- */
- struct WherePlan {
- u32 wsFlags; /* WHERE_* flags that describe the strategy */
- u32 nEq; /* Number of == constraints */
- double nRow; /* Estimated number of rows (for EQP) */
- union {
- Index *pIdx; /* Index when WHERE_INDEXED is true */
- struct WhereTerm *pTerm; /* WHERE clause term for OR-search */
- sqlite3_index_info *pVtabIdx; /* Virtual table index to use */
- } u;
- };
- /*
- ** For each nested loop in a WHERE clause implementation, the WhereInfo
- ** structure contains a single instance of this structure. This structure
- ** is intended to be private the the where.c module and should not be
- ** access or modified by other modules.
- **
- ** The pIdxInfo field is used to help pick the best index on a
- ** virtual table. The pIdxInfo pointer contains indexing
- ** information for the i-th table in the FROM clause before reordering.
- ** All the pIdxInfo pointers are freed by whereInfoFree() in where.c.
- ** All other information in the i-th WhereLevel object for the i-th table
- ** after FROM clause ordering.
- */
- struct WhereLevel {
- WherePlan plan; /* query plan for this element of the FROM clause */
- int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */
- int iTabCur; /* The VDBE cursor used to access the table */
- int iIdxCur; /* The VDBE cursor used to access pIdx */
- int addrBrk; /* Jump here to break out of the loop */
- int addrNxt; /* Jump here to start the next IN combination */
- int addrCont; /* Jump here to continue with the next loop cycle */
- int addrFirst; /* First instruction of interior of the loop */
- u8 iFrom; /* Which entry in the FROM clause */
- u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */
- int p1, p2; /* Operands of the opcode used to ends the loop */
- union { /* Information that depends on plan.wsFlags */
- struct {
- int nIn; /* Number of entries in aInLoop[] */
- struct InLoop {
- int iCur; /* The VDBE cursor used by this IN operator */
- int addrInTop; /* Top of the IN loop */
- } *aInLoop; /* Information about each nested IN operator */
- } in; /* Used when plan.wsFlags&WHERE_IN_ABLE */
- } u;
- /* The following field is really not part of the current level. But
- ** we need a place to cache virtual table index information for each
- ** virtual table in the FROM clause and the WhereLevel structure is
- ** a convenient place since there is one WhereLevel for each FROM clause
- ** element.
- */
- sqlite3_index_info *pIdxInfo; /* Index info for n-th source table */
- };
- /*
- ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
- ** and the WhereInfo.wctrlFlags member.
- */
- #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
- #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
- #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
- #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
- #define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */
- #define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */
- #define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */
- #define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */
- #define WHERE_AND_ONLY 0x0080 /* Don't use indices for OR terms */
- /*
- ** The WHERE clause processing routine has two halves. The
- ** first part does the start of the WHERE loop and the second
- ** half does the tail of the WHERE loop. An instance of
- ** this structure is returned by the first half and passed
- ** into the second half to give some continuity.
- */
- struct WhereInfo {
- Parse *pParse; /* Parsing and code generating context */
- u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */
- u8 okOnePass; /* Ok to use one-pass algorithm for UPDATE or DELETE */
- u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */
- u8 eDistinct;
- SrcList *pTabList; /* List of tables in the join */
- int iTop; /* The very beginning of the WHERE loop */
- int iContinue; /* Jump here to continue with next record */
- int iBreak; /* Jump here to break out of the loop */
- int nLevel; /* Number of nested loop */
- struct WhereClause *pWC; /* Decomposition of the WHERE clause */
- double savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
- double nRowOut; /* Estimated number of output rows */
- WhereLevel a[1]; /* Information about each nest loop in WHERE */
- };
- #define WHERE_DISTINCT_UNIQUE 1
- #define WHERE_DISTINCT_ORDERED 2
- /*
- ** A NameContext defines a context in which to resolve table and column
- ** names. The context consists of a list of tables (the pSrcList) field and
- ** a list of named expression (pEList). The named expression list may
- ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
- ** to the table being operated on by INSERT, UPDATE, or DELETE. The
- ** pEList corresponds to the result set of a SELECT and is NULL for
- ** other statements.
- **
- ** NameContexts can be nested. When resolving names, the inner-most
- ** context is searched first. If no match is found, the next outer
- ** context is checked. If there is still no match, the next context
- ** is checked. This process continues until either a match is found
- ** or all contexts are check. When a match is found, the nRef member of
- ** the context containing the match is incremented.
- **
- ** Each subquery gets a new NameContext. The pNext field points to the
- ** NameContext in the parent query. Thus the process of scanning the
- ** NameContext list corresponds to searching through successively outer
- ** subqueries looking for a match.
- */
- struct NameContext {
- Parse *pParse; /* The parser */
- SrcList *pSrcList; /* One or more tables used to resolve names */
- ExprList *pEList; /* Optional list of named expressions */
- int nRef; /* Number of names resolved by this context */
- int nErr; /* Number of errors encountered while resolving names */
- u8 allowAgg; /* Aggregate functions allowed here */
- u8 hasAgg; /* True if aggregates are seen */
- u8 isCheck; /* True if resolving names in a CHECK constraint */
- int nDepth; /* Depth of subquery recursion. 1 for no recursion */
- AggInfo *pAggInfo; /* Information about aggregates at this level */
- NameContext *pNext; /* Next outer name context. NULL for outermost */
- };
- /*
- ** An instance of the following structure contains all information
- ** needed to generate code for a single SELECT statement.
- **
- ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0.
- ** If there is a LIMIT clause, the parser sets nLimit to the value of the
- ** limit and nOffset to the value of the offset (or 0 if there is not
- ** offset). But later on, nLimit and nOffset become the memory locations
- ** in the VDBE that record the limit and offset counters.
- **
- ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
- ** These addresses must be stored so that we can go back and fill in
- ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
- ** the number of columns in P2 can be computed at the same time
- ** as the OP_OpenEphm instruction is coded because not
- ** enough information about the compound query is known at that point.
- ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
- ** for the result set. The KeyInfo for addrOpenTran[2] contains collating
- ** sequences for the ORDER BY clause.
- */
- struct Select {
- ExprList *pEList; /* The fields of the result */
- u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
- char affinity; /* MakeRecord with this affinity for SRT_Set */
- u16 selFlags; /* Various SF_* values */
- SrcList *pSrc; /* The FROM clause */
- Expr *pWhere; /* The WHERE clause */
- ExprList *pGroupBy; /* The GROUP BY clause */
- Expr *pHaving; /* The HAVING clause */
- ExprList *pOrderBy; /* The ORDER BY clause */
- Select *pPrior; /* Prior select in a compound select statement */
- Select *pNext; /* Next select to the left in a compound */
- Select *pRightmost; /* Right-most select in a compound select statement */
- Expr *pLimit; /* LIMIT expression. NULL means not used. */
- Expr *pOffset; /* OFFSET expression. NULL means not used. */
- int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
- int addrOpenEphm[3]; /* OP_OpenEphem opcodes related to this select */
- double nSelectRow; /* Estimated number of result rows */
- };
- /*
- ** Allowed values for Select.selFlags. The "SF" prefix stands for
- ** "Select Flag".
- */
- #define SF_Distinct 0x01 /* Output should be DISTINCT */
- #define SF_Resolved 0x02 /* Identifiers have been resolved */
- #define SF_Aggregate 0x04 /* Contains aggregate functions */
- #define SF_UsesEphemeral 0x08 /* Uses the OpenEphemeral opcode */
- #define SF_Expanded 0x10 /* sqlite3SelectExpand() called on this */
- #define SF_HasTypeInfo 0x20 /* FROM subqueries have Table metadata */
- #define SF_UseSorter 0x40 /* Sort using a sorter */
- /*
- ** The results of a select can be distributed in several ways. The
- ** "SRT" prefix means "SELECT Result Type".
- */
- #define SRT_Union 1 /* Store result as keys in an index */
- #define SRT_Except 2 /* Remove result from a UNION index */
- #define SRT_Exists 3 /* Store 1 if the result is not empty */
- #define SRT_Discard 4 /* Do not save the results anywhere */
- /* The ORDER BY clause is ignored for all of the above */
- #define IgnorableOrderby(X) ((X->eDest)<=SRT_Discard)
- #define SRT_Output 5 /* Output each row of result */
- #define SRT_Mem 6 /* Store result in a memory cell */
- #define SRT_Set 7 /* Store results as keys in an index */
- #define SRT_Table 8 /* Store result as data with an automatic rowid */
- #define SRT_EphemTab 9 /* Create transient tab and store like SRT_Table */
- #define SRT_Coroutine 10 /* Generate a single row of result */
- /*
- ** A structure used to customize the behavior of sqlite3Select(). See
- ** comments above sqlite3Select() for details.
- */
- typedef struct SelectDest SelectDest;
- struct SelectDest {
- u8 eDest; /* How to dispose of the results */
- u8 affinity; /* Affinity used when eDest==SRT_Set */
- int iParm; /* A parameter used by the eDest disposal method */
- int iMem; /* Base register where results are written */
- int nMem; /* Number of registers allocated */
- };
- /*
- ** During code generation of statements that do inserts into AUTOINCREMENT
- ** tables, the following information is attached to the Table.u.autoInc.p
- ** pointer of each autoincrement table to record some side information that
- ** the code generator needs. We have to keep per-table autoincrement
- ** information in case inserts are down within triggers. Triggers do not
- ** normally coordinate their activities, but we do need to coordinate the
- ** loading and saving of autoincrement information.
- */
- struct AutoincInfo {
- AutoincInfo *pNext; /* Next info block in a list of them all */
- Table *pTab; /* Table this info block refers to */
- int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
- int regCtr; /* Memory register holding the rowid counter */
- };
- /*
- ** Size of the column cache
- */
- #ifndef SQLITE_N_COLCACHE
- # define SQLITE_N_COLCACHE 10
- #endif
- /*
- ** At least one instance of the following structure is created for each
- ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
- ** statement. All such objects are stored in the linked list headed at
- ** Parse.pTriggerPrg and deleted once statement compilation has been
- ** completed.
- **
- ** A Vdbe sub-program that implements the body and WHEN clause of trigger
- ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
- ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
- ** The Parse.pTriggerPrg list never contains two entries with the same
- ** values for both pTrigger and orconf.
- **
- ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
- ** accessed (or set to 0 for triggers fired as a result of INSERT
- ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
- ** a mask of new.* columns used by the program.
- */
- struct TriggerPrg {
- Trigger *pTrigger; /* Trigger this program was coded from */
- int orconf; /* Default ON CONFLICT policy */
- SubProgram *pProgram; /* Program implementing pTrigger/orconf */
- u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
- TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
- };
- /*
- ** The yDbMask datatype for the bitmask of all attached databases.
- */
- #if SQLITE_MAX_ATTACHED>30
- typedef sqlite3_uint64 yDbMask;
- #else
- typedef unsigned int yDbMask;
- #endif
- /*
- ** An SQL parser context. A copy of this structure is passed through
- ** the parser and down into all the parser action routine in order to
- ** carry around information that is global to the entire parse.
- **
- ** The structure is divided into two parts. When the parser and code
- ** generate call themselves recursively, the first part of the structure
- ** is constant but the second part is reset at the beginning and end of
- ** each recursion.
- **
- ** The nTableLock and aTableLock variables are only used if the shared-cache
- ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
- ** used to store the set of table-locks required by the statement being
- ** compiled. Function sqlite3TableLock() is used to add entries to the
- ** list.
- */
- struct Parse {
- sqlite3 *db; /* The main database structure */
- int rc; /* Return code from execution */
- char *zErrMsg; /* An error message */
- Vdbe *pVdbe; /* An engine for executing database bytecode */
- u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */
- u8 checkSchema; /* Causes schema cookie check after an error */
- u8 nested; /* Number of nested calls to the parser/code generator */
- u8 nTempReg; /* Number of temporary registers in aTempReg[] */
- u8 nTempInUse; /* Number of aTempReg[] currently checked out */
- int aTempReg[8]; /* Holding area for temporary registers */
- int nRangeReg; /* Size of the temporary register block */
- int iRangeReg; /* First register in temporary register block */
- int nErr; /* Number of errors seen */
- int nTab; /* Number of previously allocated VDBE cursors */
- int nMem; /* Number of memory cells used so far */
- int nSet; /* Number of sets used so far */
- int nOnce; /* Number of OP_Once instructions so far */
- int ckBase; /* Base register of data during check constraints */
- int iCacheLevel; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
- int iCacheCnt; /* Counter used to generate aColCache[].lru values */
- u8 nColCache; /* Number of entries in aColCache[] */
- u8 iColCache; /* Next entry in aColCache[] to replace */
- struct yColCache {
- int iTable; /* Table cursor number */
- int iColumn; /* Table column number */
- u8 tempReg; /* iReg is a temp register that needs to be freed */
- int iLevel; /* Nesting level */
- int iReg; /* Reg with value of this column. 0 means none. */
- int lru; /* Least recently used entry has the smallest value */
- } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
- yDbMask writeMask; /* Start a write transaction on these databases */
- yDbMask cookieMask; /* Bitmask of schema verified databases */
- u8 isMultiWrite; /* True if statement may affect/insert multiple rows */
- u8 mayAbort; /* True if statement may throw an ABORT exception */
- int cookieGoto; /* Address of OP_Goto to cookie verifier subroutine */
- int cookieValue[SQLITE_MAX_ATTACHED+2]; /* Values of cookies to verify */
- #ifndef SQLITE_OMIT_SHARED_CACHE
- int nTableLock; /* Number of locks in aTableLock */
- TableLock *aTableLock; /* Required table locks for shared-cache mode */
- #endif
- int regRowid; /* Register holding rowid of CREATE TABLE entry */
- int regRoot; /* Register holding root page number for new objects */
- AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */
- int nMaxArg; /* Max args passed to user function by sub-program */
- /* Information used while coding trigger programs. */
- Parse *pToplevel; /* Parse structure for main program (or NULL) */
- Table *pTriggerTab; /* Table triggers are being coded for */
- u32 oldmask; /* Mask of old.* columns referenced */
- u32 newmask; /* Mask of new.* columns referenced */
- u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */
- u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */
- u8 disableTriggers; /* True to disable triggers */
- double nQueryLoop; /* Estimated number of iterations of a query */
- /* Above is constant between recursions. Below is reset before and after
- ** each recursion */
- int nVar; /* Number of '?' variables seen in the SQL so far */
- int nzVar; /* Number of available slots in azVar[] */
- char **azVar; /* Pointers to names of parameters */
- Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */
- int nAlias; /* Number of aliased result set columns */
- int *aAlias; /* Register used to hold aliased result */
- u8 explain; /* True if the EXPLAIN flag is found on the query */
- Token sNameToken; /* Token with unqualified schema object name */
- Token sLastToken; /* The last token parsed */
- const char *zTail; /* All SQL text past the last semicolon parsed */
- Table *pNewTable; /* A table being constructed by CREATE TABLE */
- Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */
- const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
- #ifndef SQLITE_OMIT_VIRTUALTABLE
- Token sArg; /* Complete text of a module argument */
- u8 declareVtab; /* True if inside sqlite3_declare_vtab() */
- int nVtabLock; /* Number of virtual tables to lock */
- Table **apVtabLock; /* Pointer to virtual tables needing locking */
- #endif
- int nHeight; /* Expression tree height of current sub-select */
- Table *pZombieTab; /* List of Table objects to delete after code gen */
- TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */
- #ifndef SQLITE_OMIT_EXPLAIN
- int iSelectId;
- int iNextSelectId;
- #endif
- };
- #ifdef SQLITE_OMIT_VIRTUALTABLE
- #define IN_DECLARE_VTAB 0
- #else
- #define IN_DECLARE_VTAB (pParse->declareVtab)
- #endif
- /*
- ** An instance of the following structure can be declared on a stack and used
- ** to save the Parse.zAuthContext value so that it can be restored later.
- */
- struct AuthContext {
- const char *zAuthContext; /* Put saved Parse.zAuthContext here */
- Parse *pParse; /* The Parse structure */
- };
- /*
- ** Bitfield flags for P5 value in OP_Insert and OP_Delete
- */
- #define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */
- #define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */
- #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
- #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
- #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
- #define OPFLAG_CLEARCACHE 0x20 /* Clear pseudo-table cache in OP_Column */
- /*
- * Each trigger present in the database schema is stored as an instance of
- * struct Trigger.
- *
- * Pointers to instances of struct Trigger are stored in two ways.
- * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
- * database). This allows Trigger structures to be retrieved by name.
- * 2. All triggers associated with a single table form a linked list, using the
- * pNext member of struct Trigger. A pointer to the first element of the
- * linked list is stored as the "pTrigger" member of the associated
- * struct Table.
- *
- * The "step_list" member points to the first element of a linked list
- * containing the SQL statements specified as the trigger program.
- */
- struct Trigger {
- char *zName; /* The name of the trigger */
- char *table; /* The table or view to which the trigger applies */
- u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
- u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
- Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */
- IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
- the <column-list> is stored here */
- Schema *pSchema; /* Schema containing the trigger */
- Schema *pTabSchema; /* Schema containing the table */
- TriggerStep *step_list; /* Link list of trigger program steps */
- Trigger *pNext; /* Next trigger associated with the table */
- };
- /*
- ** A trigger is either a BEFORE or an AFTER trigger. The following constants
- ** determine which.
- **
- ** If there are multiple triggers, you might of some BEFORE and some AFTER.
- ** In that cases, the constants below can be ORed together.
- */
- #define TRIGGER_BEFORE 1
- #define TRIGGER_AFTER 2
- /*
- * An instance of struct TriggerStep is used to store a single SQL statement
- * that is a part of a trigger-program.
- *
- * Instances of struct TriggerStep are stored in a singly linked list (linked
- * using the "pNext" member) referenced by the "step_list" member of the
- * associated struct Trigger instance. The first element of the linked list is
- * the first step of the trigger-program.
- *
- * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
- * "SELECT" statement. The meanings of the other members is determined by the
- * value of "op" as follows:
- *
- * (op == TK_INSERT)
- * orconf -> stores the ON CONFLICT algorithm
- * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
- * this stores a pointer to the SELECT statement. Otherwise NULL.
- * target -> A token holding the quoted name of the table to insert into.
- * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
- * this stores values to be inserted. Otherwise NULL.
- * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
- * statement, then this stores the column-names to be
- * inserted into.
- *
- * (op == TK_DELETE)
- * target -> A token holding the quoted name of the table to delete from.
- * pWhere -> The WHERE clause of the DELETE statement if one is specified.
- * Otherwise NULL.
- *
- * (op == TK_UPDATE)
- * target -> A token holding the quoted name of the table to update rows of.
- * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
- * Otherwise NULL.
- * pExprList -> A list of the columns to update and the expressions to update
- * them to. See sqlite3Update() documentation of "pChanges"
- * argument.
- *
- */
- struct TriggerStep {
- u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
- u8 orconf; /* OE_Rollback etc. */
- Trigger *pTrig; /* The trigger that this step is a part of */
- Select *pSelect; /* SELECT statment or RHS of INSERT INTO .. SELECT ... */
- Token target; /* Target table for DELETE, UPDATE, INSERT */
- Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */
- ExprList *pExprList; /* SET clause for UPDATE. VALUES clause for INSERT */
- IdList *pIdList; /* Column names for INSERT */
- TriggerStep *pNext; /* Next in the link-list */
- TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */
- };
- /*
- ** The following structure contains information used by the sqliteFix...
- ** routines as they walk the parse tree to make database references
- ** explicit.
- */
- typedef struct DbFixer DbFixer;
- struct DbFixer {
- Parse *pParse; /* The parsing context. Error messages written here */
- const char *zDb; /* Make sure all objects are contained in this database */
- const char *zType; /* Type of the container - used for error messages */
- const Token *pName; /* Name of the container - used for error messages */
- };
- /*
- ** An objected used to accumulate the text of a string where we
- ** do not necessarily know how big the string will be in the end.
- */
- struct StrAccum {
- sqlite3 *db; /* Optional database for lookaside. Can be NULL */
- char *zBase; /* A base allocation. Not from malloc. */
- char *zText; /* The string collected so far */
- int nChar; /* Length of the string so far */
- int nAlloc; /* Amount of space allocated in zText */
- int mxAlloc; /* Maximum allowed string length */
- u8 mallocFailed; /* Becomes true if any memory allocation fails */
- u8 useMalloc; /* 0: none, 1: sqlite3DbMalloc, 2: sqlite3_malloc */
- u8 tooBig; /* Becomes true if string size exceeds limits */
- };
- /*
- ** A pointer to this structure is used to communicate information
- ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
- */
- typedef struct {
- sqlite3 *db; /* The database being initialized */
- int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
- char **pzErrMsg; /* Error message stored here */
- int rc; /* Result code stored here */
- } InitData;
- /*
- ** Structure containing global configuration data for the SQLite library.
- **
- ** This structure also contains some state information.
- */
- struct Sqlite3Config {
- int bMemstat; /* True to enable memory status */
- int bCoreMutex; /* True to enable core mutexing */
- int bFullMutex; /* True to enable full mutexing */
- int bOpenUri; /* True to interpret filenames as URIs */
- int mxStrlen; /* Maximum string length */
- int szLookaside; /* Default lookaside buffer size */
- int nLookaside; /* Default lookaside buffer count */
- sqlite3_mem_methods m; /* Low-level memory allocation interface */
- sqlite3_mutex_methods mutex; /* Low-level mutex interface */
- sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */
- void *pHeap; /* Heap storage space */
- int nHeap; /* Size of pHeap[] */
- int mnReq, mxReq; /* Min and max heap requests sizes */
- void *pScratch; /* Scratch memory */
- int szScratch; /* Size of each scratch buffer */
- int nScratch; /* Number of scratch buffers */
- void *pPage; /* Page cache memory */
- int szPage; /* Size of each page in pPage[] */
- int nPage; /* Number of pages in pPage[] */
- int mxParserStack; /* maximum depth of the parser stack */
- int sharedCacheEnabled; /* true if shared-cache mode enabled */
- /* The above might be initialized to non-zero. The following need to always
- ** initially be zero, however. */
- int isInit; /* True after initialization has finished */
- int inProgress; /* True while initialization in progress */
- int isMutexInit; /* True after mutexes are initialized */
- int isMallocInit; /* True after malloc is initialized */
- int isPCacheInit; /* True after malloc is initialized */
- sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */
- int nRefInitMutex; /* Number of users of pInitMutex */
- void (*xLog)(void*,int,const char*); /* Function for logging */
- void *pLogArg; /* First argument to xLog() */
- int bLocaltimeFault; /* True to fail localtime() calls */
- };
- /*
- ** Context pointer passed down through the tree-walk.
- */
- struct Walker {
- int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */
- int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */
- Parse *pParse; /* Parser context. */
- union { /* Extra data for callback */
- NameContext *pNC; /* Naming context */
- int i; /* Integer value */
- } u;
- };
- /* Forward declarations */
- SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*);
- SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*);
- SQLITE_PRIVATE int sqlite3WalkSelect(Walker*, Select*);
- SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker*, Select*);
- SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker*, Select*);
- /*
- ** Return code from the parse-tree walking primitives and their
- ** callbacks.
- */
- #define WRC_Continue 0 /* Continue down into children */
- #define WRC_Prune 1 /* Omit children but continue walking siblings */
- #define WRC_Abort 2 /* Abandon the tree walk */
- /*
- ** Assuming zIn points to the first byte of a UTF-8 character,
- ** advance zIn to point to the first byte of the next UTF-8 character.
- */
- #define SQLITE_SKIP_UTF8(zIn) { \
- if( (*(zIn++))>=0xc0 ){ \
- while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
- } \
- }
- /*
- ** The SQLITE_*_BKPT macros are substitutes for the error codes with
- ** the same name but without the _BKPT suffix. These macros invoke
- ** routines that report the line-number on which the error originated
- ** using sqlite3_log(). The routines also provide a convenient place
- ** to set a debugger breakpoint.
- */
- SQLITE_PRIVATE int sqlite3CorruptError(int);
- SQLITE_PRIVATE int sqlite3MisuseError(int);
- SQLITE_PRIVATE int sqlite3CantopenError(int);
- #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
- #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
- #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
- /*
- ** FTS4 is really an extension for FTS3. It is enabled using the
- ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all
- ** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3.
- */
- #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
- # define SQLITE_ENABLE_FTS3
- #endif
- /*
- ** The ctype.h header is needed for non-ASCII systems. It is also
- ** needed by FTS3 when FTS3 is included in the amalgamation.
- */
- #if !defined(SQLITE_ASCII) || \
- (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
- # include <ctype.h>
- #endif
- /*
- ** The following macros mimic the standard library functions toupper(),
- ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
- ** sqlite versions only work for ASCII characters, regardless of locale.
- */
- #ifdef SQLITE_ASCII
- # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
- # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
- # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
- # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
- # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
- # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
- # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
- #else
- # define sqlite3Toupper(x) toupper((unsigned char)(x))
- # define sqlite3Isspace(x) isspace((unsigned char)(x))
- # define sqlite3Isalnum(x) isalnum((unsigned char)(x))
- # define sqlite3Isalpha(x) isalpha((unsigned char)(x))
- # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
- # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
- # define sqlite3Tolower(x) tolower((unsigned char)(x))
- #endif
- /*
- ** Internal function prototypes
- */
- SQLITE_PRIVATE int sqlite3StrICmp(const char *, const char *);
- SQLITE_PRIVATE int sqlite3Strlen30(const char*);
- #define sqlite3StrNICmp sqlite3_strnicmp
- SQLITE_PRIVATE int sqlite3MallocInit(void);
- SQLITE_PRIVATE void sqlite3MallocEnd(void);
- SQLITE_PRIVATE void *sqlite3Malloc(int);
- SQLITE_PRIVATE void *sqlite3MallocZero(int);
- SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, int);
- SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, int);
- SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3*,const char*);
- SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3*,const char*, int);
- SQLITE_PRIVATE void *sqlite3Realloc(void*, int);
- SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
- SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, int);
- SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*);
- SQLITE_PRIVATE int sqlite3MallocSize(void*);
- SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*);
- SQLITE_PRIVATE void *sqlite3ScratchMalloc(int);
- SQLITE_PRIVATE void sqlite3ScratchFree(void*);
- SQLITE_PRIVATE void *sqlite3PageMalloc(int);
- SQLITE_PRIVATE void sqlite3PageFree(void*);
- SQLITE_PRIVATE void sqlite3MemSetDefault(void);
- SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
- SQLITE_PRIVATE int sqlite3HeapNearlyFull(void);
- /*
- ** On systems with ample stack space and that support alloca(), make
- ** use of alloca() to obtain space for large automatic objects. By default,
- ** obtain space from malloc().
- **
- ** The alloca() routine never returns NULL. This will cause code paths
- ** that deal with sqlite3StackAlloc() failures to be unreachable.
- */
- #ifdef SQLITE_USE_ALLOCA
- # define sqlite3StackAllocRaw(D,N) alloca(N)
- # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
- # define sqlite3StackFree(D,P)
- #else
- # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
- # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
- # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
- #endif
- #ifdef SQLITE_ENABLE_MEMSYS3
- SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
- #endif
- #ifdef SQLITE_ENABLE_MEMSYS5
- SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
- #endif
- #ifndef SQLITE_MUTEX_OMIT
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void);
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void);
- SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int);
- SQLITE_PRIVATE int sqlite3MutexInit(void);
- SQLITE_PRIVATE int sqlite3MutexEnd(void);
- #endif
- SQLITE_PRIVATE int sqlite3StatusValue(int);
- SQLITE_PRIVATE void sqlite3StatusAdd(int, int);
- SQLITE_PRIVATE void sqlite3StatusSet(int, int);
- #ifndef SQLITE_OMIT_FLOATING_POINT
- SQLITE_PRIVATE int sqlite3IsNaN(double);
- #else
- # define sqlite3IsNaN(X) 0
- #endif
- SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, int, const char*, va_list);
- #ifndef SQLITE_OMIT_TRACE
- SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, const char*, ...);
- #endif
- SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...);
- SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
- SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3*,char*,const char*,...);
- #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
- SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...);
- #endif
- #if defined(SQLITE_TEST)
- SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*);
- #endif
- /* Output formatting for SQLITE_TESTCTRL_EXPLAIN */
- #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
- SQLITE_PRIVATE void sqlite3ExplainBegin(Vdbe*);
- SQLITE_PRIVATE void sqlite3ExplainPrintf(Vdbe*, const char*, ...);
- SQLITE_PRIVATE void sqlite3ExplainNL(Vdbe*);
- SQLITE_PRIVATE void sqlite3ExplainPush(Vdbe*);
- SQLITE_PRIVATE void sqlite3ExplainPop(Vdbe*);
- SQLITE_PRIVATE void sqlite3ExplainFinish(Vdbe*);
- SQLITE_PRIVATE void sqlite3ExplainSelect(Vdbe*, Select*);
- SQLITE_PRIVATE void sqlite3ExplainExpr(Vdbe*, Expr*);
- SQLITE_PRIVATE void sqlite3ExplainExprList(Vdbe*, ExprList*);
- SQLITE_PRIVATE const char *sqlite3VdbeExplanation(Vdbe*);
- #else
- # define sqlite3ExplainBegin(X)
- # define sqlite3ExplainSelect(A,B)
- # define sqlite3ExplainExpr(A,B)
- # define sqlite3ExplainExprList(A,B)
- # define sqlite3ExplainFinish(X)
- # define sqlite3VdbeExplanation(X) 0
- #endif
- SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*, ...);
- SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
- SQLITE_PRIVATE int sqlite3Dequote(char*);
- SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int);
- SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **);
- SQLITE_PRIVATE void sqlite3FinishCoding(Parse*);
- SQLITE_PRIVATE int sqlite3GetTempReg(Parse*);
- SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int);
- SQLITE_PRIVATE int sqlite3GetTempRange(Parse*,int);
- SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int);
- SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse*);
- SQLITE_PRIVATE Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int);
- SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*);
- SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
- SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*);
- SQLITE_PRIVATE Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*);
- SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
- SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*);
- SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
- SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
- SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
- SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
- SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
- SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**);
- SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);
- SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
- SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3*, int);
- SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);
- SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
- SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*);
- SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *, int);
- SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
- SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*);
- SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int);
- SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
- SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*);
- SQLITE_PRIVATE void sqlite3AddColumnType(Parse*,Token*);
- SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*);
- SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);
- SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);
- SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*,
- sqlite3_vfs**,char**,char **);
- SQLITE_PRIVATE int sqlite3CodeOnce(Parse *);
- SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);
- SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32);
- SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32);
- SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
- SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*);
- SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
- SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int,int*);
- SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int);
- SQLITE_PRIVATE void sqlite3RowSetClear(RowSet*);
- SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64);
- SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, u8 iBatch, i64);
- SQLITE_PRIVATE int sqlite3RowSetNext(RowSet*, i64*);
- SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
- #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
- SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse*,Table*);
- #else
- # define sqlite3ViewGetColumnNames(A,B) 0
- #endif
- SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int);
- SQLITE_PRIVATE void sqlite3CodeDropTable(Parse*, Table*, int, int);
- SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3*, Table*);
- #ifndef SQLITE_OMIT_AUTOINCREMENT
- SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
- SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
- #else
- # define sqlite3AutoincrementBegin(X)
- # define sqlite3AutoincrementEnd(X)
- #endif
- SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
- SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int,int*,int*,int*);
- SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*);
- SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*);
- SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int);
- SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*);
- SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
- Token*, Select*, Expr*, IdList*);
- SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
- SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, struct SrcList_item *);
- SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*);
- SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*);
- SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*);
- SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*);
- SQLITE_PRIVATE Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
- Token*, int, int);
- SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int);
- SQLITE_PRIVATE int sqlite3Select(Parse*, Select*, SelectDest*);
- SQLITE_PRIVATE Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
- Expr*,ExprList*,int,Expr*,Expr*);
- SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*);
- SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse*, SrcList*);
- SQLITE_PRIVATE int sqlite3IsReadOnly(Parse*, Table*, int);
- SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
- #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
- SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse *, SrcList *, Expr *, ExprList *, Expr *, Expr *, char *);
- #endif
- SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
- SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
- SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*, SrcList*, Expr*, ExprList**,ExprList*,u16);
- SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*);
- SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int);
- SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
- SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);
- SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, int, int, int);
- SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse*, int, int, int);
- SQLITE_PRIVATE void sqlite3ExprCachePush(Parse*);
- SQLITE_PRIVATE void sqlite3ExprCachePop(Parse*, int);
- SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse*, int, int);
- SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse*);
- SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse*, int, int);
- SQLITE_PRIVATE int sqlite3ExprCode(Parse*, Expr*, int);
- SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
- SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int);
- SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse*, Expr*, int);
- SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse*, Expr*);
- SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int);
- SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
- SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
- SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*);
- SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*);
- SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
- SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
- SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
- SQLITE_PRIVATE void sqlite3Vacuum(Parse*);
- SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*);
- SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, Token*);
- SQLITE_PRIVATE int sqlite3ExprCompare(Expr*, Expr*);
- SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList*, ExprList*);
- SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
- SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
- SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*);
- SQLITE_PRIVATE void sqlite3PrngSaveState(void);
- SQLITE_PRIVATE void sqlite3PrngRestoreState(void);
- SQLITE_PRIVATE void sqlite3PrngResetState(void);
- SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*);
- SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int);
- SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);
- SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int);
- SQLITE_PRIVATE void sqlite3CommitTransaction(Parse*);
- SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse*);
- SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*);
- SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
- SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*);
- SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);
- SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*);
- SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*);
- SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*);
- SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
- SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
- SQLITE_PRIVATE int sqlite3IsRowid(const char*);
- SQLITE_PRIVATE void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int);
- SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*);
- SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int);
- SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int,
- int*,int,int,int,int,int*);
- SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int);
- SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, int);
- SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);
- SQLITE_PRIVATE void sqlite3MultiWrite(Parse*);
- SQLITE_PRIVATE void sqlite3MayAbort(Parse*);
- SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, char*, int);
- SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int);
- SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int);
- SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int);
- SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*);
- SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int);
- SQLITE_PRIVATE void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);
- SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,int);
- SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3*);
- SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void);
- SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void);
- SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*);
- SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*);
- SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int);
- #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
- SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, int);
- #endif
- #ifndef SQLITE_OMIT_TRIGGER
- SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
- Expr*,int, int);
- SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
- SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int);
- SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*);
- SQLITE_PRIVATE Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask);
- SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *, Table *);
- SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
- int, int, int);
- SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
- void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
- SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
- SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*);
- SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*,
- ExprList*,Select*,u8);
- SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8);
- SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*);
- SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*);
- SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
- SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
- # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
- #else
- # define sqlite3TriggersExist(B,C,D,E,F) 0
- # define sqlite3DeleteTrigger(A,B)
- # define sqlite3DropTriggerPtr(A,B)
- # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
- # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
- # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
- # define sqlite3TriggerList(X, Y) 0
- # define sqlite3ParseToplevel(p) p
- # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
- #endif
- SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*);
- SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
- SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int);
- #ifndef SQLITE_OMIT_AUTHORIZATION
- SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
- SQLITE_PRIVATE int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*);
- SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
- SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*);
- SQLITE_PRIVATE int sqlite3AuthReadCol(Parse*, const char *, const char *, int);
- #else
- # define sqlite3AuthRead(a,b,c,d)
- # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
- # define sqlite3AuthContextPush(a,b,c)
- # define sqlite3AuthContextPop(a) ((void)(a))
- #endif
- SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
- SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*);
- SQLITE_PRIVATE int sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*);
- SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*);
- SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*);
- SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*);
- SQLITE_PRIVATE int sqlite3FixExprList(DbFixer*, ExprList*);
- SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
- SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8);
- SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*);
- SQLITE_PRIVATE int sqlite3Atoi(const char*);
- SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
- SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
- SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8*, const u8**);
- /*
- ** Routines to read and write variable-length integers. These used to
- ** be defined locally, but now we use the varint routines in the util.c
- ** file. Code should use the MACRO forms below, as the Varint32 versions
- ** are coded to assume the single byte case is already handled (which
- ** the MACRO form does).
- */
- SQLITE_PRIVATE int sqlite3PutVarint(unsigned char*, u64);
- SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char*, u32);
- SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *, u64 *);
- SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *);
- SQLITE_PRIVATE int sqlite3VarintLen(u64 v);
- /*
- ** The header of a record consists of a sequence variable-length integers.
- ** These integers are almost always small and are encoded as a single byte.
- ** The following macros take advantage this fact to provide a fast encode
- ** and decode of the integers in a record header. It is faster for the common
- ** case where the integer is a single byte. It is a little slower when the
- ** integer is two or more bytes. But overall it is faster.
- **
- ** The following expressions are equivalent:
- **
- ** x = sqlite3GetVarint32( A, &B );
- ** x = sqlite3PutVarint32( A, B );
- **
- ** x = getVarint32( A, B );
- ** x = putVarint32( A, B );
- **
- */
- #define getVarint32(A,B) (u8)((*(A)<(u8)0x80) ? ((B) = (u32)*(A)),1 : sqlite3GetVarint32((A), (u32 *)&(B)))
- #define putVarint32(A,B) (u8)(((u32)(B)<(u32)0x80) ? (*(A) = (unsigned char)(B)),1 : sqlite3PutVarint32((A), (B)))
- #define getVarint sqlite3GetVarint
- #define putVarint sqlite3PutVarint
- SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *, Index *);
- SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *, Table *);
- SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2);
- SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
- SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr);
- SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8);
- SQLITE_PRIVATE void sqlite3Error(sqlite3*, int, const char*,...);
- SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
- SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
- SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
- SQLITE_PRIVATE const char *sqlite3ErrStr(int);
- SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);
- SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
- SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
- SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
- SQLITE_PRIVATE Expr *sqlite3ExprSetColl(Expr*, CollSeq*);
- SQLITE_PRIVATE Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr*, Token*);
- SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *);
- SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *, const char *);
- SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int);
- SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64);
- SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64);
- SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64);
- SQLITE_PRIVATE int sqlite3AbsInt32(int);
- #ifdef SQLITE_ENABLE_8_3_NAMES
- SQLITE_PRIVATE void sqlite3FileSuffix3(const char*, char*);
- #else
- # define sqlite3FileSuffix3(X,Y)
- #endif
- SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z);
- SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);
- SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8);
- SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
- void(*)(void*));
- SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*);
- SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *);
- SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
- #ifdef SQLITE_ENABLE_STAT3
- SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *, u8, char *, int, int *);
- #endif
- SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
- SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
- #ifndef SQLITE_AMALGAMATION
- SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
- SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
- SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];
- SQLITE_PRIVATE const Token sqlite3IntTokens[];
- SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
- SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
- #ifndef SQLITE_OMIT_WSD
- SQLITE_PRIVATE int sqlite3PendingByte;
- #endif
- #endif
- SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, int, int);
- SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*);
- SQLITE_PRIVATE void sqlite3AlterFunctions(void);
- SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
- SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *, int *);
- SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...);
- SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*);
- SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *, Expr *, int, int);
- SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*);
- SQLITE_PRIVATE int sqlite3ResolveExprNames(NameContext*, Expr*);
- SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
- SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
- SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
- SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
- SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
- SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(sqlite3*, u8, CollSeq *, const char*);
- SQLITE_PRIVATE char sqlite3AffinityType(const char*);
- SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*);
- SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler*);
- SQLITE_PRIVATE int sqlite3FindDb(sqlite3*, Token*);
- SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *, const char *);
- SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3*,int iDB);
- SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3*,Index*);
- SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*);
- SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int);
- SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
- SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int);
- SQLITE_PRIVATE void sqlite3SchemaClear(void *);
- SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
- SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
- SQLITE_PRIVATE KeyInfo *sqlite3IndexKeyinfo(Parse *, Index *);
- SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
- void (*)(sqlite3_context*,int,sqlite3_value **),
- void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
- FuncDestructor *pDestructor
- );
- SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int);
- SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *);
- SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, char*, int, int);
- SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum*,const char*,int);
- SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum*,int);
- SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*);
- SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum*);
- SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int);
- SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
- SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *);
- SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
- /*
- ** The interface to the LEMON-generated parser
- */
- SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(size_t));
- SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*));
- SQLITE_PRIVATE void sqlite3Parser(void*, int, Token, Parse*);
- #ifdef YYTRACKMAXSTACKDEPTH
- SQLITE_PRIVATE int sqlite3ParserStackPeak(void*);
- #endif
- SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*);
- #ifndef SQLITE_OMIT_LOAD_EXTENSION
- SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*);
- #else
- # define sqlite3CloseExtensions(X)
- #endif
- #ifndef SQLITE_OMIT_SHARED_CACHE
- SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, int, u8, const char *);
- #else
- #define sqlite3TableLock(v,w,x,y,z)
- #endif
- #ifdef SQLITE_TEST
- SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char*);
- #endif
- #ifdef SQLITE_OMIT_VIRTUALTABLE
- # define sqlite3VtabClear(Y)
- # define sqlite3VtabSync(X,Y) SQLITE_OK
- # define sqlite3VtabRollback(X)
- # define sqlite3VtabCommit(X)
- # define sqlite3VtabInSync(db) 0
- # define sqlite3VtabLock(X)
- # define sqlite3VtabUnlock(X)
- # define sqlite3VtabUnlockList(X)
- # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
- # define sqlite3GetVTable(X,Y) ((VTable*)0)
- #else
- SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table*);
- SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, char **);
- SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db);
- SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db);
- SQLITE_PRIVATE void sqlite3VtabLock(VTable *);
- SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *);
- SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*);
- SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *, int, int);
- SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3*, Table*);
- # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
- #endif
- SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*);
- SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*);
- SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*);
- SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*);
- SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*);
- SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **);
- SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse*, Table*);
- SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
- SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *, VTable *);
- SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
- SQLITE_PRIVATE void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
- SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
- SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
- SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*);
- SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
- SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
- SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3*);
- SQLITE_PRIVATE const char *sqlite3JournalModename(int);
- SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
- SQLITE_PRIVATE int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
- /* Declarations for functions in fkey.c. All of these are replaced by
- ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
- ** key functionality is available. If OMIT_TRIGGER is defined but
- ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
- ** this case foreign keys are parsed, but no other functionality is
- ** provided (enforcement of FK constraints requires the triggers sub-system).
- */
- #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
- SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int);
- SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*);
- SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int);
- SQLITE_PRIVATE int sqlite3FkRequired(Parse*, Table*, int*, int);
- SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*);
- SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *);
- #else
- #define sqlite3FkActions(a,b,c,d)
- #define sqlite3FkCheck(a,b,c,d)
- #define sqlite3FkDropTable(a,b,c)
- #define sqlite3FkOldmask(a,b) 0
- #define sqlite3FkRequired(a,b,c,d) 0
- #endif
- #ifndef SQLITE_OMIT_FOREIGN_KEY
- SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *, Table*);
- #else
- #define sqlite3FkDelete(a,b)
- #endif
- /*
- ** Available fault injectors. Should be numbered beginning with 0.
- */
- #define SQLITE_FAULTINJECTOR_MALLOC 0
- #define SQLITE_FAULTINJECTOR_COUNT 1
- /*
- ** The interface to the code in fault.c used for identifying "benign"
- ** malloc failures. This is only present if SQLITE_OMIT_BUILTIN_TEST
- ** is not defined.
- */
- #ifndef SQLITE_OMIT_BUILTIN_TEST
- SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void);
- SQLITE_PRIVATE void sqlite3EndBenignMalloc(void);
- #else
- #define sqlite3BeginBenignMalloc()
- #define sqlite3EndBenignMalloc()
- #endif
- #define IN_INDEX_ROWID 1
- #define IN_INDEX_EPH 2
- #define IN_INDEX_INDEX 3
- SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, int*);
- #ifdef SQLITE_ENABLE_ATOMIC_WRITE
- SQLITE_PRIVATE int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
- SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *);
- SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *);
- #else
- #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile)
- #endif
- SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *);
- SQLITE_PRIVATE int sqlite3MemJournalSize(void);
- SQLITE_PRIVATE int sqlite3IsMemJournal(sqlite3_file *);
- #if SQLITE_MAX_EXPR_DEPTH>0
- SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
- SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *);
- SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse*, int);
- #else
- #define sqlite3ExprSetHeight(x,y)
- #define sqlite3SelectExprHeight(x) 0
- #define sqlite3ExprCheckHeight(x,y)
- #endif
- SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*);
- SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
- #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
- SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *);
- SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db);
- SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db);
- #else
- #define sqlite3ConnectionBlocked(x,y)
- #define sqlite3ConnectionUnlocked(x)
- #define sqlite3ConnectionClosed(x)
- #endif
- #ifdef SQLITE_DEBUG
- SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *);
- #endif
- /*
- ** If the SQLITE_ENABLE IOTRACE exists then the global variable
- ** sqlite3IoTrace is a pointer to a printf-like routine used to
- ** print I/O tracing messages.
- */
- #ifdef SQLITE_ENABLE_IOTRACE
- # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
- SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*);
- SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*,...);
- #else
- # define IOTRACE(A)
- # define sqlite3VdbeIOTraceSql(X)
- #endif
- /*
- ** These routines are available for the mem2.c debugging memory allocator
- ** only. They are used to verify that different "types" of memory
- ** allocations are properly tracked by the system.
- **
- ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
- ** the MEMTYPE_* macros defined below. The type must be a bitmask with
- ** a single bit set.
- **
- ** sqlite3MemdebugHasType() returns true if any of the bits in its second
- ** argument match the type set by the previous sqlite3MemdebugSetType().
- ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
- **
- ** sqlite3MemdebugNoType() returns true if none of the bits in its second
- ** argument match the type set by the previous sqlite3MemdebugSetType().
- **
- ** Perhaps the most important point is the difference between MEMTYPE_HEAP
- ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
- ** it might have been allocated by lookaside, except the allocation was
- ** too large or lookaside was already full. It is important to verify
- ** that allocations that might have been satisfied by lookaside are not
- ** passed back to non-lookaside free() routines. Asserts such as the
- ** example above are placed on the non-lookaside free() routines to verify
- ** this constraint.
- **
- ** All of this is no-op for a production build. It only comes into
- ** play when the SQLITE_MEMDEBUG compile-time option is used.
- */
- #ifdef SQLITE_MEMDEBUG
- SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8);
- SQLITE_PRIVATE int sqlite3MemdebugHasType(void*,u8);
- SQLITE_PRIVATE int sqlite3MemdebugNoType(void*,u8);
- #else
- # define sqlite3MemdebugSetType(X,Y) /* no-op */
- # define sqlite3MemdebugHasType(X,Y) 1
- # define sqlite3MemdebugNoType(X,Y) 1
- #endif
- #define MEMTYPE_HEAP 0x01 /* General heap allocations */
- #define MEMTYPE_LOOKASIDE 0x02 /* Might have been lookaside memory */
- #define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */
- #define MEMTYPE_PCACHE 0x08 /* Page cache allocations */
- #define MEMTYPE_DB 0x10 /* Uses sqlite3DbMalloc, not sqlite_malloc */
- #endif /* _SQLITEINT_H_ */
- /************** End of sqliteInt.h *******************************************/
- /************** Begin file global.c ******************************************/
- /*
- ** 2008 June 13
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains definitions of global variables and contants.
- */
- /* An array to map all upper-case characters into their corresponding
- ** lower-case character.
- **
- ** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
- ** handle case conversions for the UTF character set since the tables
- ** involved are nearly as big or bigger than SQLite itself.
- */
- SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = {
- #ifdef SQLITE_ASCII
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
- 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
- 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
- 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
- 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
- 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
- 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
- 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
- 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
- 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
- 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
- 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
- 252,253,254,255
- #endif
- #ifdef SQLITE_EBCDIC
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */
- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
- 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
- 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
- 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
- 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
- 96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
- 112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
- 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
- 144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */
- 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
- 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
- 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
- 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
- 224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */
- 239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */
- #endif
- };
- /*
- ** The following 256 byte lookup table is used to support SQLites built-in
- ** equivalents to the following standard library functions:
- **
- ** isspace() 0x01
- ** isalpha() 0x02
- ** isdigit() 0x04
- ** isalnum() 0x06
- ** isxdigit() 0x08
- ** toupper() 0x20
- ** SQLite identifier character 0x40
- **
- ** Bit 0x20 is set if the mapped character requires translation to upper
- ** case. i.e. if the character is a lower-case ASCII character.
- ** If x is a lower-case ASCII character, then its upper-case equivalent
- ** is (x - 0x20). Therefore toupper() can be implemented as:
- **
- ** (x & ~(map[x]&0x20))
- **
- ** Standard function tolower() is implemented using the sqlite3UpperToLower[]
- ** array. tolower() is used more often than toupper() by SQLite.
- **
- ** Bit 0x40 is set if the character non-alphanumeric and can be used in an
- ** SQLite identifier. Identifiers are alphanumerics, "_", "$", and any
- ** non-ASCII UTF character. Hence the test for whether or not a character is
- ** part of an identifier is 0x46.
- **
- ** SQLite's versions are identical to the standard versions assuming a
- ** locale of "C". They are implemented as macros in sqliteInt.h.
- */
- #ifdef SQLITE_ASCII
- SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00..07 ........ */
- 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10..17 ........ */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */
- 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, /* 20..27 !"#$%&' */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */
- 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, /* 30..37 01234567 */
- 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */
- 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, /* 40..47 @ABCDEFG */
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 50..57 PQRSTUVW */
- 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */
- 0x00, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22, /* 60..67 `abcdefg */
- 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */
- 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 70..77 pqrstuvw */
- 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 80..87 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 90..97 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a0..a7 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b0..b7 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c0..c7 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d0..d7 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e0..e7 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* f0..f7 ........ */
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */
- };
- #endif
- #ifndef SQLITE_USE_URI
- # define SQLITE_USE_URI 0
- #endif
- /*
- ** The following singleton contains the global configuration for
- ** the SQLite library.
- */
- SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
- SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */
- 1, /* bCoreMutex */
- SQLITE_THREADSAFE==1, /* bFullMutex */
- SQLITE_USE_URI, /* bOpenUri */
- 0x7ffffffe, /* mxStrlen */
- 128, /* szLookaside */
- 500, /* nLookaside */
- {0,0,0,0,0,0,0,0}, /* m */
- {0,0,0,0,0,0,0,0,0}, /* mutex */
- {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
- (void*)0, /* pHeap */
- 0, /* nHeap */
- 0, 0, /* mnHeap, mxHeap */
- (void*)0, /* pScratch */
- 0, /* szScratch */
- 0, /* nScratch */
- (void*)0, /* pPage */
- 0, /* szPage */
- 0, /* nPage */
- 0, /* mxParserStack */
- 0, /* sharedCacheEnabled */
- /* All the rest should always be initialized to zero */
- 0, /* isInit */
- 0, /* inProgress */
- 0, /* isMutexInit */
- 0, /* isMallocInit */
- 0, /* isPCacheInit */
- 0, /* pInitMutex */
- 0, /* nRefInitMutex */
- 0, /* xLog */
- 0, /* pLogArg */
- 0, /* bLocaltimeFault */
- };
- /*
- ** Hash table for global functions - functions common to all
- ** database connections. After initialization, this table is
- ** read-only.
- */
- SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
- /*
- ** Constant tokens for values 0 and 1.
- */
- SQLITE_PRIVATE const Token sqlite3IntTokens[] = {
- { "0", 1 },
- { "1", 1 }
- };
- /*
- ** The value of the "pending" byte must be 0x40000000 (1 byte past the
- ** 1-gibabyte boundary) in a compatible database. SQLite never uses
- ** the database page that contains the pending byte. It never attempts
- ** to read or write that page. The pending byte page is set assign
- ** for use by the VFS layers as space for managing file locks.
- **
- ** During testing, it is often desirable to move the pending byte to
- ** a different position in the file. This allows code that has to
- ** deal with the pending byte to run on files that are much smaller
- ** than 1 GiB. The sqlite3_test_control() interface can be used to
- ** move the pending byte.
- **
- ** IMPORTANT: Changing the pending byte to any value other than
- ** 0x40000000 results in an incompatible database file format!
- ** Changing the pending byte during operating results in undefined
- ** and dileterious behavior.
- */
- #ifndef SQLITE_OMIT_WSD
- SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000;
- #endif
- /*
- ** Properties of opcodes. The OPFLG_INITIALIZER macro is
- ** created by mkopcodeh.awk during compilation. Data is obtained
- ** from the comments following the "case OP_xxxx:" statements in
- ** the vdbe.c file.
- */
- SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
- /************** End of global.c **********************************************/
- /************** Begin file ctime.c *******************************************/
- /*
- ** 2010 February 23
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file implements routines used to report what compile-time options
- ** SQLite was built with.
- */
- #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
- /*
- ** An array of names of all compile-time options. This array should
- ** be sorted A-Z.
- **
- ** This array looks large, but in a typical installation actually uses
- ** only a handful of compile-time options, so most times this array is usually
- ** rather short and uses little memory space.
- */
- static const char * const azCompileOpt[] = {
- /* These macros are provided to "stringify" the value of the define
- ** for those options in which the value is meaningful. */
- #define CTIMEOPT_VAL_(opt) #opt
- #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
- #ifdef SQLITE_32BIT_ROWID
- "32BIT_ROWID",
- #endif
- #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
- "4_BYTE_ALIGNED_MALLOC",
- #endif
- #ifdef SQLITE_CASE_SENSITIVE_LIKE
- "CASE_SENSITIVE_LIKE",
- #endif
- #ifdef SQLITE_CHECK_PAGES
- "CHECK_PAGES",
- #endif
- #ifdef SQLITE_COVERAGE_TEST
- "COVERAGE_TEST",
- #endif
- #ifdef SQLITE_DEBUG
- "DEBUG",
- #endif
- #ifdef SQLITE_DEFAULT_LOCKING_MODE
- "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
- #endif
- #ifdef SQLITE_DISABLE_DIRSYNC
- "DISABLE_DIRSYNC",
- #endif
- #ifdef SQLITE_DISABLE_LFS
- "DISABLE_LFS",
- #endif
- #ifdef SQLITE_ENABLE_ATOMIC_WRITE
- "ENABLE_ATOMIC_WRITE",
- #endif
- #ifdef SQLITE_ENABLE_CEROD
- "ENABLE_CEROD",
- #endif
- #ifdef SQLITE_ENABLE_COLUMN_METADATA
- "ENABLE_COLUMN_METADATA",
- #endif
- #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
- "ENABLE_EXPENSIVE_ASSERT",
- #endif
- #ifdef SQLITE_ENABLE_FTS1
- "ENABLE_FTS1",
- #endif
- #ifdef SQLITE_ENABLE_FTS2
- "ENABLE_FTS2",
- #endif
- #ifdef SQLITE_ENABLE_FTS3
- "ENABLE_FTS3",
- #endif
- #ifdef SQLITE_ENABLE_FTS3_PARENTHESIS
- "ENABLE_FTS3_PARENTHESIS",
- #endif
- #ifdef SQLITE_ENABLE_FTS4
- "ENABLE_FTS4",
- #endif
- #ifdef SQLITE_ENABLE_ICU
- "ENABLE_ICU",
- #endif
- #ifdef SQLITE_ENABLE_IOTRACE
- "ENABLE_IOTRACE",
- #endif
- #ifdef SQLITE_ENABLE_LOAD_EXTENSION
- "ENABLE_LOAD_EXTENSION",
- #endif
- #ifdef SQLITE_ENABLE_LOCKING_STYLE
- "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
- #endif
- #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
- "ENABLE_MEMORY_MANAGEMENT",
- #endif
- #ifdef SQLITE_ENABLE_MEMSYS3
- "ENABLE_MEMSYS3",
- #endif
- #ifdef SQLITE_ENABLE_MEMSYS5
- "ENABLE_MEMSYS5",
- #endif
- #ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK
- "ENABLE_OVERSIZE_CELL_CHECK",
- #endif
- #ifdef SQLITE_ENABLE_RTREE
- "ENABLE_RTREE",
- #endif
- #ifdef SQLITE_ENABLE_STAT3
- "ENABLE_STAT3",
- #endif
- #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
- "ENABLE_UNLOCK_NOTIFY",
- #endif
- #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
- "ENABLE_UPDATE_DELETE_LIMIT",
- #endif
- #ifdef SQLITE_HAS_CODEC
- "HAS_CODEC",
- #endif
- #ifdef SQLITE_HAVE_ISNAN
- "HAVE_ISNAN",
- #endif
- #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
- "HOMEGROWN_RECURSIVE_MUTEX",
- #endif
- #ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS
- "IGNORE_AFP_LOCK_ERRORS",
- #endif
- #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
- "IGNORE_FLOCK_LOCK_ERRORS",
- #endif
- #ifdef SQLITE_INT64_TYPE
- "INT64_TYPE",
- #endif
- #ifdef SQLITE_LOCK_TRACE
- "LOCK_TRACE",
- #endif
- #ifdef SQLITE_MAX_SCHEMA_RETRY
- "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
- #endif
- #ifdef SQLITE_MEMDEBUG
- "MEMDEBUG",
- #endif
- #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
- "MIXED_ENDIAN_64BIT_FLOAT",
- #endif
- #ifdef SQLITE_NO_SYNC
- "NO_SYNC",
- #endif
- #ifdef SQLITE_OMIT_ALTERTABLE
- "OMIT_ALTERTABLE",
- #endif
- #ifdef SQLITE_OMIT_ANALYZE
- "OMIT_ANALYZE",
- #endif
- #ifdef SQLITE_OMIT_ATTACH
- "OMIT_ATTACH",
- #endif
- #ifdef SQLITE_OMIT_AUTHORIZATION
- "OMIT_AUTHORIZATION",
- #endif
- #ifdef SQLITE_OMIT_AUTOINCREMENT
- "OMIT_AUTOINCREMENT",
- #endif
- #ifdef SQLITE_OMIT_AUTOINIT
- "OMIT_AUTOINIT",
- #endif
- #ifdef SQLITE_OMIT_AUTOMATIC_INDEX
- "OMIT_AUTOMATIC_INDEX",
- #endif
- #ifdef SQLITE_OMIT_AUTORESET
- "OMIT_AUTORESET",
- #endif
- #ifdef SQLITE_OMIT_AUTOVACUUM
- "OMIT_AUTOVACUUM",
- #endif
- #ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION
- "OMIT_BETWEEN_OPTIMIZATION",
- #endif
- #ifdef SQLITE_OMIT_BLOB_LITERAL
- "OMIT_BLOB_LITERAL",
- #endif
- #ifdef SQLITE_OMIT_BTREECOUNT
- "OMIT_BTREECOUNT",
- #endif
- #ifdef SQLITE_OMIT_BUILTIN_TEST
- "OMIT_BUILTIN_TEST",
- #endif
- #ifdef SQLITE_OMIT_CAST
- "OMIT_CAST",
- #endif
- #ifdef SQLITE_OMIT_CHECK
- "OMIT_CHECK",
- #endif
- /* // redundant
- ** #ifdef SQLITE_OMIT_COMPILEOPTION_DIAGS
- ** "OMIT_COMPILEOPTION_DIAGS",
- ** #endif
- */
- #ifdef SQLITE_OMIT_COMPLETE
- "OMIT_COMPLETE",
- #endif
- #ifdef SQLITE_OMIT_COMPOUND_SELECT
- "OMIT_COMPOUND_SELECT",
- #endif
- #ifdef SQLITE_OMIT_DATETIME_FUNCS
- "OMIT_DATETIME_FUNCS",
- #endif
- #ifdef SQLITE_OMIT_DECLTYPE
- "OMIT_DECLTYPE",
- #endif
- #ifdef SQLITE_OMIT_DEPRECATED
- "OMIT_DEPRECATED",
- #endif
- #ifdef SQLITE_OMIT_DISKIO
- "OMIT_DISKIO",
- #endif
- #ifdef SQLITE_OMIT_EXPLAIN
- "OMIT_EXPLAIN",
- #endif
- #ifdef SQLITE_OMIT_FLAG_PRAGMAS
- "OMIT_FLAG_PRAGMAS",
- #endif
- #ifdef SQLITE_OMIT_FLOATING_POINT
- "OMIT_FLOATING_POINT",
- #endif
- #ifdef SQLITE_OMIT_FOREIGN_KEY
- "OMIT_FOREIGN_KEY",
- #endif
- #ifdef SQLITE_OMIT_GET_TABLE
- "OMIT_GET_TABLE",
- #endif
- #ifdef SQLITE_OMIT_INCRBLOB
- "OMIT_INCRBLOB",
- #endif
- #ifdef SQLITE_OMIT_INTEGRITY_CHECK
- "OMIT_INTEGRITY_CHECK",
- #endif
- #ifdef SQLITE_OMIT_LIKE_OPTIMIZATION
- "OMIT_LIKE_OPTIMIZATION",
- #endif
- #ifdef SQLITE_OMIT_LOAD_EXTENSION
- "OMIT_LOAD_EXTENSION",
- #endif
- #ifdef SQLITE_OMIT_LOCALTIME
- "OMIT_LOCALTIME",
- #endif
- #ifdef SQLITE_OMIT_LOOKASIDE
- "OMIT_LOOKASIDE",
- #endif
- #ifdef SQLITE_OMIT_MEMORYDB
- "OMIT_MEMORYDB",
- #endif
- #ifdef SQLITE_OMIT_MERGE_SORT
- "OMIT_MERGE_SORT",
- #endif
- #ifdef SQLITE_OMIT_OR_OPTIMIZATION
- "OMIT_OR_OPTIMIZATION",
- #endif
- #ifdef SQLITE_OMIT_PAGER_PRAGMAS
- "OMIT_PAGER_PRAGMAS",
- #endif
- #ifdef SQLITE_OMIT_PRAGMA
- "OMIT_PRAGMA",
- #endif
- #ifdef SQLITE_OMIT_PROGRESS_CALLBACK
- "OMIT_PROGRESS_CALLBACK",
- #endif
- #ifdef SQLITE_OMIT_QUICKBALANCE
- "OMIT_QUICKBALANCE",
- #endif
- #ifdef SQLITE_OMIT_REINDEX
- "OMIT_REINDEX",
- #endif
- #ifdef SQLITE_OMIT_SCHEMA_PRAGMAS
- "OMIT_SCHEMA_PRAGMAS",
- #endif
- #ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
- "OMIT_SCHEMA_VERSION_PRAGMAS",
- #endif
- #ifdef SQLITE_OMIT_SHARED_CACHE
- "OMIT_SHARED_CACHE",
- #endif
- #ifdef SQLITE_OMIT_SUBQUERY
- "OMIT_SUBQUERY",
- #endif
- #ifdef SQLITE_OMIT_TCL_VARIABLE
- "OMIT_TCL_VARIABLE",
- #endif
- #ifdef SQLITE_OMIT_TEMPDB
- "OMIT_TEMPDB",
- #endif
- #ifdef SQLITE_OMIT_TRACE
- "OMIT_TRACE",
- #endif
- #ifdef SQLITE_OMIT_TRIGGER
- "OMIT_TRIGGER",
- #endif
- #ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
- "OMIT_TRUNCATE_OPTIMIZATION",
- #endif
- #ifdef SQLITE_OMIT_UTF16
- "OMIT_UTF16",
- #endif
- #ifdef SQLITE_OMIT_VACUUM
- "OMIT_VACUUM",
- #endif
- #ifdef SQLITE_OMIT_VIEW
- "OMIT_VIEW",
- #endif
- #ifdef SQLITE_OMIT_VIRTUALTABLE
- "OMIT_VIRTUALTABLE",
- #endif
- #ifdef SQLITE_OMIT_WAL
- "OMIT_WAL",
- #endif
- #ifdef SQLITE_OMIT_WSD
- "OMIT_WSD",
- #endif
- #ifdef SQLITE_OMIT_XFER_OPT
- "OMIT_XFER_OPT",
- #endif
- #ifdef SQLITE_PERFORMANCE_TRACE
- "PERFORMANCE_TRACE",
- #endif
- #ifdef SQLITE_PROXY_DEBUG
- "PROXY_DEBUG",
- #endif
- #ifdef SQLITE_SECURE_DELETE
- "SECURE_DELETE",
- #endif
- #ifdef SQLITE_SMALL_STACK
- "SMALL_STACK",
- #endif
- #ifdef SQLITE_SOUNDEX
- "SOUNDEX",
- #endif
- #ifdef SQLITE_TCL
- "TCL",
- #endif
- #ifdef SQLITE_TEMP_STORE
- "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
- #endif
- #ifdef SQLITE_TEST
- "TEST",
- #endif
- #ifdef SQLITE_THREADSAFE
- "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
- #endif
- #ifdef SQLITE_USE_ALLOCA
- "USE_ALLOCA",
- #endif
- #ifdef SQLITE_ZERO_MALLOC
- "ZERO_MALLOC"
- #endif
- };
- /*
- ** Given the name of a compile-time option, return true if that option
- ** was used and false if not.
- **
- ** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
- ** is not required for a match.
- */
- SQLITE_API int sqlite3_compileoption_used(const char *zOptName){
- int i, n;
- if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
- n = sqlite3Strlen30(zOptName);
- /* Since ArraySize(azCompileOpt) is normally in single digits, a
- ** linear search is adequate. No need for a binary search. */
- for(i=0; i<ArraySize(azCompileOpt); i++){
- if( (sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0)
- && ( (azCompileOpt[i][n]==0) || (azCompileOpt[i][n]=='=') ) ) return 1;
- }
- return 0;
- }
- /*
- ** Return the N-th compile-time option string. If N is out of range,
- ** return a NULL pointer.
- */
- SQLITE_API const char *sqlite3_compileoption_get(int N){
- if( N>=0 && N<ArraySize(azCompileOpt) ){
- return azCompileOpt[N];
- }
- return 0;
- }
- #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
- /************** End of ctime.c ***********************************************/
- /************** Begin file status.c ******************************************/
- /*
- ** 2008 June 18
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This module implements the sqlite3_status() interface and related
- ** functionality.
- */
- /************** Include vdbeInt.h in the middle of status.c ******************/
- /************** Begin file vdbeInt.h *****************************************/
- /*
- ** 2003 September 6
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This is the header file for information that is private to the
- ** VDBE. This information used to all be at the top of the single
- ** source code file "vdbe.c". When that file became too big (over
- ** 6000 lines long) it was split up into several smaller files and
- ** this header information was factored out.
- */
- #ifndef _VDBEINT_H_
- #define _VDBEINT_H_
- /*
- ** SQL is translated into a sequence of instructions to be
- ** executed by a virtual machine. Each instruction is an instance
- ** of the following structure.
- */
- typedef struct VdbeOp Op;
- /*
- ** Boolean values
- */
- typedef unsigned char Bool;
- /* Opaque type used by code in vdbesort.c */
- typedef struct VdbeSorter VdbeSorter;
- /* Opaque type used by the explainer */
- typedef struct Explain Explain;
- /*
- ** A cursor is a pointer into a single BTree within a database file.
- ** The cursor can seek to a BTree entry with a particular key, or
- ** loop over all entries of the Btree. You can also insert new BTree
- ** entries or retrieve the key or data from the entry that the cursor
- ** is currently pointing to.
- **
- ** Every cursor that the virtual machine has open is represented by an
- ** instance of the following structure.
- */
- struct VdbeCursor {
- BtCursor *pCursor; /* The cursor structure of the backend */
- Btree *pBt; /* Separate file holding temporary table */
- KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
- int iDb; /* Index of cursor database in db->aDb[] (or -1) */
- int pseudoTableReg; /* Register holding pseudotable content. */
- int nField; /* Number of fields in the header */
- Bool zeroed; /* True if zeroed out and ready for reuse */
- Bool rowidIsValid; /* True if lastRowid is valid */
- Bool atFirst; /* True if pointing to first entry */
- Bool useRandomRowid; /* Generate new record numbers semi-randomly */
- Bool nullRow; /* True if pointing to a row with no data */
- Bool deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */
- Bool isTable; /* True if a table requiring integer keys */
- Bool isIndex; /* True if an index containing keys only - no data */
- Bool isOrdered; /* True if the underlying table is BTREE_UNORDERED */
- Bool isSorter; /* True if a new-style sorter */
- sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */
- const sqlite3_module *pModule; /* Module for cursor pVtabCursor */
- i64 seqCount; /* Sequence counter */
- i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */
- i64 lastRowid; /* Last rowid from a Next or NextIdx operation */
- VdbeSorter *pSorter; /* Sorter object for OP_SorterOpen cursors */
- /* Result of last sqlite3BtreeMoveto() done by an OP_NotExists or
- ** OP_IsUnique opcode on this cursor. */
- int seekResult;
- /* Cached information about the header for the data record that the
- ** cursor is currently pointing to. Only valid if cacheStatus matches
- ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
- ** CACHE_STALE and so setting cacheStatus=CACHE_STALE guarantees that
- ** the cache is out of date.
- **
- ** aRow might point to (ephemeral) data for the current row, or it might
- ** be NULL.
- */
- u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
- int payloadSize; /* Total number of bytes in the record */
- u32 *aType; /* Type values for all entries in the record */
- u32 *aOffset; /* Cached offsets to the start of each columns data */
- u8 *aRow; /* Data for the current row, if all on one page */
- };
- typedef struct VdbeCursor VdbeCursor;
- /*
- ** When a sub-program is executed (OP_Program), a structure of this type
- ** is allocated to store the current value of the program counter, as
- ** well as the current memory cell array and various other frame specific
- ** values stored in the Vdbe struct. When the sub-program is finished,
- ** these values are copied back to the Vdbe from the VdbeFrame structure,
- ** restoring the state of the VM to as it was before the sub-program
- ** began executing.
- **
- ** The memory for a VdbeFrame object is allocated and managed by a memory
- ** cell in the parent (calling) frame. When the memory cell is deleted or
- ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
- ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
- ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
- ** this instead of deleting the VdbeFrame immediately is to avoid recursive
- ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
- ** child frame are released.
- **
- ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
- ** set to NULL if the currently executing frame is the main program.
- */
- typedef struct VdbeFrame VdbeFrame;
- struct VdbeFrame {
- Vdbe *v; /* VM this frame belongs to */
- int pc; /* Program Counter in parent (calling) frame */
- Op *aOp; /* Program instructions for parent frame */
- int nOp; /* Size of aOp array */
- Mem *aMem; /* Array of memory cells for parent frame */
- int nMem; /* Number of entries in aMem */
- u8 *aOnceFlag; /* Array of OP_Once flags for parent frame */
- int nOnceFlag; /* Number of entries in aOnceFlag */
- VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
- u16 nCursor; /* Number of entries in apCsr */
- void *token; /* Copy of SubProgram.token */
- int nChildMem; /* Number of memory cells for child frame */
- int nChildCsr; /* Number of cursors for child frame */
- i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */
- int nChange; /* Statement changes (Vdbe.nChanges) */
- VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */
- };
- #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
- /*
- ** A value for VdbeCursor.cacheValid that means the cache is always invalid.
- */
- #define CACHE_STALE 0
- /*
- ** Internally, the vdbe manipulates nearly all SQL values as Mem
- ** structures. Each Mem struct may cache multiple representations (string,
- ** integer etc.) of the same value.
- */
- struct Mem {
- sqlite3 *db; /* The associated database connection */
- char *z; /* String or BLOB value */
- double r; /* Real value */
- union {
- i64 i; /* Integer value used when MEM_Int is set in flags */
- int nZero; /* Used when bit MEM_Zero is set in flags */
- FuncDef *pDef; /* Used only when flags==MEM_Agg */
- RowSet *pRowSet; /* Used only when flags==MEM_RowSet */
- VdbeFrame *pFrame; /* Used when flags==MEM_Frame */
- } u;
- int n; /* Number of characters in string value, excluding '\0' */
- u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
- u8 type; /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
- u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
- #ifdef SQLITE_DEBUG
- Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
- void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
- #endif
- void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
- char *zMalloc; /* Dynamic buffer allocated by sqlite3_malloc() */
- };
- /* One or more of the following flags are set to indicate the validOK
- ** representations of the value stored in the Mem struct.
- **
- ** If the MEM_Null flag is set, then the value is an SQL NULL value.
- ** No other flags may be set in this case.
- **
- ** If the MEM_Str flag is set then Mem.z points at a string representation.
- ** Usually this is encoded in the same unicode encoding as the main
- ** database (see below for exceptions). If the MEM_Term flag is also
- ** set, then the string is nul terminated. The MEM_Int and MEM_Real
- ** flags may coexist with the MEM_Str flag.
- */
- #define MEM_Null 0x0001 /* Value is NULL */
- #define MEM_Str 0x0002 /* Value is a string */
- #define MEM_Int 0x0004 /* Value is an integer */
- #define MEM_Real 0x0008 /* Value is a real number */
- #define MEM_Blob 0x0010 /* Value is a BLOB */
- #define MEM_RowSet 0x0020 /* Value is a RowSet object */
- #define MEM_Frame 0x0040 /* Value is a VdbeFrame object */
- #define MEM_Invalid 0x0080 /* Value is undefined */
- #define MEM_TypeMask 0x00ff /* Mask of type bits */
- /* Whenever Mem contains a valid string or blob representation, one of
- ** the following flags must be set to determine the memory management
- ** policy for Mem.z. The MEM_Term flag tells us whether or not the
- ** string is \000 or \u0000 terminated
- */
- #define MEM_Term 0x0200 /* String rep is nul terminated */
- #define MEM_Dyn 0x0400 /* Need to call sqliteFree() on Mem.z */
- #define MEM_Static 0x0800 /* Mem.z points to a static string */
- #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
- #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
- #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
- #ifdef SQLITE_OMIT_INCRBLOB
- #undef MEM_Zero
- #define MEM_Zero 0x0000
- #endif
- /*
- ** Clear any existing type flags from a Mem and replace them with f
- */
- #define MemSetTypeFlag(p, f) \
- ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
- /*
- ** Return true if a memory cell is not marked as invalid. This macro
- ** is for use inside assert() statements only.
- */
- #ifdef SQLITE_DEBUG
- #define memIsValid(M) ((M)->flags & MEM_Invalid)==0
- #endif
- /* A VdbeFunc is just a FuncDef (defined in sqliteInt.h) that contains
- ** additional information about auxiliary information bound to arguments
- ** of the function. This is used to implement the sqlite3_get_auxdata()
- ** and sqlite3_set_auxdata() APIs. The "auxdata" is some auxiliary data
- ** that can be associated with a constant argument to a function. This
- ** allows functions such as "regexp" to compile their constant regular
- ** expression argument once and reused the compiled code for multiple
- ** invocations.
- */
- struct VdbeFunc {
- FuncDef *pFunc; /* The definition of the function */
- int nAux; /* Number of entries allocated for apAux[] */
- struct AuxData {
- void *pAux; /* Aux data for the i-th argument */
- void (*xDelete)(void *); /* Destructor for the aux data */
- } apAux[1]; /* One slot for each function argument */
- };
- /*
- ** The "context" argument for a installable function. A pointer to an
- ** instance of this structure is the first argument to the routines used
- ** implement the SQL functions.
- **
- ** There is a typedef for this structure in sqlite.h. So all routines,
- ** even the public interface to SQLite, can use a pointer to this structure.
- ** But this file is the only place where the internal details of this
- ** structure are known.
- **
- ** This structure is defined inside of vdbeInt.h because it uses substructures
- ** (Mem) which are only defined there.
- */
- struct sqlite3_context {
- FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */
- VdbeFunc *pVdbeFunc; /* Auxilary data, if created. */
- Mem s; /* The return value is stored here */
- Mem *pMem; /* Memory cell used to store aggregate context */
- int isError; /* Error code returned by the function. */
- CollSeq *pColl; /* Collating sequence */
- };
- /*
- ** An Explain object accumulates indented output which is helpful
- ** in describing recursive data structures.
- */
- struct Explain {
- Vdbe *pVdbe; /* Attach the explanation to this Vdbe */
- StrAccum str; /* The string being accumulated */
- int nIndent; /* Number of elements in aIndent */
- u16 aIndent[100]; /* Levels of indentation */
- char zBase[100]; /* Initial space */
- };
- /*
- ** An instance of the virtual machine. This structure contains the complete
- ** state of the virtual machine.
- **
- ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
- ** is really a pointer to an instance of this structure.
- **
- ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
- ** any virtual table method invocations made by the vdbe program. It is
- ** set to 2 for xDestroy method calls and 1 for all other methods. This
- ** variable is used for two purposes: to allow xDestroy methods to execute
- ** "DROP TABLE" statements and to prevent some nasty side effects of
- ** malloc failure when SQLite is invoked recursively by a virtual table
- ** method function.
- */
- struct Vdbe {
- sqlite3 *db; /* The database connection that owns this statement */
- Op *aOp; /* Space to hold the virtual machine's program */
- Mem *aMem; /* The memory locations */
- Mem **apArg; /* Arguments to currently executing user function */
- Mem *aColName; /* Column names to return */
- Mem *pResultSet; /* Pointer to an array of results */
- int nMem; /* Number of memory locations currently allocated */
- int nOp; /* Number of instructions in the program */
- int nOpAlloc; /* Number of slots allocated for aOp[] */
- int nLabel; /* Number of labels used */
- int nLabelAlloc; /* Number of slots allocated in aLabel[] */
- int *aLabel; /* Space to hold the labels */
- u16 nResColumn; /* Number of columns in one row of the result set */
- u16 nCursor; /* Number of slots in apCsr[] */
- u32 magic; /* Magic number for sanity checking */
- char *zErrMsg; /* Error message written here */
- Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
- VdbeCursor **apCsr; /* One element of this array for each open cursor */
- Mem *aVar; /* Values for the OP_Variable opcode. */
- char **azVar; /* Name of variables */
- ynVar nVar; /* Number of entries in aVar[] */
- ynVar nzVar; /* Number of entries in azVar[] */
- u32 cacheCtr; /* VdbeCursor row cache generation counter */
- int pc; /* The program counter */
- int rc; /* Value to return */
- u8 errorAction; /* Recovery action to do in case of an error */
- u8 explain; /* True if EXPLAIN present on SQL command */
- u8 changeCntOn; /* True to update the change-counter */
- u8 expired; /* True if the VM needs to be recompiled */
- u8 runOnlyOnce; /* Automatically expire on reset */
- u8 minWriteFileFormat; /* Minimum file format for writable database files */
- u8 inVtabMethod; /* See comments above */
- u8 usesStmtJournal; /* True if uses a statement journal */
- u8 readOnly; /* True for read-only statements */
- u8 isPrepareV2; /* True if prepared with prepare_v2() */
- int nChange; /* Number of db changes made since last reset */
- yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
- yDbMask lockMask; /* Subset of btreeMask that requires a lock */
- int iStatement; /* Statement number (or 0 if has not opened stmt) */
- int aCounter[3]; /* Counters used by sqlite3_stmt_status() */
- #ifndef SQLITE_OMIT_TRACE
- i64 startTime; /* Time when query started - used for profiling */
- #endif
- i64 nFkConstraint; /* Number of imm. FK constraints this VM */
- i64 nStmtDefCons; /* Number of def. constraints when stmt started */
- char *zSql; /* Text of the SQL statement that generated this */
- void *pFree; /* Free this when deleting the vdbe */
- #ifdef SQLITE_DEBUG
- FILE *trace; /* Write an execution trace here, if not NULL */
- #endif
- #ifdef SQLITE_ENABLE_TREE_EXPLAIN
- Explain *pExplain; /* The explainer */
- char *zExplain; /* Explanation of data structures */
- #endif
- VdbeFrame *pFrame; /* Parent frame */
- VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */
- int nFrame; /* Number of frames in pFrame list */
- u32 expmask; /* Binding to these vars invalidates VM */
- SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
- int nOnceFlag; /* Size of array aOnceFlag[] */
- u8 *aOnceFlag; /* Flags for OP_Once */
- };
- /*
- ** The following are allowed values for Vdbe.magic
- */
- #define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */
- #define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */
- #define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */
- #define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */
- /*
- ** Function prototypes
- */
- SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
- void sqliteVdbePopStack(Vdbe*,int);
- SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor*);
- #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
- SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*);
- #endif
- SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
- SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
- SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
- SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
- SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
- int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
- SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(VdbeCursor*,UnpackedRecord*,int*);
- SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor *, i64 *);
- SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
- SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*);
- SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*);
- SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*);
- SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
- SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
- SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
- SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
- SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
- #ifdef SQLITE_OMIT_FLOATING_POINT
- # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
- #else
- SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
- #endif
- SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
- SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
- SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, int);
- SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
- SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
- SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
- SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
- SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
- SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
- #define VdbeMemRelease(X) \
- if((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame)) \
- sqlite3VdbeMemReleaseExternal(X);
- SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
- SQLITE_PRIVATE const char *sqlite3OpcodeName(int);
- SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
- SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
- SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*);
- SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *);
- SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
- SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p);
- #ifdef SQLITE_OMIT_MERGE_SORT
- # define sqlite3VdbeSorterInit(Y,Z) SQLITE_OK
- # define sqlite3VdbeSorterWrite(X,Y,Z) SQLITE_OK
- # define sqlite3VdbeSorterClose(Y,Z)
- # define sqlite3VdbeSorterRowkey(Y,Z) SQLITE_OK
- # define sqlite3VdbeSorterRewind(X,Y,Z) SQLITE_OK
- # define sqlite3VdbeSorterNext(X,Y,Z) SQLITE_OK
- # define sqlite3VdbeSorterCompare(X,Y,Z) SQLITE_OK
- #else
- SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *, VdbeCursor *);
- SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *);
- SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *, Mem *);
- SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, VdbeCursor *, int *);
- SQLITE_PRIVATE int sqlite3VdbeSorterRewind(sqlite3 *, VdbeCursor *, int *);
- SQLITE_PRIVATE int sqlite3VdbeSorterWrite(sqlite3 *, VdbeCursor *, Mem *);
- SQLITE_PRIVATE int sqlite3VdbeSorterCompare(VdbeCursor *, Mem *, int *);
- #endif
- #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
- SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*);
- #else
- # define sqlite3VdbeEnter(X)
- # define sqlite3VdbeLeave(X)
- #endif
- #ifdef SQLITE_DEBUG
- SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
- #endif
- #ifndef SQLITE_OMIT_FOREIGN_KEY
- SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *, int);
- #else
- # define sqlite3VdbeCheckFk(p,i) 0
- #endif
- SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
- #ifdef SQLITE_DEBUG
- SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*);
- SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
- #endif
- SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem);
- #ifndef SQLITE_OMIT_INCRBLOB
- SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *);
- #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
- #else
- #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
- #define ExpandBlob(P) SQLITE_OK
- #endif
- #endif /* !defined(_VDBEINT_H_) */
- /************** End of vdbeInt.h *********************************************/
- /************** Continuing where we left off in status.c *********************/
- /*
- ** Variables in which to record status information.
- */
- typedef struct sqlite3StatType sqlite3StatType;
- static SQLITE_WSD struct sqlite3StatType {
- int nowValue[10]; /* Current value */
- int mxValue[10]; /* Maximum value */
- } sqlite3Stat = { {0,}, {0,} };
- /* The "wsdStat" macro will resolve to the status information
- ** state vector. If writable static data is unsupported on the target,
- ** we have to locate the state vector at run-time. In the more common
- ** case where writable static data is supported, wsdStat can refer directly
- ** to the "sqlite3Stat" state vector declared above.
- */
- #ifdef SQLITE_OMIT_WSD
- # define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat)
- # define wsdStat x[0]
- #else
- # define wsdStatInit
- # define wsdStat sqlite3Stat
- #endif
- /*
- ** Return the current value of a status parameter.
- */
- SQLITE_PRIVATE int sqlite3StatusValue(int op){
- wsdStatInit;
- assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
- return wsdStat.nowValue[op];
- }
- /*
- ** Add N to the value of a status record. It is assumed that the
- ** caller holds appropriate locks.
- */
- SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
- wsdStatInit;
- assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
- wsdStat.nowValue[op] += N;
- if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
- wsdStat.mxValue[op] = wsdStat.nowValue[op];
- }
- }
- /*
- ** Set the value of a status to X.
- */
- SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){
- wsdStatInit;
- assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
- wsdStat.nowValue[op] = X;
- if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
- wsdStat.mxValue[op] = wsdStat.nowValue[op];
- }
- }
- /*
- ** Query status information.
- **
- ** This implementation assumes that reading or writing an aligned
- ** 32-bit integer is an atomic operation. If that assumption is not true,
- ** then this routine is not threadsafe.
- */
- SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
- wsdStatInit;
- if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
- return SQLITE_MISUSE_BKPT;
- }
- *pCurrent = wsdStat.nowValue[op];
- *pHighwater = wsdStat.mxValue[op];
- if( resetFlag ){
- wsdStat.mxValue[op] = wsdStat.nowValue[op];
- }
- return SQLITE_OK;
- }
- /*
- ** Query status information for a single database connection
- */
- SQLITE_API int sqlite3_db_status(
- sqlite3 *db, /* The database connection whose status is desired */
- int op, /* Status verb */
- int *pCurrent, /* Write current value here */
- int *pHighwater, /* Write high-water mark here */
- int resetFlag /* Reset high-water mark if true */
- ){
- int rc = SQLITE_OK; /* Return code */
- sqlite3_mutex_enter(db->mutex);
- switch( op ){
- case SQLITE_DBSTATUS_LOOKASIDE_USED: {
- *pCurrent = db->lookaside.nOut;
- *pHighwater = db->lookaside.mxOut;
- if( resetFlag ){
- db->lookaside.mxOut = db->lookaside.nOut;
- }
- break;
- }
- case SQLITE_DBSTATUS_LOOKASIDE_HIT:
- case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:
- case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {
- testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
- testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
- testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
- assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );
- assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );
- *pCurrent = 0;
- *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
- if( resetFlag ){
- db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
- }
- break;
- }
- /*
- ** Return an approximation for the amount of memory currently used
- ** by all pagers associated with the given database connection. The
- ** highwater mark is meaningless and is returned as zero.
- */
- case SQLITE_DBSTATUS_CACHE_USED: {
- int totalUsed = 0;
- int i;
- sqlite3BtreeEnterAll(db);
- for(i=0; i<db->nDb; i++){
- Btree *pBt = db->aDb[i].pBt;
- if( pBt ){
- Pager *pPager = sqlite3BtreePager(pBt);
- totalUsed += sqlite3PagerMemUsed(pPager);
- }
- }
- sqlite3BtreeLeaveAll(db);
- *pCurrent = totalUsed;
- *pHighwater = 0;
- break;
- }
- /*
- ** *pCurrent gets an accurate estimate of the amount of memory used
- ** to store the schema for all databases (main, temp, and any ATTACHed
- ** databases. *pHighwater is set to zero.
- */
- case SQLITE_DBSTATUS_SCHEMA_USED: {
- int i; /* Used to iterate through schemas */
- int nByte = 0; /* Used to accumulate return value */
- sqlite3BtreeEnterAll(db);
- db->pnBytesFreed = &nByte;
- for(i=0; i<db->nDb; i++){
- Schema *pSchema = db->aDb[i].pSchema;
- if( ALWAYS(pSchema!=0) ){
- HashElem *p;
- nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
- pSchema->tblHash.count
- + pSchema->trigHash.count
- + pSchema->idxHash.count
- + pSchema->fkeyHash.count
- );
- nByte += sqlite3MallocSize(pSchema->tblHash.ht);
- nByte += sqlite3MallocSize(pSchema->trigHash.ht);
- nByte += sqlite3MallocSize(pSchema->idxHash.ht);
- nByte += sqlite3MallocSize(pSchema->fkeyHash.ht);
- for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){
- sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
- }
- for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
- sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
- }
- }
- }
- db->pnBytesFreed = 0;
- sqlite3BtreeLeaveAll(db);
- *pHighwater = 0;
- *pCurrent = nByte;
- break;
- }
- /*
- ** *pCurrent gets an accurate estimate of the amount of memory used
- ** to store all prepared statements.
- ** *pHighwater is set to zero.
- */
- case SQLITE_DBSTATUS_STMT_USED: {
- struct Vdbe *pVdbe; /* Used to iterate through VMs */
- int nByte = 0; /* Used to accumulate return value */
- db->pnBytesFreed = &nByte;
- for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
- sqlite3VdbeDeleteObject(db, pVdbe);
- }
- db->pnBytesFreed = 0;
- *pHighwater = 0;
- *pCurrent = nByte;
- break;
- }
- /*
- ** Set *pCurrent to the total cache hits or misses encountered by all
- ** pagers the database handle is connected to. *pHighwater is always set
- ** to zero.
- */
- case SQLITE_DBSTATUS_CACHE_HIT:
- case SQLITE_DBSTATUS_CACHE_MISS: {
- int i;
- int nRet = 0;
- assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );
- for(i=0; i<db->nDb; i++){
- if( db->aDb[i].pBt ){
- Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
- sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
- }
- }
- *pHighwater = 0;
- *pCurrent = nRet;
- break;
- }
- default: {
- rc = SQLITE_ERROR;
- }
- }
- sqlite3_mutex_leave(db->mutex);
- return rc;
- }
- /************** End of status.c **********************************************/
- /************** Begin file date.c ********************************************/
- /*
- ** 2003 October 31
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement date and time
- ** functions for SQLite.
- **
- ** There is only one exported symbol in this file - the function
- ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
- ** All other code has file scope.
- **
- ** SQLite processes all times and dates as Julian Day numbers. The
- ** dates and times are stored as the number of days since noon
- ** in Greenwich on November 24, 4714 B.C. according to the Gregorian
- ** calendar system.
- **
- ** 1970-01-01 00:00:00 is JD 2440587.5
- ** 2000-01-01 00:00:00 is JD 2451544.5
- **
- ** This implemention requires years to be expressed as a 4-digit number
- ** which means that only dates between 0000-01-01 and 9999-12-31 can
- ** be represented, even though julian day numbers allow a much wider
- ** range of dates.
- **
- ** The Gregorian calendar system is used for all dates and times,
- ** even those that predate the Gregorian calendar. Historians usually
- ** use the Julian calendar for dates prior to 1582-10-15 and for some
- ** dates afterwards, depending on locale. Beware of this difference.
- **
- ** The conversion algorithms are implemented based on descriptions
- ** in the following text:
- **
- ** Jean Meeus
- ** Astronomical Algorithms, 2nd Edition, 1998
- ** ISBM 0-943396-61-1
- ** Willmann-Bell, Inc
- ** Richmond, Virginia (USA)
- */
- /* #include <stdlib.h> */
- /* #include <assert.h> */
- #include <time.h>
- #ifndef SQLITE_OMIT_DATETIME_FUNCS
- /*
- ** A structure for holding a single date and time.
- */
- typedef struct DateTime DateTime;
- struct DateTime {
- sqlite3_int64 iJD; /* The julian day number times 86400000 */
- int Y, M, D; /* Year, month, and day */
- int h, m; /* Hour and minutes */
- int tz; /* Timezone offset in minutes */
- double s; /* Seconds */
- char validYMD; /* True (1) if Y,M,D are valid */
- char validHMS; /* True (1) if h,m,s are valid */
- char validJD; /* True (1) if iJD is valid */
- char validTZ; /* True (1) if tz is valid */
- };
- /*
- ** Convert zDate into one or more integers. Additional arguments
- ** come in groups of 5 as follows:
- **
- ** N number of digits in the integer
- ** min minimum allowed value of the integer
- ** max maximum allowed value of the integer
- ** nextC first character after the integer
- ** pVal where to write the integers value.
- **
- ** Conversions continue until one with nextC==0 is encountered.
- ** The function returns the number of successful conversions.
- */
- static int getDigits(const char *zDate, ...){
- va_list ap;
- int val;
- int N;
- int min;
- int max;
- int nextC;
- int *pVal;
- int cnt = 0;
- va_start(ap, zDate);
- do{
- N = va_arg(ap, int);
- min = va_arg(ap, int);
- max = va_arg(ap, int);
- nextC = va_arg(ap, int);
- pVal = va_arg(ap, int*);
- val = 0;
- while( N-- ){
- if( !sqlite3Isdigit(*zDate) ){
- goto end_getDigits;
- }
- val = val*10 + *zDate - '0';
- zDate++;
- }
- if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
- goto end_getDigits;
- }
- *pVal = val;
- zDate++;
- cnt++;
- }while( nextC );
- end_getDigits:
- va_end(ap);
- return cnt;
- }
- /*
- ** Parse a timezone extension on the end of a date-time.
- ** The extension is of the form:
- **
- ** (+/-)HH:MM
- **
- ** Or the "zulu" notation:
- **
- ** Z
- **
- ** If the parse is successful, write the number of minutes
- ** of change in p->tz and return 0. If a parser error occurs,
- ** return non-zero.
- **
- ** A missing specifier is not considered an error.
- */
- static int parseTimezone(const char *zDate, DateTime *p){
- int sgn = 0;
- int nHr, nMn;
- int c;
- while( sqlite3Isspace(*zDate) ){ zDate++; }
- p->tz = 0;
- c = *zDate;
- if( c=='-' ){
- sgn = -1;
- }else if( c=='+' ){
- sgn = +1;
- }else if( c=='Z' || c=='z' ){
- zDate++;
- goto zulu_time;
- }else{
- return c!=0;
- }
- zDate++;
- if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
- return 1;
- }
- zDate += 5;
- p->tz = sgn*(nMn + nHr*60);
- zulu_time:
- while( sqlite3Isspace(*zDate) ){ zDate++; }
- return *zDate!=0;
- }
- /*
- ** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.
- ** The HH, MM, and SS must each be exactly 2 digits. The
- ** fractional seconds FFFF can be one or more digits.
- **
- ** Return 1 if there is a parsing error and 0 on success.
- */
- static int parseHhMmSs(const char *zDate, DateTime *p){
- int h, m, s;
- double ms = 0.0;
- if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
- return 1;
- }
- zDate += 5;
- if( *zDate==':' ){
- zDate++;
- if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
- return 1;
- }
- zDate += 2;
- if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){
- double rScale = 1.0;
- zDate++;
- while( sqlite3Isdigit(*zDate) ){
- ms = ms*10.0 + *zDate - '0';
- rScale *= 10.0;
- zDate++;
- }
- ms /= rScale;
- }
- }else{
- s = 0;
- }
- p->validJD = 0;
- p->validHMS = 1;
- p->h = h;
- p->m = m;
- p->s = s + ms;
- if( parseTimezone(zDate, p) ) return 1;
- p->validTZ = (p->tz!=0)?1:0;
- return 0;
- }
- /*
- ** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume
- ** that the YYYY-MM-DD is according to the Gregorian calendar.
- **
- ** Reference: Meeus page 61
- */
- static void computeJD(DateTime *p){
- int Y, M, D, A, B, X1, X2;
- if( p->validJD ) return;
- if( p->validYMD ){
- Y = p->Y;
- M = p->M;
- D = p->D;
- }else{
- Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */
- M = 1;
- D = 1;
- }
- if( M<=2 ){
- Y--;
- M += 12;
- }
- A = Y/100;
- B = 2 - A + (A/4);
- X1 = 36525*(Y+4716)/100;
- X2 = 306001*(M+1)/10000;
- p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
- p->validJD = 1;
- if( p->validHMS ){
- p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000);
- if( p->validTZ ){
- p->iJD -= p->tz*60000;
- p->validYMD = 0;
- p->validHMS = 0;
- p->validTZ = 0;
- }
- }
- }
- /*
- ** Parse dates of the form
- **
- ** YYYY-MM-DD HH:MM:SS.FFF
- ** YYYY-MM-DD HH:MM:SS
- ** YYYY-MM-DD HH:MM
- ** YYYY-MM-DD
- **
- ** Write the result into the DateTime structure and return 0
- ** on success and 1 if the input string is not a well-formed
- ** date.
- */
- static int parseYyyyMmDd(const char *zDate, DateTime *p){
- int Y, M, D, neg;
- if( zDate[0]=='-' ){
- zDate++;
- neg = 1;
- }else{
- neg = 0;
- }
- if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
- return 1;
- }
- zDate += 10;
- while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }
- if( parseHhMmSs(zDate, p)==0 ){
- /* We got the time */
- }else if( *zDate==0 ){
- p->validHMS = 0;
- }else{
- return 1;
- }
- p->validJD = 0;
- p->validYMD = 1;
- p->Y = neg ? -Y : Y;
- p->M = M;
- p->D = D;
- if( p->validTZ ){
- computeJD(p);
- }
- return 0;
- }
- /*
- ** Set the time to the current time reported by the VFS.
- **
- ** Return the number of errors.
- */
- static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
- sqlite3 *db = sqlite3_context_db_handle(context);
- if( sqlite3OsCurrentTimeInt64(db->pVfs, &p->iJD)==SQLITE_OK ){
- p->validJD = 1;
- return 0;
- }else{
- return 1;
- }
- }
- /*
- ** Attempt to parse the given string into a Julian Day Number. Return
- ** the number of errors.
- **
- ** The following are acceptable forms for the input string:
- **
- ** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM
- ** DDDD.DD
- ** now
- **
- ** In the first form, the +/-HH:MM is always optional. The fractional
- ** seconds extension (the ".FFF") is optional. The seconds portion
- ** (":SS.FFF") is option. The year and date can be omitted as long
- ** as there is a time string. The time string can be omitted as long
- ** as there is a year and date.
- */
- static int parseDateOrTime(
- sqlite3_context *context,
- const char *zDate,
- DateTime *p
- ){
- double r;
- if( parseYyyyMmDd(zDate,p)==0 ){
- return 0;
- }else if( parseHhMmSs(zDate, p)==0 ){
- return 0;
- }else if( sqlite3StrICmp(zDate,"now")==0){
- return setDateTimeToCurrent(context, p);
- }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){
- p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);
- p->validJD = 1;
- return 0;
- }
- return 1;
- }
- /*
- ** Compute the Year, Month, and Day from the julian day number.
- */
- static void computeYMD(DateTime *p){
- int Z, A, B, C, D, E, X1;
- if( p->validYMD ) return;
- if( !p->validJD ){
- p->Y = 2000;
- p->M = 1;
- p->D = 1;
- }else{
- Z = (int)((p->iJD + 43200000)/86400000);
- A = (int)((Z - 1867216.25)/36524.25);
- A = Z + 1 + A - (A/4);
- B = A + 1524;
- C = (int)((B - 122.1)/365.25);
- D = (36525*C)/100;
- E = (int)((B-D)/30.6001);
- X1 = (int)(30.6001*E);
- p->D = B - D - X1;
- p->M = E<14 ? E-1 : E-13;
- p->Y = p->M>2 ? C - 4716 : C - 4715;
- }
- p->validYMD = 1;
- }
- /*
- ** Compute the Hour, Minute, and Seconds from the julian day number.
- */
- static void computeHMS(DateTime *p){
- int s;
- if( p->validHMS ) return;
- computeJD(p);
- s = (int)((p->iJD + 43200000) % 86400000);
- p->s = s/1000.0;
- s = (int)p->s;
- p->s -= s;
- p->h = s/3600;
- s -= p->h*3600;
- p->m = s/60;
- p->s += s - p->m*60;
- p->validHMS = 1;
- }
- /*
- ** Compute both YMD and HMS
- */
- static void computeYMD_HMS(DateTime *p){
- computeYMD(p);
- computeHMS(p);
- }
- /*
- ** Clear the YMD and HMS and the TZ
- */
- static void clearYMD_HMS_TZ(DateTime *p){
- p->validYMD = 0;
- p->validHMS = 0;
- p->validTZ = 0;
- }
- /*
- ** On recent Windows platforms, the localtime_s() function is available
- ** as part of the "Secure CRT". It is essentially equivalent to
- ** localtime_r() available under most POSIX platforms, except that the
- ** order of the parameters is reversed.
- **
- ** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx.
- **
- ** If the user has not indicated to use localtime_r() or localtime_s()
- ** already, check for an MSVC build environment that provides
- ** localtime_s().
- */
- #if !defined(HAVE_LOCALTIME_R) && !defined(HAVE_LOCALTIME_S) && \
- defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE)
- #define HAVE_LOCALTIME_S 1
- #endif
- #ifndef SQLITE_OMIT_LOCALTIME
- /*
- ** The following routine implements the rough equivalent of localtime_r()
- ** using whatever operating-system specific localtime facility that
- ** is available. This routine returns 0 on success and
- ** non-zero on any kind of error.
- **
- ** If the sqlite3GlobalConfig.bLocaltimeFault variable is true then this
- ** routine will always fail.
- */
- static int osLocaltime(time_t *t, struct tm *pTm){
- int rc;
- #if (!defined(HAVE_LOCALTIME_R) || !HAVE_LOCALTIME_R) \
- && (!defined(HAVE_LOCALTIME_S) || !HAVE_LOCALTIME_S)
- struct tm *pX;
- #if SQLITE_THREADSAFE>0
- sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
- #endif
- sqlite3_mutex_enter(mutex);
- pX = localtime(t);
- #ifndef SQLITE_OMIT_BUILTIN_TEST
- if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0;
- #endif
- if( pX ) *pTm = *pX;
- sqlite3_mutex_leave(mutex);
- rc = pX==0;
- #else
- #ifndef SQLITE_OMIT_BUILTIN_TEST
- if( sqlite3GlobalConfig.bLocaltimeFault ) return 1;
- #endif
- #if defined(HAVE_LOCALTIME_R) && HAVE_LOCALTIME_R
- rc = localtime_r(t, pTm)==0;
- #else
- rc = localtime_s(pTm, t);
- #endif /* HAVE_LOCALTIME_R */
- #endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */
- return rc;
- }
- #endif /* SQLITE_OMIT_LOCALTIME */
- #ifndef SQLITE_OMIT_LOCALTIME
- /*
- ** Compute the difference (in milliseconds) between localtime and UTC
- ** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs,
- ** return this value and set *pRc to SQLITE_OK.
- **
- ** Or, if an error does occur, set *pRc to SQLITE_ERROR. The returned value
- ** is undefined in this case.
- */
- static sqlite3_int64 localtimeOffset(
- DateTime *p, /* Date at which to calculate offset */
- sqlite3_context *pCtx, /* Write error here if one occurs */
- int *pRc /* OUT: Error code. SQLITE_OK or ERROR */
- ){
- DateTime x, y;
- time_t t;
- struct tm sLocal;
- /* Initialize the contents of sLocal to avoid a compiler warning. */
- memset(&sLocal, 0, sizeof(sLocal));
- x = *p;
- computeYMD_HMS(&x);
- if( x.Y<1971 || x.Y>=2038 ){
- x.Y = 2000;
- x.M = 1;
- x.D = 1;
- x.h = 0;
- x.m = 0;
- x.s = 0.0;
- } else {
- int s = (int)(x.s + 0.5);
- x.s = s;
- }
- x.tz = 0;
- x.validJD = 0;
- computeJD(&x);
- t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
- if( osLocaltime(&t, &sLocal) ){
- sqlite3_result_error(pCtx, "local time unavailable", -1);
- *pRc = SQLITE_ERROR;
- return 0;
- }
- y.Y = sLocal.tm_year + 1900;
- y.M = sLocal.tm_mon + 1;
- y.D = sLocal.tm_mday;
- y.h = sLocal.tm_hour;
- y.m = sLocal.tm_min;
- y.s = sLocal.tm_sec;
- y.validYMD = 1;
- y.validHMS = 1;
- y.validJD = 0;
- y.validTZ = 0;
- computeJD(&y);
- *pRc = SQLITE_OK;
- return y.iJD - x.iJD;
- }
- #endif /* SQLITE_OMIT_LOCALTIME */
- /*
- ** Process a modifier to a date-time stamp. The modifiers are
- ** as follows:
- **
- ** NNN days
- ** NNN hours
- ** NNN minutes
- ** NNN.NNNN seconds
- ** NNN months
- ** NNN years
- ** start of month
- ** start of year
- ** start of week
- ** start of day
- ** weekday N
- ** unixepoch
- ** localtime
- ** utc
- **
- ** Return 0 on success and 1 if there is any kind of error. If the error
- ** is in a system call (i.e. localtime()), then an error message is written
- ** to context pCtx. If the error is an unrecognized modifier, no error is
- ** written to pCtx.
- */
- static int parseModifier(sqlite3_context *pCtx, const char *zMod, DateTime *p){
- int rc = 1;
- int n;
- double r;
- char *z, zBuf[30];
- z = zBuf;
- for(n=0; n<ArraySize(zBuf)-1 && zMod[n]; n++){
- z[n] = (char)sqlite3UpperToLower[(u8)zMod[n]];
- }
- z[n] = 0;
- switch( z[0] ){
- #ifndef SQLITE_OMIT_LOCALTIME
- case 'l': {
- /* localtime
- **
- ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
- ** show local time.
- */
- if( strcmp(z, "localtime")==0 ){
- computeJD(p);
- p->iJD += localtimeOffset(p, pCtx, &rc);
- clearYMD_HMS_TZ(p);
- }
- break;
- }
- #endif
- case 'u': {
- /*
- ** unixepoch
- **
- ** Treat the current value of p->iJD as the number of
- ** seconds since 1970. Convert to a real julian day number.
- */
- if( strcmp(z, "unixepoch")==0 && p->validJD ){
- p->iJD = (p->iJD + 43200)/86400 + 21086676*(i64)10000000;
- clearYMD_HMS_TZ(p);
- rc = 0;
- }
- #ifndef SQLITE_OMIT_LOCALTIME
- else if( strcmp(z, "utc")==0 ){
- sqlite3_int64 c1;
- computeJD(p);
- c1 = localtimeOffset(p, pCtx, &rc);
- if( rc==SQLITE_OK ){
- p->iJD -= c1;
- clearYMD_HMS_TZ(p);
- p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
- }
- }
- #endif
- break;
- }
- case 'w': {
- /*
- ** weekday N
- **
- ** Move the date to the same time on the next occurrence of
- ** weekday N where 0==Sunday, 1==Monday, and so forth. If the
- ** date is already on the appropriate weekday, this is a no-op.
- */
- if( strncmp(z, "weekday ", 8)==0
- && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)
- && (n=(int)r)==r && n>=0 && r<7 ){
- sqlite3_int64 Z;
- computeYMD_HMS(p);
- p->validTZ = 0;
- p->validJD = 0;
- computeJD(p);
- Z = ((p->iJD + 129600000)/86400000) % 7;
- if( Z>n ) Z -= 7;
- p->iJD += (n - Z)*86400000;
- clearYMD_HMS_TZ(p);
- rc = 0;
- }
- break;
- }
- case 's': {
- /*
- ** start of TTTTT
- **
- ** Move the date backwards to the beginning of the current day,
- ** or month or year.
- */
- if( strncmp(z, "start of ", 9)!=0 ) break;
- z += 9;
- computeYMD(p);
- p->validHMS = 1;
- p->h = p->m = 0;
- p->s = 0.0;
- p->validTZ = 0;
- p->validJD = 0;
- if( strcmp(z,"month")==0 ){
- p->D = 1;
- rc = 0;
- }else if( strcmp(z,"year")==0 ){
- computeYMD(p);
- p->M = 1;
- p->D = 1;
- rc = 0;
- }else if( strcmp(z,"day")==0 ){
- rc = 0;
- }
- break;
- }
- case '+':
- case '-':
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9': {
- double rRounder;
- for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){}
- if( !sqlite3AtoF(z, &r, n, SQLITE_UTF8) ){
- rc = 1;
- break;
- }
- if( z[n]==':' ){
- /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the
- ** specified number of hours, minutes, seconds, and fractional seconds
- ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be
- ** omitted.
- */
- const char *z2 = z;
- DateTime tx;
- sqlite3_int64 day;
- if( !sqlite3Isdigit(*z2) ) z2++;
- memset(&tx, 0, sizeof(tx));
- if( parseHhMmSs(z2, &tx) ) break;
- computeJD(&tx);
- tx.iJD -= 43200000;
- day = tx.iJD/86400000;
- tx.iJD -= day*86400000;
- if( z[0]=='-' ) tx.iJD = -tx.iJD;
- computeJD(p);
- clearYMD_HMS_TZ(p);
- p->iJD += tx.iJD;
- rc = 0;
- break;
- }
- z += n;
- while( sqlite3Isspace(*z) ) z++;
- n = sqlite3Strlen30(z);
- if( n>10 || n<3 ) break;
- if( z[n-1]=='s' ){ z[n-1] = 0; n--; }
- computeJD(p);
- rc = 0;
- rRounder = r<0 ? -0.5 : +0.5;
- if( n==3 && strcmp(z,"day")==0 ){
- p->iJD += (sqlite3_int64)(r*86400000.0 + rRounder);
- }else if( n==4 && strcmp(z,"hour")==0 ){
- p->iJD += (sqlite3_int64)(r*(86400000.0/24.0) + rRounder);
- }else if( n==6 && strcmp(z,"minute")==0 ){
- p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0)) + rRounder);
- }else if( n==6 && strcmp(z,"second")==0 ){
- p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0*60.0)) + rRounder);
- }else if( n==5 && strcmp(z,"month")==0 ){
- int x, y;
- computeYMD_HMS(p);
- p->M += (int)r;
- x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
- p->Y += x;
- p->M -= x*12;
- p->validJD = 0;
- computeJD(p);
- y = (int)r;
- if( y!=r ){
- p->iJD += (sqlite3_int64)((r - y)*30.0*86400000.0 + rRounder);
- }
- }else if( n==4 && strcmp(z,"year")==0 ){
- int y = (int)r;
- computeYMD_HMS(p);
- p->Y += y;
- p->validJD = 0;
- computeJD(p);
- if( y!=r ){
- p->iJD += (sqlite3_int64)((r - y)*365.0*86400000.0 + rRounder);
- }
- }else{
- rc = 1;
- }
- clearYMD_HMS_TZ(p);
- break;
- }
- default: {
- break;
- }
- }
- return rc;
- }
- /*
- ** Process time function arguments. argv[0] is a date-time stamp.
- ** argv[1] and following are modifiers. Parse them all and write
- ** the resulting time into the DateTime structure p. Return 0
- ** on success and 1 if there are any errors.
- **
- ** If there are zero parameters (if even argv[0] is undefined)
- ** then assume a default value of "now" for argv[0].
- */
- static int isDate(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv,
- DateTime *p
- ){
- int i;
- const unsigned char *z;
- int eType;
- memset(p, 0, sizeof(*p));
- if( argc==0 ){
- return setDateTimeToCurrent(context, p);
- }
- if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT
- || eType==SQLITE_INTEGER ){
- p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5);
- p->validJD = 1;
- }else{
- z = sqlite3_value_text(argv[0]);
- if( !z || parseDateOrTime(context, (char*)z, p) ){
- return 1;
- }
- }
- for(i=1; i<argc; i++){
- z = sqlite3_value_text(argv[i]);
- if( z==0 || parseModifier(context, (char*)z, p) ) return 1;
- }
- return 0;
- }
- /*
- ** The following routines implement the various date and time functions
- ** of SQLite.
- */
- /*
- ** julianday( TIMESTRING, MOD, MOD, ...)
- **
- ** Return the julian day number of the date specified in the arguments
- */
- static void juliandayFunc(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv
- ){
- DateTime x;
- if( isDate(context, argc, argv, &x)==0 ){
- computeJD(&x);
- sqlite3_result_double(context, x.iJD/86400000.0);
- }
- }
- /*
- ** datetime( TIMESTRING, MOD, MOD, ...)
- **
- ** Return YYYY-MM-DD HH:MM:SS
- */
- static void datetimeFunc(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv
- ){
- DateTime x;
- if( isDate(context, argc, argv, &x)==0 ){
- char zBuf[100];
- computeYMD_HMS(&x);
- sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
- x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
- sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
- }
- }
- /*
- ** time( TIMESTRING, MOD, MOD, ...)
- **
- ** Return HH:MM:SS
- */
- static void timeFunc(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv
- ){
- DateTime x;
- if( isDate(context, argc, argv, &x)==0 ){
- char zBuf[100];
- computeHMS(&x);
- sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
- sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
- }
- }
- /*
- ** date( TIMESTRING, MOD, MOD, ...)
- **
- ** Return YYYY-MM-DD
- */
- static void dateFunc(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv
- ){
- DateTime x;
- if( isDate(context, argc, argv, &x)==0 ){
- char zBuf[100];
- computeYMD(&x);
- sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
- sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
- }
- }
- /*
- ** strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
- **
- ** Return a string described by FORMAT. Conversions as follows:
- **
- ** %d day of month
- ** %f ** fractional seconds SS.SSS
- ** %H hour 00-24
- ** %j day of year 000-366
- ** %J ** Julian day number
- ** %m month 01-12
- ** %M minute 00-59
- ** %s seconds since 1970-01-01
- ** %S seconds 00-59
- ** %w day of week 0-6 sunday==0
- ** %W week of year 00-53
- ** %Y year 0000-9999
- ** %% %
- */
- static void strftimeFunc(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv
- ){
- DateTime x;
- u64 n;
- size_t i,j;
- char *z;
- sqlite3 *db;
- const char *zFmt = (const char*)sqlite3_value_text(argv[0]);
- char zBuf[100];
- if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
- db = sqlite3_context_db_handle(context);
- for(i=0, n=1; zFmt[i]; i++, n++){
- if( zFmt[i]=='%' ){
- switch( zFmt[i+1] ){
- case 'd':
- case 'H':
- case 'm':
- case 'M':
- case 'S':
- case 'W':
- n++;
- /* fall thru */
- case 'w':
- case '%':
- break;
- case 'f':
- n += 8;
- break;
- case 'j':
- n += 3;
- break;
- case 'Y':
- n += 8;
- break;
- case 's':
- case 'J':
- n += 50;
- break;
- default:
- return; /* ERROR. return a NULL */
- }
- i++;
- }
- }
- testcase( n==sizeof(zBuf)-1 );
- testcase( n==sizeof(zBuf) );
- testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
- testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
- if( n<sizeof(zBuf) ){
- z = zBuf;
- }else if( n>(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){
- sqlite3_result_error_toobig(context);
- return;
- }else{
- z = sqlite3DbMallocRaw(db, (int)n);
- if( z==0 ){
- sqlite3_result_error_nomem(context);
- return;
- }
- }
- computeJD(&x);
- computeYMD_HMS(&x);
- for(i=j=0; zFmt[i]; i++){
- if( zFmt[i]!='%' ){
- z[j++] = zFmt[i];
- }else{
- i++;
- switch( zFmt[i] ){
- case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
- case 'f': {
- double s = x.s;
- if( s>59.999 ) s = 59.999;
- sqlite3_snprintf(7, &z[j],"%06.3f", s);
- j += sqlite3Strlen30(&z[j]);
- break;
- }
- case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
- case 'W': /* Fall thru */
- case 'j': {
- int nDay; /* Number of days since 1st day of year */
- DateTime y = x;
- y.validJD = 0;
- y.M = 1;
- y.D = 1;
- computeJD(&y);
- nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
- if( zFmt[i]=='W' ){
- int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */
- wd = (int)(((x.iJD+43200000)/86400000)%7);
- sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
- j += 2;
- }else{
- sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
- j += 3;
- }
- break;
- }
- case 'J': {
- sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0);
- j+=sqlite3Strlen30(&z[j]);
- break;
- }
- case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
- case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
- case 's': {
- sqlite3_snprintf(30,&z[j],"%lld",
- (i64)(x.iJD/1000 - 21086676*(i64)10000));
- j += sqlite3Strlen30(&z[j]);
- break;
- }
- case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
- case 'w': {
- z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
- break;
- }
- case 'Y': {
- sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
- break;
- }
- default: z[j++] = '%'; break;
- }
- }
- }
- z[j] = 0;
- sqlite3_result_text(context, z, -1,
- z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC);
- }
- /*
- ** current_time()
- **
- ** This function returns the same value as time('now').
- */
- static void ctimeFunc(
- sqlite3_context *context,
- int NotUsed,
- sqlite3_value **NotUsed2
- ){
- UNUSED_PARAMETER2(NotUsed, NotUsed2);
- timeFunc(context, 0, 0);
- }
- /*
- ** current_date()
- **
- ** This function returns the same value as date('now').
- */
- static void cdateFunc(
- sqlite3_context *context,
- int NotUsed,
- sqlite3_value **NotUsed2
- ){
- UNUSED_PARAMETER2(NotUsed, NotUsed2);
- dateFunc(context, 0, 0);
- }
- /*
- ** current_timestamp()
- **
- ** This function returns the same value as datetime('now').
- */
- static void ctimestampFunc(
- sqlite3_context *context,
- int NotUsed,
- sqlite3_value **NotUsed2
- ){
- UNUSED_PARAMETER2(NotUsed, NotUsed2);
- datetimeFunc(context, 0, 0);
- }
- #endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */
- #ifdef SQLITE_OMIT_DATETIME_FUNCS
- /*
- ** If the library is compiled to omit the full-scale date and time
- ** handling (to get a smaller binary), the following minimal version
- ** of the functions current_time(), current_date() and current_timestamp()
- ** are included instead. This is to support column declarations that
- ** include "DEFAULT CURRENT_TIME" etc.
- **
- ** This function uses the C-library functions time(), gmtime()
- ** and strftime(). The format string to pass to strftime() is supplied
- ** as the user-data for the function.
- */
- static void currentTimeFunc(
- sqlite3_context *context,
- int argc,
- sqlite3_value **argv
- ){
- time_t t;
- char *zFormat = (char *)sqlite3_user_data(context);
- sqlite3 *db;
- sqlite3_int64 iT;
- struct tm *pTm;
- struct tm sNow;
- char zBuf[20];
- UNUSED_PARAMETER(argc);
- UNUSED_PARAMETER(argv);
- db = sqlite3_context_db_handle(context);
- if( sqlite3OsCurrentTimeInt64(db->pVfs, &iT) ) return;
- t = iT/1000 - 10000*(sqlite3_int64)21086676;
- #ifdef HAVE_GMTIME_R
- pTm = gmtime_r(&t, &sNow);
- #else
- sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- pTm = gmtime(&t);
- if( pTm ) memcpy(&sNow, pTm, sizeof(sNow));
- sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- #endif
- if( pTm ){
- strftime(zBuf, 20, zFormat, &sNow);
- sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
- }
- }
- #endif
- /*
- ** This function registered all of the above C functions as SQL
- ** functions. This should be the only routine in this file with
- ** external linkage.
- */
- SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
- static SQLITE_WSD FuncDef aDateTimeFuncs[] = {
- #ifndef SQLITE_OMIT_DATETIME_FUNCS
- FUNCTION(julianday, -1, 0, 0, juliandayFunc ),
- FUNCTION(date, -1, 0, 0, dateFunc ),
- FUNCTION(time, -1, 0, 0, timeFunc ),
- FUNCTION(datetime, -1, 0, 0, datetimeFunc ),
- FUNCTION(strftime, -1, 0, 0, strftimeFunc ),
- FUNCTION(current_time, 0, 0, 0, ctimeFunc ),
- FUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
- FUNCTION(current_date, 0, 0, 0, cdateFunc ),
- #else
- STR_FUNCTION(current_time, 0, "%H:%M:%S", 0, currentTimeFunc),
- STR_FUNCTION(current_date, 0, "%Y-%m-%d", 0, currentTimeFunc),
- STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc),
- #endif
- };
- int i;
- FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
- FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aDateTimeFuncs);
- for(i=0; i<ArraySize(aDateTimeFuncs); i++){
- sqlite3FuncDefInsert(pHash, &aFunc[i]);
- }
- }
- /************** End of date.c ************************************************/
- /************** Begin file os.c **********************************************/
- /*
- ** 2005 November 29
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains OS interface code that is common to all
- ** architectures.
- */
- #define _SQLITE_OS_C_ 1
- #undef _SQLITE_OS_C_
- /*
- ** The default SQLite sqlite3_vfs implementations do not allocate
- ** memory (actually, os_unix.c allocates a small amount of memory
- ** from within OsOpen()), but some third-party implementations may.
- ** So we test the effects of a malloc() failing and the sqlite3OsXXX()
- ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
- **
- ** The following functions are instrumented for malloc() failure
- ** testing:
- **
- ** sqlite3OsRead()
- ** sqlite3OsWrite()
- ** sqlite3OsSync()
- ** sqlite3OsFileSize()
- ** sqlite3OsLock()
- ** sqlite3OsCheckReservedLock()
- ** sqlite3OsFileControl()
- ** sqlite3OsShmMap()
- ** sqlite3OsOpen()
- ** sqlite3OsDelete()
- ** sqlite3OsAccess()
- ** sqlite3OsFullPathname()
- **
- */
- #if defined(SQLITE_TEST)
- SQLITE_API int sqlite3_memdebug_vfs_oom_test = 1;
- #define DO_OS_MALLOC_TEST(x) \
- if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3IsMemJournal(x))) { \
- void *pTstAlloc = sqlite3Malloc(10); \
- if (!pTstAlloc) return SQLITE_IOERR_NOMEM; \
- sqlite3_free(pTstAlloc); \
- }
- #else
- #define DO_OS_MALLOC_TEST(x)
- #endif
- /*
- ** The following routines are convenience wrappers around methods
- ** of the sqlite3_file object. This is mostly just syntactic sugar. All
- ** of this would be completely automatic if SQLite were coded using
- ** C++ instead of plain old C.
- */
- SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file *pId){
- int rc = SQLITE_OK;
- if( pId->pMethods ){
- rc = pId->pMethods->xClose(pId);
- pId->pMethods = 0;
- }
- return rc;
- }
- SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xRead(id, pBuf, amt, offset);
- }
- SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xWrite(id, pBuf, amt, offset);
- }
- SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file *id, i64 size){
- return id->pMethods->xTruncate(id, size);
- }
- SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xSync(id, flags);
- }
- SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xFileSize(id, pSize);
- }
- SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file *id, int lockType){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xLock(id, lockType);
- }
- SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file *id, int lockType){
- return id->pMethods->xUnlock(id, lockType);
- }
- SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xCheckReservedLock(id, pResOut);
- }
- /*
- ** Use sqlite3OsFileControl() when we are doing something that might fail
- ** and we need to know about the failures. Use sqlite3OsFileControlHint()
- ** when simply tossing information over the wall to the VFS and we do not
- ** really care if the VFS receives and understands the information since it
- ** is only a hint and can be safely ignored. The sqlite3OsFileControlHint()
- ** routine has no return value since the return value would be meaningless.
- */
- SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xFileControl(id, op, pArg);
- }
- SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){
- (void)id->pMethods->xFileControl(id, op, pArg);
- }
- SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){
- int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
- return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
- }
- SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
- return id->pMethods->xDeviceCharacteristics(id);
- }
- SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
- return id->pMethods->xShmLock(id, offset, n, flags);
- }
- SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){
- id->pMethods->xShmBarrier(id);
- }
- SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){
- return id->pMethods->xShmUnmap(id, deleteFlag);
- }
- SQLITE_PRIVATE int sqlite3OsShmMap(
- sqlite3_file *id, /* Database file handle */
- int iPage,
- int pgsz,
- int bExtend, /* True to extend file if necessary */
- void volatile **pp /* OUT: Pointer to mapping */
- ){
- DO_OS_MALLOC_TEST(id);
- return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
- }
- /*
- ** The next group of routines are convenience wrappers around the
- ** VFS methods.
- */
- SQLITE_PRIVATE int sqlite3OsOpen(
- sqlite3_vfs *pVfs,
- const char *zPath,
- sqlite3_file *pFile,
- int flags,
- int *pFlagsOut
- ){
- int rc;
- DO_OS_MALLOC_TEST(0);
- /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
- ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
- ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
- ** reaching the VFS. */
- rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
- assert( rc==SQLITE_OK || pFile->pMethods==0 );
- return rc;
- }
- SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
- DO_OS_MALLOC_TEST(0);
- assert( dirSync==0 || dirSync==1 );
- return pVfs->xDelete(pVfs, zPath, dirSync);
- }
- SQLITE_PRIVATE int sqlite3OsAccess(
- sqlite3_vfs *pVfs,
- const char *zPath,
- int flags,
- int *pResOut
- ){
- DO_OS_MALLOC_TEST(0);
- return pVfs->xAccess(pVfs, zPath, flags, pResOut);
- }
- SQLITE_PRIVATE int sqlite3OsFullPathname(
- sqlite3_vfs *pVfs,
- const char *zPath,
- int nPathOut,
- char *zPathOut
- ){
- DO_OS_MALLOC_TEST(0);
- zPathOut[0] = 0;
- return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
- }
- #ifndef SQLITE_OMIT_LOAD_EXTENSION
- SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
- return pVfs->xDlOpen(pVfs, zPath);
- }
- SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
- pVfs->xDlError(pVfs, nByte, zBufOut);
- }
- SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){
- return pVfs->xDlSym(pVfs, pHdle, zSym);
- }
- SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
- pVfs->xDlClose(pVfs, pHandle);
- }
- #endif /* SQLITE_OMIT_LOAD_EXTENSION */
- SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
- return pVfs->xRandomness(pVfs, nByte, zBufOut);
- }
- SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
- return pVfs->xSleep(pVfs, nMicro);
- }
- SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
- int rc;
- /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
- ** method to get the current date and time if that method is available
- ** (if iVersion is 2 or greater and the function pointer is not NULL) and
- ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
- ** unavailable.
- */
- if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
- rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
- }else{
- double r;
- rc = pVfs->xCurrentTime(pVfs, &r);
- *pTimeOut = (sqlite3_int64)(r*86400000.0);
- }
- return rc;
- }
- SQLITE_PRIVATE int sqlite3OsOpenMalloc(
- sqlite3_vfs *pVfs,
- const char *zFile,
- sqlite3_file **ppFile,
- int flags,
- int *pOutFlags
- ){
- int rc = SQLITE_NOMEM;
- sqlite3_file *pFile;
- pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
- if( pFile ){
- rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
- if( rc!=SQLITE_OK ){
- sqlite3_free(pFile);
- }else{
- *ppFile = pFile;
- }
- }
- return rc;
- }
- SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *pFile){
- int rc = SQLITE_OK;
- assert( pFile );
- rc = sqlite3OsClose(pFile);
- sqlite3_free(pFile);
- return rc;
- }
- /*
- ** This function is a wrapper around the OS specific implementation of
- ** sqlite3_os_init(). The purpose of the wrapper is to provide the
- ** ability to simulate a malloc failure, so that the handling of an
- ** error in sqlite3_os_init() by the upper layers can be tested.
- */
- SQLITE_PRIVATE int sqlite3OsInit(void){
- void *p = sqlite3_malloc(10);
- if( p==0 ) return SQLITE_NOMEM;
- sqlite3_free(p);
- return sqlite3_os_init();
- }
- /*
- ** The list of all registered VFS implementations.
- */
- static sqlite3_vfs * SQLITE_WSD vfsList = 0;
- #define vfsList GLOBAL(sqlite3_vfs *, vfsList)
- /*
- ** Locate a VFS by name. If no name is given, simply return the
- ** first VFS on the list.
- */
- SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
- sqlite3_vfs *pVfs = 0;
- #if SQLITE_THREADSAFE
- sqlite3_mutex *mutex;
- #endif
- #ifndef SQLITE_OMIT_AUTOINIT
- int rc = sqlite3_initialize();
- if( rc ) return 0;
- #endif
- #if SQLITE_THREADSAFE
- mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
- #endif
- sqlite3_mutex_enter(mutex);
- for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
- if( zVfs==0 ) break;
- if( strcmp(zVfs, pVfs->zName)==0 ) break;
- }
- sqlite3_mutex_leave(mutex);
- return pVfs;
- }
- /*
- ** Unlink a VFS from the linked list
- */
- static void vfsUnlink(sqlite3_vfs *pVfs){
- assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
- if( pVfs==0 ){
- /* No-op */
- }else if( vfsList==pVfs ){
- vfsList = pVfs->pNext;
- }else if( vfsList ){
- sqlite3_vfs *p = vfsList;
- while( p->pNext && p->pNext!=pVfs ){
- p = p->pNext;
- }
- if( p->pNext==pVfs ){
- p->pNext = pVfs->pNext;
- }
- }
- }
- /*
- ** Register a VFS with the system. It is harmless to register the same
- ** VFS multiple times. The new VFS becomes the default if makeDflt is
- ** true.
- */
- SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
- MUTEX_LOGIC(sqlite3_mutex *mutex;)
- #ifndef SQLITE_OMIT_AUTOINIT
- int rc = sqlite3_initialize();
- if( rc ) return rc;
- #endif
- MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
- sqlite3_mutex_enter(mutex);
- vfsUnlink(pVfs);
- if( makeDflt || vfsList==0 ){
- pVfs->pNext = vfsList;
- vfsList = pVfs;
- }else{
- pVfs->pNext = vfsList->pNext;
- vfsList->pNext = pVfs;
- }
- assert(vfsList);
- sqlite3_mutex_leave(mutex);
- return SQLITE_OK;
- }
- /*
- ** Unregister a VFS so that it is no longer accessible.
- */
- SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
- #if SQLITE_THREADSAFE
- sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
- #endif
- sqlite3_mutex_enter(mutex);
- vfsUnlink(pVfs);
- sqlite3_mutex_leave(mutex);
- return SQLITE_OK;
- }
- /************** End of os.c **************************************************/
- /************** Begin file fault.c *******************************************/
- /*
- ** 2008 Jan 22
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains code to support the concept of "benign"
- ** malloc failures (when the xMalloc() or xRealloc() method of the
- ** sqlite3_mem_methods structure fails to allocate a block of memory
- ** and returns 0).
- **
- ** Most malloc failures are non-benign. After they occur, SQLite
- ** abandons the current operation and returns an error code (usually
- ** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily
- ** fatal. For example, if a malloc fails while resizing a hash table, this
- ** is completely recoverable simply by not carrying out the resize. The
- ** hash table will continue to function normally. So a malloc failure
- ** during a hash table resize is a benign fault.
- */
- #ifndef SQLITE_OMIT_BUILTIN_TEST
- /*
- ** Global variables.
- */
- typedef struct BenignMallocHooks BenignMallocHooks;
- static SQLITE_WSD struct BenignMallocHooks {
- void (*xBenignBegin)(void);
- void (*xBenignEnd)(void);
- } sqlite3Hooks = { 0, 0 };
- /* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks
- ** structure. If writable static data is unsupported on the target,
- ** we have to locate the state vector at run-time. In the more common
- ** case where writable static data is supported, wsdHooks can refer directly
- ** to the "sqlite3Hooks" state vector declared above.
- */
- #ifdef SQLITE_OMIT_WSD
- # define wsdHooksInit \
- BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlite3Hooks)
- # define wsdHooks x[0]
- #else
- # define wsdHooksInit
- # define wsdHooks sqlite3Hooks
- #endif
- /*
- ** Register hooks to call when sqlite3BeginBenignMalloc() and
- ** sqlite3EndBenignMalloc() are called, respectively.
- */
- SQLITE_PRIVATE void sqlite3BenignMallocHooks(
- void (*xBenignBegin)(void),
- void (*xBenignEnd)(void)
- ){
- wsdHooksInit;
- wsdHooks.xBenignBegin = xBenignBegin;
- wsdHooks.xBenignEnd = xBenignEnd;
- }
- /*
- ** This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that
- ** subsequent malloc failures are benign. A call to sqlite3EndBenignMalloc()
- ** indicates that subsequent malloc failures are non-benign.
- */
- SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){
- wsdHooksInit;
- if( wsdHooks.xBenignBegin ){
- wsdHooks.xBenignBegin();
- }
- }
- SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){
- wsdHooksInit;
- if( wsdHooks.xBenignEnd ){
- wsdHooks.xBenignEnd();
- }
- }
- #endif /* #ifndef SQLITE_OMIT_BUILTIN_TEST */
- /************** End of fault.c ***********************************************/
- /************** Begin file mem0.c ********************************************/
- /*
- ** 2008 October 28
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains a no-op memory allocation drivers for use when
- ** SQLITE_ZERO_MALLOC is defined. The allocation drivers implemented
- ** here always fail. SQLite will not operate with these drivers. These
- ** are merely placeholders. Real drivers must be substituted using
- ** sqlite3_config() before SQLite will operate.
- */
- /*
- ** This version of the memory allocator is the default. It is
- ** used when no other memory allocator is specified using compile-time
- ** macros.
- */
- #ifdef SQLITE_ZERO_MALLOC
- /*
- ** No-op versions of all memory allocation routines
- */
- static void *sqlite3MemMalloc(int nByte){ return 0; }
- static void sqlite3MemFree(void *pPrior){ return; }
- static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
- static int sqlite3MemSize(void *pPrior){ return 0; }
- static int sqlite3MemRoundup(int n){ return n; }
- static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
- static void sqlite3MemShutdown(void *NotUsed){ return; }
- /*
- ** This routine is the only routine in this file with external linkage.
- **
- ** Populate the low-level memory allocation function pointers in
- ** sqlite3GlobalConfig.m with pointers to the routines in this file.
- */
- SQLITE_PRIVATE void sqlite3MemSetDefault(void){
- static const sqlite3_mem_methods defaultMethods = {
- sqlite3MemMalloc,
- sqlite3MemFree,
- sqlite3MemRealloc,
- sqlite3MemSize,
- sqlite3MemRoundup,
- sqlite3MemInit,
- sqlite3MemShutdown,
- 0
- };
- sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
- }
- #endif /* SQLITE_ZERO_MALLOC */
- /************** End of mem0.c ************************************************/
- /************** Begin file mem1.c ********************************************/
- /*
- ** 2007 August 14
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains low-level memory allocation drivers for when
- ** SQLite will use the standard C-library malloc/realloc/free interface
- ** to obtain the memory it needs.
- **
- ** This file contains implementations of the low-level memory allocation
- ** routines specified in the sqlite3_mem_methods object.
- */
- /*
- ** This version of the memory allocator is the default. It is
- ** used when no other memory allocator is specified using compile-time
- ** macros.
- */
- #ifdef SQLITE_SYSTEM_MALLOC
- /*
- ** Windows systems have malloc_usable_size() but it is called _msize()
- */
- #if !defined(HAVE_MALLOC_USABLE_SIZE) && SQLITE_OS_WIN
- # define HAVE_MALLOC_USABLE_SIZE 1
- # define malloc_usable_size _msize
- #endif
- #if defined(__APPLE__)
- /*
- ** Use the zone allocator available on apple products
- */
- #include <sys/sysctl.h>
- #include <malloc/malloc.h>
- #include <libkern/OSAtomic.h>
- static malloc_zone_t* _sqliteZone_;
- #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
- #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
- #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y))
- #define SQLITE_MALLOCSIZE(x) \
- (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
- #else /* if not __APPLE__ */
- /*
- ** Use standard C library malloc and free on non-Apple systems.
- */
- #define SQLITE_MALLOC(x) malloc(x)
- #define SQLITE_FREE(x) free(x)
- #define SQLITE_REALLOC(x,y) realloc((x),(y))
- #ifdef HAVE_MALLOC_USABLE_SIZE
- #include <malloc.h>
- #define SQLITE_MALLOCSIZE(x) malloc_usable_size(x)
- #else
- #undef SQLITE_MALLOCSIZE
- #endif
- #endif /* __APPLE__ or not __APPLE__ */
- /*
- ** Like malloc(), but remember the size of the allocation
- ** so that we can find it later using sqlite3MemSize().
- **
- ** For this low-level routine, we are guaranteed that nByte>0 because
- ** cases of nByte<=0 will be intercepted and dealt with by higher level
- ** routines.
- */
- static void *sqlite3MemMalloc(int nByte){
- #ifdef SQLITE_MALLOCSIZE
- void *p = SQLITE_MALLOC( nByte );
- if( p==0 ){
- testcase( sqlite3GlobalConfig.xLog!=0 );
- sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
- }
- return p;
- #else
- sqlite3_int64 *p;
- assert( nByte>0 );
- nByte = ROUND8(nByte);
- p = SQLITE_MALLOC( nByte+8 );
- if( p ){
- p[0] = nByte;
- p++;
- }else{
- testcase( sqlite3GlobalConfig.xLog!=0 );
- sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
- }
- return (void *)p;
- #endif
- }
- /*
- ** Like free() but works for allocations obtained from sqlite3MemMalloc()
- ** or sqlite3MemRealloc().
- **
- ** For this low-level routine, we already know that pPrior!=0 since
- ** cases where pPrior==0 will have been intecepted and dealt with
- ** by higher-level routines.
- */
- static void sqlite3MemFree(void *pPrior){
- #ifdef SQLITE_MALLOCSIZE
- SQLITE_FREE(pPrior);
- #else
- sqlite3_int64 *p = (sqlite3_int64*)pPrior;
- assert( pPrior!=0 );
- p--;
- SQLITE_FREE(p);
- #endif
- }
- /*
- ** Report the allocated size of a prior return from xMalloc()
- ** or xRealloc().
- */
- static int sqlite3MemSize(void *pPrior){
- #ifdef SQLITE_MALLOCSIZE
- return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
- #else
- sqlite3_int64 *p;
- if( pPrior==0 ) return 0;
- p = (sqlite3_int64*)pPrior;
- p--;
- return (int)p[0];
- #endif
- }
- /*
- ** Like realloc(). Resize an allocation previously obtained from
- ** sqlite3MemMalloc().
- **
- ** For this low-level interface, we know that pPrior!=0. Cases where
- ** pPrior==0 while have been intercepted by higher-level routine and
- ** redirected to xMalloc. Similarly, we know that nByte>0 becauses
- ** cases where nByte<=0 will have been intercepted by higher-level
- ** routines and redirected to xFree.
- */
- static void *sqlite3MemRealloc(void *pPrior, int nByte){
- #ifdef SQLITE_MALLOCSIZE
- void *p = SQLITE_REALLOC(pPrior, nByte);
- if( p==0 ){
- testcase( sqlite3GlobalConfig.xLog!=0 );
- sqlite3_log(SQLITE_NOMEM,
- "failed memory resize %u to %u bytes",
- SQLITE_MALLOCSIZE(pPrior), nByte);
- }
- return p;
- #else
- sqlite3_int64 *p = (sqlite3_int64*)pPrior;
- assert( pPrior!=0 && nByte>0 );
- assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
- p--;
- p = SQLITE_REALLOC(p, nByte+8 );
- if( p ){
- p[0] = nByte;
- p++;
- }else{
- testcase( sqlite3GlobalConfig.xLog!=0 );
- sqlite3_log(SQLITE_NOMEM,
- "failed memory resize %u to %u bytes",
- sqlite3MemSize(pPrior), nByte);
- }
- return (void*)p;
- #endif
- }
- /*
- ** Round up a request size to the next valid allocation size.
- */
- static int sqlite3MemRoundup(int n){
- return ROUND8(n);
- }
- /*
- ** Initialize this module.
- */
- static int sqlite3MemInit(void *NotUsed){
- #if defined(__APPLE__)
- int cpuCount;
- size_t len;
- if( _sqliteZone_ ){
- return SQLITE_OK;
- }
- len = sizeof(cpuCount);
- /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
- sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
- if( cpuCount>1 ){
- /* defer MT decisions to system malloc */
- _sqliteZone_ = malloc_default_zone();
- }else{
- /* only 1 core, use our own zone to contention over global locks,
- ** e.g. we have our own dedicated locks */
- bool success;
- malloc_zone_t* newzone = malloc_create_zone(4096, 0);
- malloc_set_zone_name(newzone, "Sqlite_Heap");
- do{
- success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,
- (void * volatile *)&_sqliteZone_);
- }while(!_sqliteZone_);
- if( !success ){
- /* somebody registered a zone first */
- malloc_destroy_zone(newzone);
- }
- }
- #endif
- UNUSED_PARAMETER(NotUsed);
- return SQLITE_OK;
- }
- /*
- ** Deinitialize this module.
- */
- static void sqlite3MemShutdown(void *NotUsed){
- UNUSED_PARAMETER(NotUsed);
- return;
- }
- /*
- ** This routine is the only routine in this file with external linkage.
- **
- ** Populate the low-level memory allocation function pointers in
- ** sqlite3GlobalConfig.m with pointers to the routines in this file.
- */
- SQLITE_PRIVATE void sqlite3MemSetDefault(void){
- static const sqlite3_mem_methods defaultMethods = {
- sqlite3MemMalloc,
- sqlite3MemFree,
- sqlite3MemRealloc,
- sqlite3MemSize,
- sqlite3MemRoundup,
- sqlite3MemInit,
- sqlite3MemShutdown,
- 0
- };
- sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
- }
- #endif /* SQLITE_SYSTEM_MALLOC */
- /************** End of mem1.c ************************************************/
- /************** Begin file mem2.c ********************************************/
- /*
- ** 2007 August 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** This file contains low-level memory allocation drivers for when
- ** SQLite will use the standard C-library malloc/realloc/free interface
- ** to obtain the memory it needs while adding lots of additional debugging
- ** information to each allocation in order to help detect and fix memory
- ** leaks and memory usage errors.
- **
- ** This file contains implementations of the low-level memory allocation
- ** routines specified in the sqlite3_mem_methods object.
- */
- /*
- ** This version of the memory allocator is used only if the
- ** SQLITE_MEMDEBUG macro is defined
- */
- #ifdef SQLITE_MEMDEBUG
- /*
- ** The backtrace functionality is only available with GLIBC
- */
- #ifdef __GLIBC__
- extern int backtrace(void**,int);
- extern void backtrace_symbols_fd(void*const*,int,int);
- #else
- # define backtrace(A,B) 1
- # define backtrace_symbols_fd(A,B,C)
- #endif
- /* #include <stdio.h> */
- /*
- ** Each memory allocation looks like this:
- **
- ** ------------------------------------------------------------------------
- ** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard |
- ** ------------------------------------------------------------------------
- **
- ** The application code sees only a pointer to the allocation. We have
- ** to back up from the allocation pointer to find the MemBlockHdr. The
- ** MemBlockHdr tells us the size of the allocation and the number of
- ** backtrace pointers. There is also a guard word at the end of the
- ** MemBlockHdr.
- */
- struct MemBlockHdr {
- i64 iSize; /* Size of this allocation */
- struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
- char nBacktrace; /* Number of backtraces on this alloc */
- char nBacktraceSlots; /* Available backtrace slots */
- u8 nTitle; /* Bytes of title; includes '\0' */
- u8 eType; /* Allocation type code */
- int iForeGuard; /* Guard word for sanity */
- };
- /*
- ** Guard words
- */
- #define FOREGUARD 0x80F5E153
- #define REARGUARD 0xE4676B53
- /*
- ** Number of malloc size increments to track.
- */
- #define NCSIZE 1000
- /*
- ** All of the static variables used by this module are collected
- ** into a single structure named "mem". This is to keep the
- ** static variables organized and to reduce namespace pollution
- ** when this module is combined with other in the amalgamation.
- */
- static struct {
-
- /*
- ** Mutex to control access to the memory allocation subsystem.
- */
- sqlite3_mutex *mutex;
- /*
- ** Head and tail of a linked list of all outstanding allocations
- */
- struct MemBlockHdr *pFirst;
- struct MemBlockHdr *pLast;
-
- /*
- ** The number of levels of backtrace to save in new allocations.
- */
- int nBacktrace;
- void (*xBacktrace)(int, int, void **);
- /*
- ** Title text to insert in front of each block
- */
- int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */
- char zTitle[100]; /* The title text */
- /*
- ** sqlite3MallocDisallow() increments the following counter.
- ** sqlite3MallocAllow() decrements it.
- */
- int disallow; /* Do not allow memory allocation */
- /*
- ** Gather statistics on the sizes of memory allocations.
- ** nAlloc[i] is the number of allocation attempts of i*8
- ** bytes. i==NCSIZE is the number of allocation attempts for
- ** sizes more than NCSIZE*8 bytes.
- */
- int nAlloc[NCSIZE]; /* Total number of allocations */
- int nCurrent[NCSIZE]; /* Current number of allocations */
- int mxCurrent[NCSIZE]; /* Highwater mark for nCurrent */
- } mem;
- /*
- ** Adjust memory usage statistics
- */
- static void adjustStats(int iSize, int increment){
- int i = ROUND8(iSize)/8;
- if( i>NCSIZE-1 ){
- i = NCSIZE - 1;
- }
- if( increment>0 ){
- mem.nAlloc[i]++;
- mem.nCurrent[i]++;
- if( mem.nCurrent[i]>mem.mxCurrent[i] ){
- mem.mxCurrent[i] = mem.nCurrent[i];
- }
- }else{
- mem.nCurrent[i]--;
- assert( mem.nCurrent[i]>=0 );
- }
- }
- /*
- ** Given an allocation, find the MemBlockHdr for that allocation.
- **
- ** This routine checks the guards at either end of the allocation and
- ** if they are incorrect it asserts.
- */
- static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
- struct MemBlockHdr *p;
- int *pInt;
- u8 *pU8;
- int nReserve;
- p = (struct MemBlockHdr*)pAllocation;
- p--;
- assert( p->iForeGuard==(int)FOREGUARD );
- nReserve = ROUND8(p->iSize);
- pInt = (int*)pAllocation;
- pU8 = (u8*)pAllocation;
- assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD );
- /* This checks any of the "extra" bytes allocated due
- ** to rounding up to an 8 byte boundary to ensure
- ** they haven't been overwritten.
- */
- while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 );
- return p;
- }
- /*
- ** Return the number of bytes currently allocated at address p.
- */
- static int sqlite3MemSize(void *p){
- struct MemBlockHdr *pHdr;
- if( !p ){
- return 0;
- }
- pHdr = sqlite3MemsysGetHeader(p);
- return pHdr->iSize;
- }
- /*
- ** Initialize the memory allocation subsystem.
- */
- static int sqlite3MemInit(void *NotUsed){
- UNUSED_PARAMETER(NotUsed);
- assert( (sizeof(struct MemBlockHdr)&7) == 0 );
- if( !sqlite3GlobalConfig.bMemstat ){
- /* If memory status is enabled, then the malloc.c wrapper will already
- ** hold the STATIC_MEM mutex when the routines here are invoked. */
- mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
- }
- return SQLITE_OK;
- }
- /*
- ** Deinitialize the memory allocation subsystem.
- */
- static void sqlite3MemShutdown(void *NotUsed){
- UNUSED_PARAMETER(NotUsed);
- mem.mutex = 0;
- }
- /*
- ** Round up a request size to the next valid allocation size.
- */
- static int sqlite3MemRoundup(int n){
- return ROUND8(n);
- }
- /*
- ** Fill a buffer with pseudo-random bytes. This is used to preset
- ** the content of a new memory allocation to unpredictable values and
- ** to clear the content of a freed allocation to unpredictable values.
- */
- static void randomFill(char *pBuf, int nByte){
- unsigned int x, y, r;
- x = SQLITE_PTR_TO_INT(pBuf);
- y = nByte | 1;
- while( nByte >= 4 ){
- x = (x>>1) ^ (-(x&1) & 0xd0000001);
- y = y*1103515245 + 12345;
- r = x ^ y;
- *(int*)pBuf = r;
- pBuf += 4;
- nByte -= 4;
- }
- while( nByte-- > 0 ){
- x = (x>>1) ^ (-(x&1) & 0xd0000001);
- y = y*1103515245 + 12345;
- r = x ^ y;
- *(pBuf++) = r & 0xff;
- }
- }
- /*
- ** Allocate nByte bytes of memory.
- */
- static void *sqlite3MemMalloc(int nByte){
- struct MemBlockHdr *pHdr;
- void **pBt;
- char *z;
- int *pInt;
- void *p = 0;
- int totalSize;
- int nReserve;
- sqlite3_mutex_enter(mem.mutex);
- assert( mem.disallow==0 );
- nReserve = ROUND8(nByte);
- totalSize = nReserve + sizeof(*pHdr) + sizeof(int) +
- mem.nBacktrace*sizeof(void*) + mem.nTitle;
- p = malloc(totalSize);
- if( p ){
- z = p;
- pBt = (void**)&z[mem.nTitle];
- pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
- pHdr->pNext = 0;
- pHdr->pPrev = mem.pLast;
- if( mem.pLast ){
- mem.pLast->pNext = pHdr;
- }else{
- mem.pFirst = pHdr;
- }
- mem.pLast = pHdr;
- pHdr->iForeGuard = FOREGUARD;
- pHdr->eType = MEMTYPE_HEAP;
- pHdr->nBacktraceSlots = mem.nBacktrace;
- pHdr->nTitle = mem.nTitle;
- if( mem.nBacktrace ){
- void *aAddr[40];
- pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
- memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
- assert(pBt[0]);
- if( mem.xBacktrace ){
- mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
- }
- }else{
- pHdr->nBacktrace = 0;
- }
- if( mem.nTitle ){
- memcpy(z, mem.zTitle, mem.nTitle);
- }
- pHdr->iSize = nByte;
- adjustStats(nByte, +1);
- pInt = (int*)&pHdr[1];
- pInt[nReserve/sizeof(int)] = REARGUARD;
- randomFill((char*)pInt, nByte);
- memset(((char*)pInt)+nByte, 0x65, nReserve-nByte);
- p = (void*)pInt;
- }
- sqlite3_mutex_leave(mem.mutex);
- return p;
- }
- /*
- ** Free memory.
- */
- static void sqlite3MemFree(void *pPrior){
- struct MemBlockHdr *pHdr;
- void **pBt;
- char *z;
- assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0
- || mem.mutex!=0 );
- pHdr = sqlite3MemsysGetHeader(pPrior);
- pBt = (void**)pHdr;
- pBt -= pHdr->nBacktraceSlots;
- sqlite3_mutex_enter(mem.mutex);
- if( pHdr->pPrev ){
- assert( pHdr->pPrev->pNext==pHdr );
- pHdr->pPrev->pNext = pHdr->pNext;
- }else{
- assert( mem.pFirst==pHdr );
- mem.pFirst = pHdr->pNext;
- }
- if( pHdr->pNext ){
- assert( pHdr->pNext->pPrev==pHdr );
- pHdr->pNext->pPrev = pHdr->pPrev;
- }else{
- assert( mem.pLast==pHdr );
- mem.pLast = pHdr->pPrev;
- }
- z = (char*)pBt;
- z -= pHdr->nTitle;
- adjustStats(pHdr->iSize, -1);
- randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
- pHdr->iSize + sizeof(int) + pHdr->nTitle);
- free(z);
- sqlite3_mutex_leave(mem.mutex);
- }
- /*
- ** Change the size of an existing memory allocation.
- **
- ** For this debugging implementation, we *always* make a copy of the
- ** allocation into a new place in memory. In this way, if the
- ** higher level code is using pointer to the old allocation, it is
- ** much more likely to break and we are much more liking to find
- ** the error.
- */
- static void *sqlite3MemRealloc(void *pPrior, int nByte){
- struct MemBlockHdr *pOldHdr;
- void *pNew;
- assert( mem.disallow==0 );
- assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */
- pOldHdr = sqlite3MemsysGetHeader(pPrior);
- pNew = sqlite3MemMalloc(nByte);
- if( pNew ){
- memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
- if( nByte>pOldHdr->iSize ){
- randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
- }
- sqlite3MemFree(pPrior);
- }
- return pNew;
- }
- /*
- ** Populate the low-level memory allocation function pointers in
- ** sqlite3GlobalConfig.m with pointers to the routines in this file.
- */
- SQLITE_PRIVATE void sqlite3MemSetDefault(void){
- static const sqlite3_mem_methods defaultMethods = {
- sqlite3MemMalloc,
- sqlite3MemFree,
- sqlite3MemRealloc,
- sqlite3MemSize,
- sqlite3MemRoundup,
- sqlite3MemInit,
- sqlite3MemShutdown,
- 0
- };
- sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
- }
- /*
- ** Set the "type" of an allocation.
- */
- SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){
- if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
- struct MemBlockHdr *pHdr;
- pHdr = sqlite3MemsysGetHeader(p);
- assert( pHdr->iForeGuard==FOREGUARD );
- pHdr->eType = eType;
- }
- }
- /*
- ** Return TRUE if the mask of type in eType matches the type of the
- ** allocation p. Also return true if p==NULL.
- **
- ** This routine is designed for use within an assert() statement, to
- ** verify the type of an allocation. For example:
- **
- ** assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
- */
- SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){
- int rc = 1;
- if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
- struct MemBlockHdr *pHdr;
- pHdr = sqlite3MemsysGetHeader(p);
- assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
- if( (pHdr->eType&eType)==0 ){
- rc = 0;
- }
- }
- return rc;
- }
- /*
- ** Return TRUE if the mask of type in eType matches no bits of the type of the
- ** allocation p. Also return true if p==NULL.
- **
- ** This routine is designed for use within an assert() statement, to
- ** verify the type of an allocation. For example:
- **
- ** assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
- */
- SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){
- int rc = 1;
- if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
- struct MemBlockHdr *pHdr;
- pHdr = sqlite3MemsysGetHeader(p);
- assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
- if( (pHdr->eType&eType)!=0 ){
- rc = 0;
- }
- }
- return rc;
- }
- /*
- ** Set the number of backtrace levels kept for each allocation.
- ** A value of zero turns off backtracing. The number is always rounded
- ** up to a multiple of 2.
- */
- SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){
- if( depth<0 ){ depth = 0; }
- if( depth>20 ){ depth = 20; }
- depth = (depth+1)&0xfe;
- mem.nBacktrace = depth;
- }
- SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){
- mem.xBacktrace = xBacktrace;
- }
- /*
- ** Set the title string for subsequent allocations.
- */
- SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){
- unsigned int n = sqlite3Strlen30(zTitle) + 1;
- sqlite3_mutex_enter(mem.mutex);
- if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
- memcpy(mem.zTitle, zTitle, n);
- mem.zTitle[n] = 0;
- mem.nTitle = ROUND8(n);
- sqlite3_mutex_leave(mem.mutex);
- }
- SQLITE_PRIVATE void sqlite3MemdebugSync(){
- struct MemBlockHdr *pHdr;
- for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
- void **pBt = (void**)pHdr;
- pBt -= pHdr->nBacktraceSlots;
- mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
- }
- }
- /*
- ** Open the file indicated and write a log of all unfreed memory
- ** allocations into that log.
- */
- SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){
- FILE *out;
- struct MemBlockHdr *pHdr;
- void **pBt;
- int i;
- out = fopen(zFilename, "w");
- if( out==0 ){
- fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
- zFilename);
- return;
- }
- for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
- char *z = (char*)pHdr;
- z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
- fprintf(out, "**** %lld bytes at %p from %s ****\n",
- pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
- if( pHdr->nBacktrace ){
- fflush(out);
- pBt = (void**)pHdr;
- pBt -= pHdr->nBacktraceSlots;
- backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
- fprintf(out, "\n");
- }
- }
- fprintf(out, "COUNTS:\n");
- for(i=0; i<NCSIZE-1; i++){
- if( mem.nAlloc[i] ){
- fprintf(out, " %5d: %10d %10d %10d\n",
- i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
- }
- }
- if( mem.nAlloc[NCSIZE-1] ){
- fprintf(out, " %5d: %10d %10d %10d\n",
- NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
- mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
- }
- fclose(out);
- }
- /*
- ** Return the number of times sqlite3MemMalloc() has been called.
- */
- SQLITE_PRIVATE int sqlite3MemdebugMallocCount(){
- int i;
- int nTotal = 0;
- for(i=0; i<NCSIZE; i++){
- nTotal += mem.nAlloc[i];
- }
- return nTotal;
- }
- #endif /* SQLITE_MEMDEBUG */
- /************** End of mem2.c ************************************************/
- /************** Begin file mem3.c ********************************************/
- /*
- ** 2007 October 14
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement a memory
- ** allocation subsystem for use by SQLite.
- **
- ** This version of the memory allocation subsystem omits all
- ** use of malloc(). The SQLite user supplies a block of memory
- ** before calling sqlite3_initialize() from which allocations
- ** are made and returned by the xMalloc() and xRealloc()
- ** implementations. Once sqlite3_initialize() has been called,
- ** the amount of memory available to SQLite is fixed and cannot
- ** be changed.
- **
- ** This version of the memory allocation subsystem is included
- ** in the build only if SQLITE_ENABLE_MEMSYS3 is defined.
- */
- /*
- ** This version of the memory allocator is only built into the library
- ** SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
- ** mean that the library will use a memory-pool by default, just that
- ** it is available. The mempool allocator is activated by calling
- ** sqlite3_config().
- */
- #ifdef SQLITE_ENABLE_MEMSYS3
- /*
- ** Maximum size (in Mem3Blocks) of a "small" chunk.
- */
- #define MX_SMALL 10
- /*
- ** Number of freelist hash slots
- */
- #define N_HASH 61
- /*
- ** A memory allocation (also called a "chunk") consists of two or
- ** more blocks where each block is 8 bytes. The first 8 bytes are
- ** a header that is not returned to the user.
- **
- ** A chunk is two or more blocks that is either checked out or
- ** free. The first block has format u.hdr. u.hdr.size4x is 4 times the
- ** size of the allocation in blocks if the allocation is free.
- ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
- ** false if the chunk is on the freelist. The u.hdr.size4x&2 bit
- ** is true if the previous chunk is checked out and false if the
- ** previous chunk is free. The u.hdr.prevSize field is the size of
- ** the previous chunk in blocks if the previous chunk is on the
- ** freelist. If the previous chunk is checked out, then
- ** u.hdr.prevSize can be part of the data for that chunk and should
- ** not be read or written.
- **
- ** We often identify a chunk by its index in mem3.aPool[]. When
- ** this is done, the chunk index refers to the second block of
- ** the chunk. In this way, the first chunk has an index of 1.
- ** A chunk index of 0 means "no such chunk" and is the equivalent
- ** of a NULL pointer.
- **
- ** The second block of free chunks is of the form u.list. The
- ** two fields form a double-linked list of chunks of related sizes.
- ** Pointers to the head of the list are stored in mem3.aiSmall[]
- ** for smaller chunks and mem3.aiHash[] for larger chunks.
- **
- ** The second block of a chunk is user data if the chunk is checked
- ** out. If a chunk is checked out, the user data may extend into
- ** the u.hdr.prevSize value of the following chunk.
- */
- typedef struct Mem3Block Mem3Block;
- struct Mem3Block {
- union {
- struct {
- u32 prevSize; /* Size of previous chunk in Mem3Block elements */
- u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
- } hdr;
- struct {
- u32 next; /* Index in mem3.aPool[] of next free chunk */
- u32 prev; /* Index in mem3.aPool[] of previous free chunk */
- } list;
- } u;
- };
- /*
- ** All of the static variables used by this module are collected
- ** into a single structure named "mem3". This is to keep the
- ** static variables organized and to reduce namespace pollution
- ** when this module is combined with other in the amalgamation.
- */
- static SQLITE_WSD struct Mem3Global {
- /*
- ** Memory available for allocation. nPool is the size of the array
- ** (in Mem3Blocks) pointed to by aPool less 2.
- */
- u32 nPool;
- Mem3Block *aPool;
- /*
- ** True if we are evaluating an out-of-memory callback.
- */
- int alarmBusy;
-
- /*
- ** Mutex to control access to the memory allocation subsystem.
- */
- sqlite3_mutex *mutex;
-
- /*
- ** The minimum amount of free space that we have seen.
- */
- u32 mnMaster;
- /*
- ** iMaster is the index of the master chunk. Most new allocations
- ** occur off of this chunk. szMaster is the size (in Mem3Blocks)
- ** of the current master. iMaster is 0 if there is not master chunk.
- ** The master chunk is not in either the aiHash[] or aiSmall[].
- */
- u32 iMaster;
- u32 szMaster;
- /*
- ** Array of lists of free blocks according to the block size
- ** for smaller chunks, or a hash on the block size for larger
- ** chunks.
- */
- u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
- u32 aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */
- } mem3 = { 97535575 };
- #define mem3 GLOBAL(struct Mem3Global, mem3)
- /*
- ** Unlink the chunk at mem3.aPool[i] from list it is currently
- ** on. *pRoot is the list that i is a member of.
- */
- static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
- u32 next = mem3.aPool[i].u.list.next;
- u32 prev = mem3.aPool[i].u.list.prev;
- assert( sqlite3_mutex_held(mem3.mutex) );
- if( prev==0 ){
- *pRoot = next;
- }else{
- mem3.aPool[prev].u.list.next = next;
- }
- if( next ){
- mem3.aPool[next].u.list.prev = prev;
- }
- mem3.aPool[i].u.list.next = 0;
- mem3.aPool[i].u.list.prev = 0;
- }
- /*
- ** Unlink the chunk at index i from
- ** whatever list is currently a member of.
- */
- static void memsys3Unlink(u32 i){
- u32 size, hash;
- assert( sqlite3_mutex_held(mem3.mutex) );
- assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
- assert( i>=1 );
- size = mem3.aPool[i-1].u.hdr.size4x/4;
- assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
- assert( size>=2 );
- if( size <= MX_SMALL ){
- memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]);
- }else{
- hash = size % N_HASH;
- memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
- }
- }
- /*
- ** Link the chunk at mem3.aPool[i] so that is on the list rooted
- ** at *pRoot.
- */
- static void memsys3LinkIntoList(u32 i, u32 *pRoot){
- assert( sqlite3_mutex_held(mem3.mutex) );
- mem3.aPool[i].u.list.next = *pRoot;
- mem3.aPool[i].u.list.prev = 0;
- if( *pRoot ){
- mem3.aPool[*pRoot].u.list.prev = i;
- }
- *pRoot = i;
- }
- /*
- ** Link the chunk at index i into either the appropriate
- ** small chunk list, or into the large chunk hash table.
- */
- static void memsys3Link(u32 i){
- u32 size, hash;
- assert( sqlite3_mutex_held(mem3.mutex) );
- assert( i>=1 );
- assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
- size = mem3.aPool[i-1].u.hdr.size4x/4;
- assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
- assert( size>=2 );
- if( size <= MX_SMALL ){
- memsys3LinkIntoList(i, &mem3.aiSmall[size-2]);
- }else{
- hash = size % N_HASH;
- memsys3LinkIntoList(i, &mem3.aiHash[hash]);
- }
- }
- /*
- ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
- ** will already be held (obtained by code in malloc.c) if
- ** sqlite3GlobalConfig.bMemStat is true.
- */
- static void memsys3Enter(void){
- if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){
- mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
- }
- sqlite3_mutex_enter(mem3.mutex);
- }
- static void memsys3Leave(void){
- sqlite3_mutex_leave(mem3.mutex);
- }
- /*
- ** Called when we are unable to satisfy an allocation of nBytes.
- */
- static void memsys3OutOfMemory(int nByte){
- if( !mem3.alarmBusy ){
- mem3.alarmBusy = 1;
- assert( sqlite3_mutex_held(mem3.mutex) );
- sqlite3_mutex_leave(mem3.mutex);
- sqlite3_release_memory(nByte);
- sqlite3_mutex_enter(mem3.mutex);
- mem3.alarmBusy = 0;
- }
- }
- /*
- ** Chunk i is a free chunk that has been unlinked. Adjust its
- ** size parameters for check-out and return a pointer to the
- ** user portion of the chunk.
- */
- static void *memsys3Checkout(u32 i, u32 nBlock){
- u32 x;
- assert( sqlite3_mutex_held(mem3.mutex) );
- assert( i>=1 );
- assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
- assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
- x = mem3.aPool[i-1].u.hdr.size4x;
- mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
- mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
- mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
- return &mem3.aPool[i];
- }
- /*
- ** Carve a piece off of the end of the mem3.iMaster free chunk.
- ** Return a pointer to the new allocation. Or, if the master chunk
- ** is not large enough, return 0.
- */
- static void *memsys3FromMaster(u32 nBlock){
- assert( sqlite3_mutex_held(mem3.mutex) );
- assert( mem3.szMaster>=nBlock );
- if( nBlock>=mem3.szMaster-1 ){
- /* Use the entire master */
- void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
- mem3.iMaster = 0;
- mem3.szMaster = 0;
- mem3.mnMaster = 0;
- return p;
- }else{
- /* Split the master block. Return the tail. */
- u32 newi, x;
- newi = mem3.iMaster + mem3.szMaster - nBlock;
- assert( newi > mem3.iMaster+1 );
- mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
- mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
- mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
- mem3.szMaster -= nBlock;
- mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
- x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
- mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
- if( mem3.szMaster < mem3.mnMaster ){
- mem3.mnMaster = mem3.szMaster;
- }
- return (void*)&mem3.aPool[newi];
- }
- }
- /*
- ** *pRoot is the head of a list of free chunks of the same size
- ** or same size hash. In other words, *pRoot is an entry in either
- ** mem3.aiSmall[] or mem3.aiHash[].
- **
- ** This routine examines all entries on the given list and tries
- ** to coalesce each entries with adjacent free chunks.
- **
- ** If it sees a chunk that is larger than mem3.iMaster, it replaces
- ** the current mem3.iMaster with the new larger chunk. In order for
- ** this mem3.iMaster replacement to work, the master chunk must be
- ** linked into the hash tables. That is not the normal state of
- ** affairs, of course. The calling routine must link the master
- ** chunk before invoking this routine, then must unlink the (possibly
- ** changed) master chunk once this routine has finished.
- */
- static void memsys3Merge(u32 *pRoot){
- u32 iNext, prev, size, i, x;
- assert( sqlite3_mutex_held(mem3.mutex) );
- for(i=*pRoot; i>0; i=iNext){
- iNext = mem3.aPool[i].u.list.next;
- size = mem3.aPool[i-1].u.hdr.size4x;
- assert( (size&1)==0 );
- if( (size&2)==0 ){
- memsys3UnlinkFromList(i, pRoot);
- assert( i > mem3.aPool[i-1].u.hdr.prevSize );
- prev = i - mem3.aPool[i-1].u.hdr.prevSize;
- if( prev==iNext ){
- iNext = mem3.aPool[prev].u.list.next;
- }
- memsys3Unlink(prev);
- size = i + size/4 - prev;
- x = mem3.aPool[prev-1].u.hdr.size4x & 2;
- mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
- mem3.aPool[prev+size-1].u.hdr.prevSize = size;
- memsys3Link(prev);
- i = prev;
- }else{
- size /= 4;
- }
- if( size>mem3.szMaster ){
- mem3.iMaster = i;
- mem3.szMaster = size;
- }
- }
- }
- /*
- ** Return a block of memory of at least nBytes in size.
- ** Return NULL if unable.
- **
- ** This function assumes that the necessary mutexes, if any, are
- ** already held by the caller. Hence "Unsafe".
- */
- static void *memsys3MallocUnsafe(int nByte){
- u32 i;
- u32 nBlock;
- u32 toFree;
- assert( sqlite3_mutex_held(mem3.mutex) );
- assert( sizeof(Mem3Block)==8 );
- if( nByte<=12 ){
- nBlock = 2;
- }else{
- nBlock = (nByte + 11)/8;
- }
- assert( nBlock>=2 );
- /* STEP 1:
- ** Look for an entry of the correct size in either the small
- ** chunk table or in the large chunk hash table. This is
- ** successful most of the time (about 9 times out of 10).
- */
- if( nBlock <= MX_SMALL ){
- i = mem3.aiSmall[nBlock-2];
- if( i>0 ){
- memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]);
- return memsys3Checkout(i, nBlock);
- }
- }else{
- int hash = nBlock % N_HASH;
- for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
- if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
- memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
- return memsys3Checkout(i, nBlock);
- }
- }
- }
- /* STEP 2:
- ** Try to satisfy the allocation by carving a piece off of the end
- ** of the master chunk. This step usually works if step 1 fails.
- */
- if( mem3.szMaster>=nBlock ){
- return memsys3FromMaster(nBlock);
- }
- /* STEP 3:
- ** Loop through the entire memory pool. Coalesce adjacent free
- ** chunks. Recompute the master chunk as the largest free chunk.
- ** Then try again to satisfy the allocation by carving a piece off
- ** of the end of the master chunk. This step happens very
- ** rarely (we hope!)
- */
- for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){
- memsys3OutOfMemory(toFree);
- if( mem3.iMaster ){
- memsys3Link(mem3.iMaster);
- mem3.iMaster = 0;
- mem3.szMaster = 0;
- }
- for(i=0; i<N_HASH; i++){
- memsys3Merge(&mem3.aiHash[i]);
- }
- for(i=0; i<MX_SMALL-1; i++){
- memsys3Merge(&mem3.aiSmall[i]);
- }
- if( mem3.szMaster ){
- memsys3Unlink(mem3.iMaster);
- if( mem3.szMaster>=nBlock ){
- return memsys3FromMaster(nBlock);
- }
- }
- }
- /* If none of the above worked, then we fail. */
- return 0;
- }
- /*
- ** Free an outstanding memory allocation.
- **
- ** This function assumes that the necessary mutexes, if any, are
- ** already held by the caller. Hence "Unsafe".
- */
- static void memsys3FreeUnsafe(void *pOld){
- Mem3Block *p = (Mem3Block*)pOld;
- int i;
- u32 size, x;
- assert( sqlite3_mutex_held(mem3.mutex) );
- assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] );
- i = p - mem3.aPool;
- assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
- size = mem3.aPool[i-1].u.hdr.size4x/4;
- assert( i+size<=mem3.nPool+1 );
- mem3.aPool[i-1].u.hdr.size4x &= ~1;
- mem3.aPool[i+size-1].u.hdr.prevSize = size;
- mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
- memsys3Link(i);
- /* Try to expand the master using the newly freed chunk */
- if( mem3.iMaster ){
- while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
- size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
- mem3.iMaster -= size;
- mem3.szMaster += size;
- memsys3Unlink(mem3.iMaster);
- x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
- mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
- mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
- }
- x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
- while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
- memsys3Unlink(mem3.iMaster+mem3.szMaster);
- mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
- mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
- mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
- }
- }
- }
- /*
- ** Return the size of an outstanding allocation, in bytes. The
- ** size returned omits the 8-byte header overhead. This only
- ** works for chunks that are currently checked out.
- */
- static int memsys3Size(void *p){
- Mem3Block *pBlock;
- if( p==0 ) return 0;
- pBlock = (Mem3Block*)p;
- assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
- return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
- }
- /*
- ** Round up a request size to the next valid allocation size.
- */
- static int memsys3Roundup(int n){
- if( n<=12 ){
- return 12;
- }else{
- return ((n+11)&~7) - 4;
- }
- }
- /*
- ** Allocate nBytes of memory.
- */
- static void *memsys3Malloc(int nBytes){
- sqlite3_int64 *p;
- assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */
- memsys3Enter();
- p = memsys3MallocUnsafe(nBytes);
- memsys3Leave();
- return (void*)p;
- }
- /*
- ** Free memory.
- */
- static void memsys3Free(void *pPrior){
- assert( pPrior );
- memsys3Enter();
- memsys3FreeUnsafe(pPrior);
- memsys3Leave();
- }
- /*
- ** Change the size of an existing memory allocation
- */
- static void *memsys3Realloc(void *pPrior, int nBytes){
- int nOld;
- void *p;
- if( pPrior==0 ){
- return sqlite3_malloc(nBytes);
- }
- if( nBytes<=0 ){
- sqlite3_free(pPrior);
- return 0;
- }
- nOld = memsys3Size(pPrior);
- if( nBytes<=nOld && nBytes>=nOld-128 ){
- return pPrior;
- }
- memsys3Enter();
- p = memsys3MallocUnsafe(nBytes);
- if( p ){
- if( nOld<nBytes ){
- memcpy(p, pPrior, nOld);
- }else{
- memcpy(p, pPrior, nBytes);
- }
- memsys3FreeUnsafe(pPrior);
- }
- memsys3Leave();
- return p;
- }
- /*
- ** Initialize this module.
- */
- static int memsys3Init(void *NotUsed){
- UNUSED_PARAMETER(NotUsed);
- if( !sqlite3GlobalConfig.pHeap ){
- return SQLITE_ERROR;
- }
- /* Store a pointer to the memory block in global structure mem3. */
- assert( sizeof(Mem3Block)==8 );
- mem3.aPool = (Mem3Block *)sqlite3GlobalConfig.pHeap;
- mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
- /* Initialize the master block. */
- mem3.szMaster = mem3.nPool;
- mem3.mnMaster = mem3.szMaster;
- mem3.iMaster = 1;
- mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
- mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
- mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
- return SQLITE_OK;
- }
- /*
- ** Deinitialize this module.
- */
- static void memsys3Shutdown(void *NotUsed){
- UNUSED_PARAMETER(NotUsed);
- mem3.mutex = 0;
- return;
- }
- /*
- ** Open the file indicated and write a log of all unfreed memory
- ** allocations into that log.
- */
- SQLITE_PRIVATE void sqlite3Memsys3Dump(const char *zFilename){
- #ifdef SQLITE_DEBUG
- FILE *out;
- u32 i, j;
- u32 size;
- if( zFilename==0 || zFilename[0]==0 ){
- out = stdout;
- }else{
- out = fopen(zFilename, "w");
- if( out==0 ){
- fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
- zFilename);
- return;
- }
- }
- memsys3Enter();
- fprintf(out, "CHUNKS:\n");
- for(i=1; i<=mem3.nPool; i+=size/4){
- size = mem3.aPool[i-1].u.hdr.size4x;
- if( size/4<=1 ){
- fprintf(out, "%p size error\n", &mem3.aPool[i]);
- assert( 0 );
- break;
- }
- if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
- fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
- assert( 0 );
- break;
- }
- if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
- fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
- assert( 0 );
- break;
- }
- if( size&1 ){
- fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
- }else{
- fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
- i==mem3.iMaster ? " **master**" : "");
- }
- }
- for(i=0; i<MX_SMALL-1; i++){
- if( mem3.aiSmall[i]==0 ) continue;
- fprintf(out, "small(%2d):", i);
- for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
- fprintf(out, " %p(%d)", &mem3.aPool[j],
- (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
- }
- fprintf(out, "\n");
- }
- for(i=0; i<N_HASH; i++){
- if( mem3.aiHash[i]==0 ) continue;
- fprintf(out, "hash(%2d):", i);
- for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
- fprintf(out, " %p(%d)", &mem3.aPool[j],
- (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
- }
- fprintf(out, "\n");
- }
- fprintf(out, "master=%d\n", mem3.iMaster);
- fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
- fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
- sqlite3_mutex_leave(mem3.mutex);
- if( out==stdout ){
- fflush(stdout);
- }else{
- fclose(out);
- }
- #else
- UNUSED_PARAMETER(zFilename);
- #endif
- }
- /*
- ** This routine is the only routine in this file with external
- ** linkage.
- **
- ** Populate the low-level memory allocation function pointers in
- ** sqlite3GlobalConfig.m with pointers to the routines in this file. The
- ** arguments specify the block of memory to manage.
- **
- ** This routine is only called by sqlite3_config(), and therefore
- ** is not required to be threadsafe (it is not).
- */
- SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){
- static const sqlite3_mem_methods mempoolMethods = {
- memsys3Malloc,
- memsys3Free,
- memsys3Realloc,
- memsys3Size,
- memsys3Roundup,
- memsys3Init,
- memsys3Shutdown,
- 0
- };
- return &mempoolMethods;
- }
- #endif /* SQLITE_ENABLE_MEMSYS3 */
- /************** End of mem3.c ************************************************/
- /************** Begin file mem5.c ********************************************/
- /*
- ** 2007 October 14
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement a memory
- ** allocation subsystem for use by SQLite.
- **
- ** This version of the memory allocation subsystem omits all
- ** use of malloc(). The application gives SQLite a block of memory
- ** before calling sqlite3_initialize() from which allocations
- ** are made and returned by the xMalloc() and xRealloc()
- ** implementations. Once sqlite3_initialize() has been called,
- ** the amount of memory available to SQLite is fixed and cannot
- ** be changed.
- **
- ** This version of the memory allocation subsystem is included
- ** in the build only if SQLITE_ENABLE_MEMSYS5 is defined.
- **
- ** This memory allocator uses the following algorithm:
- **
- ** 1. All memory allocations sizes are rounded up to a power of 2.
- **
- ** 2. If two adjacent free blocks are the halves of a larger block,
- ** then the two blocks are coalesed into the single larger block.
- **
- ** 3. New memory is allocated from the first available free block.
- **
- ** This algorithm is described in: J. M. Robson. "Bounds for Some Functions
- ** Concerning Dynamic Storage Allocation". Journal of the Association for
- ** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499.
- **
- ** Let n be the size of the largest allocation divided by the minimum
- ** allocation size (after rounding all sizes up to a power of 2.) Let M
- ** be the maximum amount of memory ever outstanding at one time. Let
- ** N be the total amount of memory available for allocation. Robson
- ** proved that this memory allocator will never breakdown due to
- ** fragmentation as long as the following constraint holds:
- **
- ** N >= M*(1 + log2(n)/2) - n + 1
- **
- ** The sqlite3_status() logic tracks the maximum values of n and M so
- ** that an application can, at any time, verify this constraint.
- */
- /*
- ** This version of the memory allocator is used only when
- ** SQLITE_ENABLE_MEMSYS5 is defined.
- */
- #ifdef SQLITE_ENABLE_MEMSYS5
- /*
- ** A minimum allocation is an instance of the following structure.
- ** Larger allocations are an array of these structures where the
- ** size of the array is a power of 2.
- **
- ** The size of this object must be a power of two. That fact is
- ** verified in memsys5Init().
- */
- typedef struct Mem5Link Mem5Link;
- struct Mem5Link {
- int next; /* Index of next free chunk */
- int prev; /* Index of previous free chunk */
- };
- /*
- ** Maximum size of any allocation is ((1<<LOGMAX)*mem5.szAtom). Since
- ** mem5.szAtom is always at least 8 and 32-bit integers are used,
- ** it is not actually possible to reach this limit.
- */
- #define LOGMAX 30
- /*
- ** Masks used for mem5.aCtrl[] elements.
- */
- #define CTRL_LOGSIZE 0x1f /* Log2 Size of this block */
- #define CTRL_FREE 0x20 /* True if not checked out */
- /*
- ** All of the static variables used by this module are collected
- ** into a single structure named "mem5". This is to keep the
- ** static variables organized and to reduce namespace pollution
- ** when this module is combined with other in the amalgamation.
- */
- static SQLITE_WSD struct Mem5Global {
- /*
- ** Memory available for allocation
- */
- int szAtom; /* Smallest possible allocation in bytes */
- int nBlock; /* Number of szAtom sized blocks in zPool */
- u8 *zPool; /* Memory available to be allocated */
-
- /*
- ** Mutex to control access to the memory allocation subsystem.
- */
- sqlite3_mutex *mutex;
- /*
- ** Performance statistics
- */
- u64 nAlloc; /* Total number of calls to malloc */
- u64 totalAlloc; /* Total of all malloc calls - includes internal frag */
- u64 totalExcess; /* Total internal fragmentation */
- u32 currentOut; /* Current checkout, including internal fragmentation */
- u32 currentCount; /* Current number of distinct checkouts */
- u32 maxOut; /* Maximum instantaneous currentOut */
- u32 maxCount; /* Maximum instantaneous currentCount */
- u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
-
- /*
- ** Lists of free blocks. aiFreelist[0] is a list of free blocks of
- ** size mem5.szAtom. aiFreelist[1] holds blocks of size szAtom*2.
- ** and so forth.
- */
- int aiFreelist[LOGMAX+1];
- /*
- ** Space for tracking which blocks are checked out and the size
- ** of each block. One byte per block.
- */
- u8 *aCtrl;
- } mem5;
- /*
- ** Access the static variable through a macro for SQLITE_OMIT_WSD
- */
- #define mem5 GLOBAL(struct Mem5Global, mem5)
- /*
- ** Assuming mem5.zPool is divided up into an array of Mem5Link
- ** structures, return a pointer to the idx-th such lik.
- */
- #define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom]))
- /*
- ** Unlink the chunk at mem5.aPool[i] from list it is currently
- ** on. It should be found on mem5.aiFreelist[iLogsize].
- */
- static void memsys5Unlink(int i, int iLogsize){
- int next, prev;
- assert( i>=0 && i<mem5.nBlock );
- assert( iLogsize>=0 && iLogsize<=LOGMAX );
- assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
- next = MEM5LINK(i)->next;
- prev = MEM5LINK(i)->prev;
- if( prev<0 ){
- mem5.aiFreelist[iLogsize] = next;
- }else{
- MEM5LINK(prev)->next = next;
- }
- if( next>=0 ){
- MEM5LINK(next)->prev = prev;
- }
- }
- /*
- ** Link the chunk at mem5.aPool[i] so that is on the iLogsize
- ** free list.
- */
- static void memsys5Link(int i, int iLogsize){
- int x;
- assert( sqlite3_mutex_held(mem5.mutex) );
- assert( i>=0 && i<mem5.nBlock );
- assert( iLogsize>=0 && iLogsize<=LOGMAX );
- assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
- x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
- MEM5LINK(i)->prev = -1;
- if( x>=0 ){
- assert( x<mem5.nBlock );
- MEM5LINK(x)->prev = i;
- }
- mem5.aiFreelist[iLogsize] = i;
- }
- /*
- ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
- ** will already be held (obtained by code in malloc.c) if
- ** sqlite3GlobalConfig.bMemStat is true.
- */
- static void memsys5Enter(void){
- sqlite3_mutex_enter(mem5.mutex);
- }
- static void memsys5Leave(void){
- sqlite3_mutex_leave(mem5.mutex);
- }
- /*
- ** Return the size of an outstanding allocation, in bytes. The
- ** size returned omits the 8-byte header overhead. This only
- ** works for chunks that are currently checked out.
- */
- static int memsys5Size(void *p){
- int iSize = 0;
- if( p ){
- int i = ((u8 *)p-mem5.zPool)/mem5.szAtom;
- assert( i>=0 && i<mem5.nBlock );
- iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
- }
- return iSize;
- }
- /*
- ** Find the first entry on the freelist iLogsize. Unlink that
- ** entry and return its index.
- */
- static int memsys5UnlinkFirst(int iLogsize){
- int i;
- int iFirst;
- assert( iLogsize>=0 && iLogsize<=LOGMAX );
- i = iFirst = mem5.aiFreelist[iLogsize];
- assert( iFirst>=0 );
- while( i>0 ){
- if( i<iFirst ) iFirst = i;
- i = MEM5LINK(i)->next;
- }
- memsys5Unlink(iFirst, iLogsize);
- return iFirst;
- }
- /*
- ** Return a block of memory of at least nBytes in size.
- ** Return NULL if unable. Return NULL if nBytes==0.
- **
- ** The caller guarantees that nByte positive.
- **
- ** The caller has obtained a mutex prior to invoking this
- ** routine so there is never any chance that two or more
- ** threads can be in this routine at the same time.
- */
- static void *memsys5MallocUnsafe(int nByte){
- int i; /* Index of a mem5.aPool[] slot */
- int iBin; /* Index into mem5.aiFreelist[] */
- int iFullSz; /* Size of allocation rounded up to power of 2 */
- int iLogsize; /* Log2 of iFullSz/POW2_MIN */
- /* nByte must be a positive */
- assert( nByte>0 );
- /* Keep track of the maximum allocation request. Even unfulfilled
- ** requests are counted */
- if( (u32)nByte>mem5.maxRequest ){
- mem5.maxRequest = nByte;
- }
- /* Abort if the requested allocation size is larger than the largest
- ** power of two that we can represent using 32-bit signed integers.
- */
- if( nByte > 0x40000000 ){
- return 0;
- }
- /* Round nByte up to the next valid power of two */
- for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
- /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
- ** block. If not, then split a block of the next larger power of
- ** two in order to create a new free block of size iLogsize.
- */
- for(iBin=iLogsize; mem5.aiFreelist[iBin]<0 && iBin<=LOGMAX; iBin++){}
- if( iBin>LOGMAX ){
- testcase( sqlite3GlobalConfig.xLog!=0 );
- sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
- return 0;
- }
- i = memsys5UnlinkFirst(iBin);
- while( iBin>iLogsize ){
- int newSize;
- iBin--;
- newSize = 1 << iBin;
- mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
- memsys5Link(i+newSize, iBin);
- }
- mem5.aCtrl[i] = iLogsize;
- /* Update allocator performance statistics. */
- mem5.nAlloc++;
- mem5.totalAlloc += iFullSz;
- mem5.totalExcess += iFullSz - nByte;
- mem5.currentCount++;
- mem5.currentOut += iFullSz;
- if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
- if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
- /* Return a pointer to the allocated memory. */
- return (void*)&mem5.zPool[i*mem5.szAtom];
- }
- /*
- ** Free an outstanding memory allocation.
- */
- static void memsys5FreeUnsafe(void *pOld){
- u32 size, iLogsize;
- int iBlock;
- /* Set iBlock to the index of the block pointed to by pOld in
- ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
- */
- iBlock = ((u8 *)pOld-mem5.zPool)/mem5.szAtom;
- /* Check that the pointer pOld points to a valid, non-free block. */
- assert( iBlock>=0 && iBlock<mem5.nBlock );
- assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
- assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
- iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
- size = 1<<iLogsize;
- assert( iBlock+size-1<(u32)mem5.nBlock );
- mem5.aCtrl[iBlock] |= CTRL_FREE;
- mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
- assert( mem5.currentCount>0 );
- assert( mem5.currentOut>=(size*mem5.szAtom) );
- mem5.currentCount--;
- mem5.currentOut -= size*mem5.szAtom;
- assert( mem5.currentOut>0 || mem5.currentCount==0 );
- assert( mem5.currentCount>0 || mem5.currentOut==0 );
- mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
- while( ALWAYS(iLogsize<LOGMAX) ){
- int iBuddy;
- if( (iBlock>>iLogsize) & 1 ){
- iBuddy = iBlock - size;
- }else{
- iBuddy = iBlock + size;
- }
- assert( iBuddy>=0 );
- if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break;
- if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
- memsys5Unlink(iBuddy, iLogsize);
- iLogsize++;
- if( iBuddy<iBlock ){
- mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
- mem5.aCtrl[iBlock] = 0;
- iBlock = iBuddy;
- }else{
- mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
- mem5.aCtrl[iBuddy] = 0;
- }
- size *= 2;
- }
- memsys5Link(iBlock, iLogsize);
- }
- /*
- ** Allocate nBytes of memory
- */
- static void *memsys5Malloc(int nBytes){
- sqlite3_int64 *p = 0;
- if( nBytes>0 ){
- memsys5Enter();
- p = memsys5MallocUnsafe(nBytes);
- memsys5Leave();
- }
- return (void*)p;
- }
- /*
- ** Free memory.
- **
- ** The outer layer memory allocator prevents this routine from
- ** being called with pPrior==0.
- */
- static void memsys5Free(void *pPrior){
- assert( pPrior!=0 );
- memsys5Enter();
- memsys5FreeUnsafe(pPrior);
- memsys5Leave();
- }
- /*
- ** Change the size of an existing memory allocation.
- **
- ** The outer layer memory allocator prevents this routine from
- ** being called with pPrior==0.
- **
- ** nBytes is always a value obtained from a prior call to
- ** memsys5Round(). Hence nBytes is always a non-negative power
- ** of two. If nBytes==0 that means that an oversize allocation
- ** (an allocation larger than 0x40000000) was requested and this
- ** routine should return 0 without freeing pPrior.
- */
- static void *memsys5Realloc(void *pPrior, int nBytes){
- int nOld;
- void *p;
- assert( pPrior!=0 );
- assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */
- assert( nBytes>=0 );
- if( nBytes==0 ){
- return 0;
- }
- nOld = memsys5Size(pPrior);
- if( nBytes<=nOld ){
- return pPrior;
- }
- memsys5Enter();
- p = memsys5MallocUnsafe(nBytes);
- if( p ){
- memcpy(p, pPrior, nOld);
- memsys5FreeUnsafe(pPrior);
- }
- memsys5Leave();
- return p;
- }
- /*
- ** Round up a request size to the next valid allocation size. If
- ** the allocation is too large to be handled by this allocation system,
- ** return 0.
- **
- ** All allocations must be a power of two and must be expressed by a
- ** 32-bit signed integer. Hence the largest allocation is 0x40000000
- ** or 1073741824 bytes.
- */
- static int memsys5Roundup(int n){
- int iFullSz;
- if( n > 0x40000000 ) return 0;
- for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2);
- return iFullSz;
- }
- /*
- ** Return the ceiling of the logarithm base 2 of iValue.
- **
- ** Examples: memsys5Log(1) -> 0
- ** memsys5Log(2) -> 1
- ** memsys5Log(4) -> 2
- ** memsys5Log(5) -> 3
- ** memsys5Log(8) -> 3
- ** memsys5Log(9) -> 4
- */
- static int memsys5Log(int iValue){
- int iLog;
- for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++);
- return iLog;
- }
- /*
- ** Initialize the memory allocator.
- **
- ** This routine is not threadsafe. The caller must be holding a mutex
- ** to prevent multiple threads from entering at the same time.
- */
- static int memsys5Init(void *NotUsed){
- int ii; /* Loop counter */
- int nByte; /* Number of bytes of memory available to this allocator */
- u8 *zByte; /* Memory usable by this allocator */
- int nMinLog; /* Log base 2 of minimum allocation size in bytes */
- int iOffset; /* An offset into mem5.aCtrl[] */
- UNUSED_PARAMETER(NotUsed);
- /* For the purposes of this routine, disable the mutex */
- mem5.mutex = 0;
- /* The size of a Mem5Link object must be a power of two. Verify that
- ** this is case.
- */
- assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
- nByte = sqlite3GlobalConfig.nHeap;
- zByte = (u8*)sqlite3GlobalConfig.pHeap;
- assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */
- /* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */
- nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
- mem5.szAtom = (1<<nMinLog);
- while( (int)sizeof(Mem5Link)>mem5.szAtom ){
- mem5.szAtom = mem5.szAtom << 1;
- }
- mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
- mem5.zPool = zByte;
- mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
- for(ii=0; ii<=LOGMAX; ii++){
- mem5.aiFreelist[ii] = -1;
- }
- iOffset = 0;
- for(ii=LOGMAX; ii>=0; ii--){
- int nAlloc = (1<<ii);
- if( (iOffset+nAlloc)<=mem5.nBlock ){
- mem5.aCtrl[iOffset] = ii | CTRL_FREE;
- memsys5Link(iOffset, ii);
- iOffset += nAlloc;
- }
- assert((iOffset+nAlloc)>mem5.nBlock);
- }
- /* If a mutex is required for normal operation, allocate one */
- if( sqlite3GlobalConfig.bMemstat==0 ){
- mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
- }
- return SQLITE_OK;
- }
- /*
- ** Deinitialize this module.
- */
- static void memsys5Shutdown(void *NotUsed){
- UNUSED_PARAMETER(NotUsed);
- mem5.mutex = 0;
- return;
- }
- #ifdef SQLITE_TEST
- /*
- ** Open the file indicated and write a log of all unfreed memory
- ** allocations into that log.
- */
- SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){
- FILE *out;
- int i, j, n;
- int nMinLog;
- if( zFilename==0 || zFilename[0]==0 ){
- out = stdout;
- }else{
- out = fopen(zFilename, "w");
- if( out==0 ){
- fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
- zFilename);
- return;
- }
- }
- memsys5Enter();
- nMinLog = memsys5Log(mem5.szAtom);
- for(i=0; i<=LOGMAX && i+nMinLog<32; i++){
- for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
- fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
- }
- fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
- fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
- fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
- fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
- fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
- fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
- fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
- fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
- memsys5Leave();
- if( out==stdout ){
- fflush(stdout);
- }else{
- fclose(out);
- }
- }
- #endif
- /*
- ** This routine is the only routine in this file with external
- ** linkage. It returns a pointer to a static sqlite3_mem_methods
- ** struct populated with the memsys5 methods.
- */
- SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){
- static const sqlite3_mem_methods memsys5Methods = {
- memsys5Malloc,
- memsys5Free,
- memsys5Realloc,
- memsys5Size,
- memsys5Roundup,
- memsys5Init,
- memsys5Shutdown,
- 0
- };
- return &memsys5Methods;
- }
- #endif /* SQLITE_ENABLE_MEMSYS5 */
- /************** End of mem5.c ************************************************/
- /************** Begin file mutex.c *******************************************/
- /*
- ** 2007 August 14
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement mutexes.
- **
- ** This file contains code that is common across all mutex implementations.
- */
- #if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT)
- /*
- ** For debugging purposes, record when the mutex subsystem is initialized
- ** and uninitialized so that we can assert() if there is an attempt to
- ** allocate a mutex while the system is uninitialized.
- */
- static SQLITE_WSD int mutexIsInit = 0;
- #endif /* SQLITE_DEBUG */
- #ifndef SQLITE_MUTEX_OMIT
- /*
- ** Initialize the mutex system.
- */
- SQLITE_PRIVATE int sqlite3MutexInit(void){
- int rc = SQLITE_OK;
- if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
- /* If the xMutexAlloc method has not been set, then the user did not
- ** install a mutex implementation via sqlite3_config() prior to
- ** sqlite3_initialize() being called. This block copies pointers to
- ** the default implementation into the sqlite3GlobalConfig structure.
- */
- sqlite3_mutex_methods const *pFrom;
- sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
- if( sqlite3GlobalConfig.bCoreMutex ){
- pFrom = sqlite3DefaultMutex();
- }else{
- pFrom = sqlite3NoopMutex();
- }
- memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
- memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
- sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
- pTo->xMutexAlloc = pFrom->xMutexAlloc;
- }
- rc = sqlite3GlobalConfig.mutex.xMutexInit();
- #ifdef SQLITE_DEBUG
- GLOBAL(int, mutexIsInit) = 1;
- #endif
- return rc;
- }
- /*
- ** Shutdown the mutex system. This call frees resources allocated by
- ** sqlite3MutexInit().
- */
- SQLITE_PRIVATE int sqlite3MutexEnd(void){
- int rc = SQLITE_OK;
- if( sqlite3GlobalConfig.mutex.xMutexEnd ){
- rc = sqlite3GlobalConfig.mutex.xMutexEnd();
- }
- #ifdef SQLITE_DEBUG
- GLOBAL(int, mutexIsInit) = 0;
- #endif
- return rc;
- }
- /*
- ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
- */
- SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int id){
- #ifndef SQLITE_OMIT_AUTOINIT
- if( sqlite3_initialize() ) return 0;
- #endif
- return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
- }
- SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){
- if( !sqlite3GlobalConfig.bCoreMutex ){
- return 0;
- }
- assert( GLOBAL(int, mutexIsInit) );
- return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
- }
- /*
- ** Free a dynamic mutex.
- */
- SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){
- if( p ){
- sqlite3GlobalConfig.mutex.xMutexFree(p);
- }
- }
- /*
- ** Obtain the mutex p. If some other thread already has the mutex, block
- ** until it can be obtained.
- */
- SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){
- if( p ){
- sqlite3GlobalConfig.mutex.xMutexEnter(p);
- }
- }
- /*
- ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
- ** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
- */
- SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){
- int rc = SQLITE_OK;
- if( p ){
- return sqlite3GlobalConfig.mutex.xMutexTry(p);
- }
- return rc;
- }
- /*
- ** The sqlite3_mutex_leave() routine exits a mutex that was previously
- ** entered by the same thread. The behavior is undefined if the mutex
- ** is not currently entered. If a NULL pointer is passed as an argument
- ** this function is a no-op.
- */
- SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){
- if( p ){
- sqlite3GlobalConfig.mutex.xMutexLeave(p);
- }
- }
- #ifndef NDEBUG
- /*
- ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- ** intended for use inside assert() statements.
- */
- SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){
- return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
- }
- SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){
- return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
- }
- #endif
- #endif /* !defined(SQLITE_MUTEX_OMIT) */
- /************** End of mutex.c ***********************************************/
- /************** Begin file mutex_noop.c **************************************/
- /*
- ** 2008 October 07
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement mutexes.
- **
- ** This implementation in this file does not provide any mutual
- ** exclusion and is thus suitable for use only in applications
- ** that use SQLite in a single thread. The routines defined
- ** here are place-holders. Applications can substitute working
- ** mutex routines at start-time using the
- **
- ** sqlite3_config(SQLITE_CONFIG_MUTEX,...)
- **
- ** interface.
- **
- ** If compiled with SQLITE_DEBUG, then additional logic is inserted
- ** that does error checking on mutexes to make sure they are being
- ** called correctly.
- */
- #ifndef SQLITE_MUTEX_OMIT
- #ifndef SQLITE_DEBUG
- /*
- ** Stub routines for all mutex methods.
- **
- ** This routines provide no mutual exclusion or error checking.
- */
- static int noopMutexInit(void){ return SQLITE_OK; }
- static int noopMutexEnd(void){ return SQLITE_OK; }
- static sqlite3_mutex *noopMutexAlloc(int id){
- UNUSED_PARAMETER(id);
- return (sqlite3_mutex*)8;
- }
- static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
- static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
- static int noopMutexTry(sqlite3_mutex *p){
- UNUSED_PARAMETER(p);
- return SQLITE_OK;
- }
- static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){
- static const sqlite3_mutex_methods sMutex = {
- noopMutexInit,
- noopMutexEnd,
- noopMutexAlloc,
- noopMutexFree,
- noopMutexEnter,
- noopMutexTry,
- noopMutexLeave,
- 0,
- 0,
- };
- return &sMutex;
- }
- #endif /* !SQLITE_DEBUG */
- #ifdef SQLITE_DEBUG
- /*
- ** In this implementation, error checking is provided for testing
- ** and debugging purposes. The mutexes still do not provide any
- ** mutual exclusion.
- */
- /*
- ** The mutex object
- */
- typedef struct sqlite3_debug_mutex {
- int id; /* The mutex type */
- int cnt; /* Number of entries without a matching leave */
- } sqlite3_debug_mutex;
- /*
- ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- ** intended for use inside assert() statements.
- */
- static int debugMutexHeld(sqlite3_mutex *pX){
- sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
- return p==0 || p->cnt>0;
- }
- static int debugMutexNotheld(sqlite3_mutex *pX){
- sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
- return p==0 || p->cnt==0;
- }
- /*
- ** Initialize and deinitialize the mutex subsystem.
- */
- static int debugMutexInit(void){ return SQLITE_OK; }
- static int debugMutexEnd(void){ return SQLITE_OK; }
- /*
- ** The sqlite3_mutex_alloc() routine allocates a new
- ** mutex and returns a pointer to it. If it returns NULL
- ** that means that a mutex could not be allocated.
- */
- static sqlite3_mutex *debugMutexAlloc(int id){
- static sqlite3_debug_mutex aStatic[6];
- sqlite3_debug_mutex *pNew = 0;
- switch( id ){
- case SQLITE_MUTEX_FAST:
- case SQLITE_MUTEX_RECURSIVE: {
- pNew = sqlite3Malloc(sizeof(*pNew));
- if( pNew ){
- pNew->id = id;
- pNew->cnt = 0;
- }
- break;
- }
- default: {
- assert( id-2 >= 0 );
- assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
- pNew = &aStatic[id-2];
- pNew->id = id;
- break;
- }
- }
- return (sqlite3_mutex*)pNew;
- }
- /*
- ** This routine deallocates a previously allocated mutex.
- */
- static void debugMutexFree(sqlite3_mutex *pX){
- sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
- assert( p->cnt==0 );
- assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
- sqlite3_free(p);
- }
- /*
- ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- ** to enter a mutex. If another thread is already within the mutex,
- ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
- ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
- ** be entered multiple times by the same thread. In such cases the,
- ** mutex must be exited an equal number of times before another thread
- ** can enter. If the same thread tries to enter any other kind of mutex
- ** more than once, the behavior is undefined.
- */
- static void debugMutexEnter(sqlite3_mutex *pX){
- sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
- assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
- p->cnt++;
- }
- static int debugMutexTry(sqlite3_mutex *pX){
- sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
- assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
- p->cnt++;
- return SQLITE_OK;
- }
- /*
- ** The sqlite3_mutex_leave() routine exits a mutex that was
- ** previously entered by the same thread. The behavior
- ** is undefined if the mutex is not currently entered or
- ** is not currently allocated. SQLite will never do either.
- */
- static void debugMutexLeave(sqlite3_mutex *pX){
- sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
- assert( debugMutexHeld(pX) );
- p->cnt--;
- assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
- }
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){
- static const sqlite3_mutex_methods sMutex = {
- debugMutexInit,
- debugMutexEnd,
- debugMutexAlloc,
- debugMutexFree,
- debugMutexEnter,
- debugMutexTry,
- debugMutexLeave,
- debugMutexHeld,
- debugMutexNotheld
- };
- return &sMutex;
- }
- #endif /* SQLITE_DEBUG */
- /*
- ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
- ** is used regardless of the run-time threadsafety setting.
- */
- #ifdef SQLITE_MUTEX_NOOP
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
- return sqlite3NoopMutex();
- }
- #endif /* defined(SQLITE_MUTEX_NOOP) */
- #endif /* !defined(SQLITE_MUTEX_OMIT) */
- /************** End of mutex_noop.c ******************************************/
- /************** Begin file mutex_os2.c ***************************************/
- /*
- ** 2007 August 28
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement mutexes for OS/2
- */
- /*
- ** The code in this file is only used if SQLITE_MUTEX_OS2 is defined.
- ** See the mutex.h file for details.
- */
- #ifdef SQLITE_MUTEX_OS2
- /********************** OS/2 Mutex Implementation **********************
- **
- ** This implementation of mutexes is built using the OS/2 API.
- */
- /*
- ** The mutex object
- ** Each recursive mutex is an instance of the following structure.
- */
- struct sqlite3_mutex {
- HMTX mutex; /* Mutex controlling the lock */
- int id; /* Mutex type */
- #ifdef SQLITE_DEBUG
- int trace; /* True to trace changes */
- #endif
- };
- #ifdef SQLITE_DEBUG
- #define SQLITE3_MUTEX_INITIALIZER { 0, 0, 0 }
- #else
- #define SQLITE3_MUTEX_INITIALIZER { 0, 0 }
- #endif
- /*
- ** Initialize and deinitialize the mutex subsystem.
- */
- static int os2MutexInit(void){ return SQLITE_OK; }
- static int os2MutexEnd(void){ return SQLITE_OK; }
- /*
- ** The sqlite3_mutex_alloc() routine allocates a new
- ** mutex and returns a pointer to it. If it returns NULL
- ** that means that a mutex could not be allocated.
- ** SQLite will unwind its stack and return an error. The argument
- ** to sqlite3_mutex_alloc() is one of these integer constants:
- **
- ** <ul>
- ** <li> SQLITE_MUTEX_FAST
- ** <li> SQLITE_MUTEX_RECURSIVE
- ** <li> SQLITE_MUTEX_STATIC_MASTER
- ** <li> SQLITE_MUTEX_STATIC_MEM
- ** <li> SQLITE_MUTEX_STATIC_MEM2
- ** <li> SQLITE_MUTEX_STATIC_PRNG
- ** <li> SQLITE_MUTEX_STATIC_LRU
- ** <li> SQLITE_MUTEX_STATIC_LRU2
- ** </ul>
- **
- ** The first two constants cause sqlite3_mutex_alloc() to create
- ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
- ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
- ** The mutex implementation does not need to make a distinction
- ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
- ** not want to. But SQLite will only request a recursive mutex in
- ** cases where it really needs one. If a faster non-recursive mutex
- ** implementation is available on the host platform, the mutex subsystem
- ** might return such a mutex in response to SQLITE_MUTEX_FAST.
- **
- ** The other allowed parameters to sqlite3_mutex_alloc() each return
- ** a pointer to a static preexisting mutex. Six static mutexes are
- ** used by the current version of SQLite. Future versions of SQLite
- ** may add additional static mutexes. Static mutexes are for internal
- ** use by SQLite only. Applications that use SQLite mutexes should
- ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
- ** SQLITE_MUTEX_RECURSIVE.
- **
- ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
- ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
- ** returns a different mutex on every call. But for the static
- ** mutex types, the same mutex is returned on every call that has
- ** the same type number.
- */
- static sqlite3_mutex *os2MutexAlloc(int iType){
- sqlite3_mutex *p = NULL;
- switch( iType ){
- case SQLITE_MUTEX_FAST:
- case SQLITE_MUTEX_RECURSIVE: {
- p = sqlite3MallocZero( sizeof(*p) );
- if( p ){
- p->id = iType;
- if( DosCreateMutexSem( 0, &p->mutex, 0, FALSE ) != NO_ERROR ){
- sqlite3_free( p );
- p = NULL;
- }
- }
- break;
- }
- default: {
- static volatile int isInit = 0;
- static sqlite3_mutex staticMutexes[6] = {
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- };
- if ( !isInit ){
- APIRET rc;
- PTIB ptib;
- PPIB ppib;
- HMTX mutex;
- char name[32];
- DosGetInfoBlocks( &ptib, &ppib );
- sqlite3_snprintf( sizeof(name), name, "\\SEM32\\SQLITE%04x",
- ppib->pib_ulpid );
- while( !isInit ){
- mutex = 0;
- rc = DosCreateMutexSem( name, &mutex, 0, FALSE);
- if( rc == NO_ERROR ){
- unsigned int i;
- if( !isInit ){
- for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){
- DosCreateMutexSem( 0, &staticMutexes[i].mutex, 0, FALSE );
- }
- isInit = 1;
- }
- DosCloseMutexSem( mutex );
- }else if( rc == ERROR_DUPLICATE_NAME ){
- DosSleep( 1 );
- }else{
- return p;
- }
- }
- }
- assert( iType-2 >= 0 );
- assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
- p = &staticMutexes[iType-2];
- p->id = iType;
- break;
- }
- }
- return p;
- }
- /*
- ** This routine deallocates a previously allocated mutex.
- ** SQLite is careful to deallocate every mutex that it allocates.
- */
- static void os2MutexFree(sqlite3_mutex *p){
- #ifdef SQLITE_DEBUG
- TID tid;
- PID pid;
- ULONG ulCount;
- DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
- assert( ulCount==0 );
- assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
- #endif
- DosCloseMutexSem( p->mutex );
- sqlite3_free( p );
- }
- #ifdef SQLITE_DEBUG
- /*
- ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- ** intended for use inside assert() statements.
- */
- static int os2MutexHeld(sqlite3_mutex *p){
- TID tid;
- PID pid;
- ULONG ulCount;
- PTIB ptib;
- DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
- if( ulCount==0 || ( ulCount>1 && p->id!=SQLITE_MUTEX_RECURSIVE ) )
- return 0;
- DosGetInfoBlocks(&ptib, NULL);
- return tid==ptib->tib_ptib2->tib2_ultid;
- }
- static int os2MutexNotheld(sqlite3_mutex *p){
- TID tid;
- PID pid;
- ULONG ulCount;
- PTIB ptib;
- DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
- if( ulCount==0 )
- return 1;
- DosGetInfoBlocks(&ptib, NULL);
- return tid!=ptib->tib_ptib2->tib2_ultid;
- }
- static void os2MutexTrace(sqlite3_mutex *p, char *pAction){
- TID tid;
- PID pid;
- ULONG ulCount;
- DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
- printf("%s mutex %p (%d) with nRef=%ld\n", pAction, (void*)p, p->trace, ulCount);
- }
- #endif
- /*
- ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- ** to enter a mutex. If another thread is already within the mutex,
- ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
- ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
- ** be entered multiple times by the same thread. In such cases the,
- ** mutex must be exited an equal number of times before another thread
- ** can enter. If the same thread tries to enter any other kind of mutex
- ** more than once, the behavior is undefined.
- */
- static void os2MutexEnter(sqlite3_mutex *p){
- assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );
- DosRequestMutexSem(p->mutex, SEM_INDEFINITE_WAIT);
- #ifdef SQLITE_DEBUG
- if( p->trace ) os2MutexTrace(p, "enter");
- #endif
- }
- static int os2MutexTry(sqlite3_mutex *p){
- int rc = SQLITE_BUSY;
- assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );
- if( DosRequestMutexSem(p->mutex, SEM_IMMEDIATE_RETURN) == NO_ERROR ) {
- rc = SQLITE_OK;
- #ifdef SQLITE_DEBUG
- if( p->trace ) os2MutexTrace(p, "try");
- #endif
- }
- return rc;
- }
- /*
- ** The sqlite3_mutex_leave() routine exits a mutex that was
- ** previously entered by the same thread. The behavior
- ** is undefined if the mutex is not currently entered or
- ** is not currently allocated. SQLite will never do either.
- */
- static void os2MutexLeave(sqlite3_mutex *p){
- assert( os2MutexHeld(p) );
- DosReleaseMutexSem(p->mutex);
- #ifdef SQLITE_DEBUG
- if( p->trace ) os2MutexTrace(p, "leave");
- #endif
- }
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
- static const sqlite3_mutex_methods sMutex = {
- os2MutexInit,
- os2MutexEnd,
- os2MutexAlloc,
- os2MutexFree,
- os2MutexEnter,
- os2MutexTry,
- os2MutexLeave,
- #ifdef SQLITE_DEBUG
- os2MutexHeld,
- os2MutexNotheld
- #else
- 0,
- 0
- #endif
- };
- return &sMutex;
- }
- #endif /* SQLITE_MUTEX_OS2 */
- /************** End of mutex_os2.c *******************************************/
- /************** Begin file mutex_unix.c **************************************/
- /*
- ** 2007 August 28
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement mutexes for pthreads
- */
- /*
- ** The code in this file is only used if we are compiling threadsafe
- ** under unix with pthreads.
- **
- ** Note that this implementation requires a version of pthreads that
- ** supports recursive mutexes.
- */
- #ifdef SQLITE_MUTEX_PTHREADS
- #include <pthread.h>
- /*
- ** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields
- ** are necessary under two condidtions: (1) Debug builds and (2) using
- ** home-grown mutexes. Encapsulate these conditions into a single #define.
- */
- #if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX)
- # define SQLITE_MUTEX_NREF 1
- #else
- # define SQLITE_MUTEX_NREF 0
- #endif
- /*
- ** Each recursive mutex is an instance of the following structure.
- */
- struct sqlite3_mutex {
- pthread_mutex_t mutex; /* Mutex controlling the lock */
- #if SQLITE_MUTEX_NREF
- int id; /* Mutex type */
- volatile int nRef; /* Number of entrances */
- volatile pthread_t owner; /* Thread that is within this mutex */
- int trace; /* True to trace changes */
- #endif
- };
- #if SQLITE_MUTEX_NREF
- #define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0, 0, (pthread_t)0, 0 }
- #else
- #define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
- #endif
- /*
- ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- ** intended for use only inside assert() statements. On some platforms,
- ** there might be race conditions that can cause these routines to
- ** deliver incorrect results. In particular, if pthread_equal() is
- ** not an atomic operation, then these routines might delivery
- ** incorrect results. On most platforms, pthread_equal() is a
- ** comparison of two integers and is therefore atomic. But we are
- ** told that HPUX is not such a platform. If so, then these routines
- ** will not always work correctly on HPUX.
- **
- ** On those platforms where pthread_equal() is not atomic, SQLite
- ** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to
- ** make sure no assert() statements are evaluated and hence these
- ** routines are never called.
- */
- #if !defined(NDEBUG) || defined(SQLITE_DEBUG)
- static int pthreadMutexHeld(sqlite3_mutex *p){
- return (p->nRef!=0 && pthread_equal(p->owner, pthread_self()));
- }
- static int pthreadMutexNotheld(sqlite3_mutex *p){
- return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0;
- }
- #endif
- /*
- ** Initialize and deinitialize the mutex subsystem.
- */
- static int pthreadMutexInit(void){ return SQLITE_OK; }
- static int pthreadMutexEnd(void){ return SQLITE_OK; }
- /*
- ** The sqlite3_mutex_alloc() routine allocates a new
- ** mutex and returns a pointer to it. If it returns NULL
- ** that means that a mutex could not be allocated. SQLite
- ** will unwind its stack and return an error. The argument
- ** to sqlite3_mutex_alloc() is one of these integer constants:
- **
- ** <ul>
- ** <li> SQLITE_MUTEX_FAST
- ** <li> SQLITE_MUTEX_RECURSIVE
- ** <li> SQLITE_MUTEX_STATIC_MASTER
- ** <li> SQLITE_MUTEX_STATIC_MEM
- ** <li> SQLITE_MUTEX_STATIC_MEM2
- ** <li> SQLITE_MUTEX_STATIC_PRNG
- ** <li> SQLITE_MUTEX_STATIC_LRU
- ** <li> SQLITE_MUTEX_STATIC_PMEM
- ** </ul>
- **
- ** The first two constants cause sqlite3_mutex_alloc() to create
- ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
- ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
- ** The mutex implementation does not need to make a distinction
- ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
- ** not want to. But SQLite will only request a recursive mutex in
- ** cases where it really needs one. If a faster non-recursive mutex
- ** implementation is available on the host platform, the mutex subsystem
- ** might return such a mutex in response to SQLITE_MUTEX_FAST.
- **
- ** The other allowed parameters to sqlite3_mutex_alloc() each return
- ** a pointer to a static preexisting mutex. Six static mutexes are
- ** used by the current version of SQLite. Future versions of SQLite
- ** may add additional static mutexes. Static mutexes are for internal
- ** use by SQLite only. Applications that use SQLite mutexes should
- ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
- ** SQLITE_MUTEX_RECURSIVE.
- **
- ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
- ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
- ** returns a different mutex on every call. But for the static
- ** mutex types, the same mutex is returned on every call that has
- ** the same type number.
- */
- static sqlite3_mutex *pthreadMutexAlloc(int iType){
- static sqlite3_mutex staticMutexes[] = {
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER
- };
- sqlite3_mutex *p;
- switch( iType ){
- case SQLITE_MUTEX_RECURSIVE: {
- p = sqlite3MallocZero( sizeof(*p) );
- if( p ){
- #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
- /* If recursive mutexes are not available, we will have to
- ** build our own. See below. */
- pthread_mutex_init(&p->mutex, 0);
- #else
- /* Use a recursive mutex if it is available */
- pthread_mutexattr_t recursiveAttr;
- pthread_mutexattr_init(&recursiveAttr);
- pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&p->mutex, &recursiveAttr);
- pthread_mutexattr_destroy(&recursiveAttr);
- #endif
- #if SQLITE_MUTEX_NREF
- p->id = iType;
- #endif
- }
- break;
- }
- case SQLITE_MUTEX_FAST: {
- p = sqlite3MallocZero( sizeof(*p) );
- if( p ){
- #if SQLITE_MUTEX_NREF
- p->id = iType;
- #endif
- pthread_mutex_init(&p->mutex, 0);
- }
- break;
- }
- default: {
- assert( iType-2 >= 0 );
- assert( iType-2 < ArraySize(staticMutexes) );
- p = &staticMutexes[iType-2];
- #if SQLITE_MUTEX_NREF
- p->id = iType;
- #endif
- break;
- }
- }
- return p;
- }
- /*
- ** This routine deallocates a previously
- ** allocated mutex. SQLite is careful to deallocate every
- ** mutex that it allocates.
- */
- static void pthreadMutexFree(sqlite3_mutex *p){
- assert( p->nRef==0 );
- assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
- pthread_mutex_destroy(&p->mutex);
- sqlite3_free(p);
- }
- /*
- ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- ** to enter a mutex. If another thread is already within the mutex,
- ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
- ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
- ** be entered multiple times by the same thread. In such cases the,
- ** mutex must be exited an equal number of times before another thread
- ** can enter. If the same thread tries to enter any other kind of mutex
- ** more than once, the behavior is undefined.
- */
- static void pthreadMutexEnter(sqlite3_mutex *p){
- assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
- #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
- /* If recursive mutexes are not available, then we have to grow
- ** our own. This implementation assumes that pthread_equal()
- ** is atomic - that it cannot be deceived into thinking self
- ** and p->owner are equal if p->owner changes between two values
- ** that are not equal to self while the comparison is taking place.
- ** This implementation also assumes a coherent cache - that
- ** separate processes cannot read different values from the same
- ** address at the same time. If either of these two conditions
- ** are not met, then the mutexes will fail and problems will result.
- */
- {
- pthread_t self = pthread_self();
- if( p->nRef>0 && pthread_equal(p->owner, self) ){
- p->nRef++;
- }else{
- pthread_mutex_lock(&p->mutex);
- assert( p->nRef==0 );
- p->owner = self;
- p->nRef = 1;
- }
- }
- #else
- /* Use the built-in recursive mutexes if they are available.
- */
- pthread_mutex_lock(&p->mutex);
- #if SQLITE_MUTEX_NREF
- assert( p->nRef>0 || p->owner==0 );
- p->owner = pthread_self();
- p->nRef++;
- #endif
- #endif
- #ifdef SQLITE_DEBUG
- if( p->trace ){
- printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
- }
- #endif
- }
- static int pthreadMutexTry(sqlite3_mutex *p){
- int rc;
- assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
- #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
- /* If recursive mutexes are not available, then we have to grow
- ** our own. This implementation assumes that pthread_equal()
- ** is atomic - that it cannot be deceived into thinking self
- ** and p->owner are equal if p->owner changes between two values
- ** that are not equal to self while the comparison is taking place.
- ** This implementation also assumes a coherent cache - that
- ** separate processes cannot read different values from the same
- ** address at the same time. If either of these two conditions
- ** are not met, then the mutexes will fail and problems will result.
- */
- {
- pthread_t self = pthread_self();
- if( p->nRef>0 && pthread_equal(p->owner, self) ){
- p->nRef++;
- rc = SQLITE_OK;
- }else if( pthread_mutex_trylock(&p->mutex)==0 ){
- assert( p->nRef==0 );
- p->owner = self;
- p->nRef = 1;
- rc = SQLITE_OK;
- }else{
- rc = SQLITE_BUSY;
- }
- }
- #else
- /* Use the built-in recursive mutexes if they are available.
- */
- if( pthread_mutex_trylock(&p->mutex)==0 ){
- #if SQLITE_MUTEX_NREF
- p->owner = pthread_self();
- p->nRef++;
- #endif
- rc = SQLITE_OK;
- }else{
- rc = SQLITE_BUSY;
- }
- #endif
- #ifdef SQLITE_DEBUG
- if( rc==SQLITE_OK && p->trace ){
- printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
- }
- #endif
- return rc;
- }
- /*
- ** The sqlite3_mutex_leave() routine exits a mutex that was
- ** previously entered by the same thread. The behavior
- ** is undefined if the mutex is not currently entered or
- ** is not currently allocated. SQLite will never do either.
- */
- static void pthreadMutexLeave(sqlite3_mutex *p){
- assert( pthreadMutexHeld(p) );
- #if SQLITE_MUTEX_NREF
- p->nRef--;
- if( p->nRef==0 ) p->owner = 0;
- #endif
- assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
- #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
- if( p->nRef==0 ){
- pthread_mutex_unlock(&p->mutex);
- }
- #else
- pthread_mutex_unlock(&p->mutex);
- #endif
- #ifdef SQLITE_DEBUG
- if( p->trace ){
- printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
- }
- #endif
- }
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
- static const sqlite3_mutex_methods sMutex = {
- pthreadMutexInit,
- pthreadMutexEnd,
- pthreadMutexAlloc,
- pthreadMutexFree,
- pthreadMutexEnter,
- pthreadMutexTry,
- pthreadMutexLeave,
- #ifdef SQLITE_DEBUG
- pthreadMutexHeld,
- pthreadMutexNotheld
- #else
- 0,
- 0
- #endif
- };
- return &sMutex;
- }
- #endif /* SQLITE_MUTEX_PTHREADS */
- /************** End of mutex_unix.c ******************************************/
- /************** Begin file mutex_w32.c ***************************************/
- /*
- ** 2007 August 14
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains the C functions that implement mutexes for win32
- */
- /*
- ** The code in this file is only used if we are compiling multithreaded
- ** on a win32 system.
- */
- #ifdef SQLITE_MUTEX_W32
- /*
- ** Each recursive mutex is an instance of the following structure.
- */
- struct sqlite3_mutex {
- CRITICAL_SECTION mutex; /* Mutex controlling the lock */
- int id; /* Mutex type */
- #ifdef SQLITE_DEBUG
- volatile int nRef; /* Number of enterances */
- volatile DWORD owner; /* Thread holding this mutex */
- int trace; /* True to trace changes */
- #endif
- };
- #define SQLITE_W32_MUTEX_INITIALIZER { 0 }
- #ifdef SQLITE_DEBUG
- #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, 0L, (DWORD)0, 0 }
- #else
- #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0 }
- #endif
- /*
- ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
- ** or WinCE. Return false (zero) for Win95, Win98, or WinME.
- **
- ** Here is an interesting observation: Win95, Win98, and WinME lack
- ** the LockFileEx() API. But we can still statically link against that
- ** API as long as we don't call it win running Win95/98/ME. A call to
- ** this routine is used to determine if the host is Win95/98/ME or
- ** WinNT/2K/XP so that we will know whether or not we can safely call
- ** the LockFileEx() API.
- **
- ** mutexIsNT() is only used for the TryEnterCriticalSection() API call,
- ** which is only available if your application was compiled with
- ** _WIN32_WINNT defined to a value >= 0x0400. Currently, the only
- ** call to TryEnterCriticalSection() is #ifdef'ed out, so #ifdef
- ** this out as well.
- */
- #if 0
- #if SQLITE_OS_WINCE
- # define mutexIsNT() (1)
- #else
- static int mutexIsNT(void){
- static int osType = 0;
- if( osType==0 ){
- OSVERSIONINFO sInfo;
- sInfo.dwOSVersionInfoSize = sizeof(sInfo);
- GetVersionEx(&sInfo);
- osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
- }
- return osType==2;
- }
- #endif /* SQLITE_OS_WINCE */
- #endif
- #ifdef SQLITE_DEBUG
- /*
- ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- ** intended for use only inside assert() statements.
- */
- static int winMutexHeld(sqlite3_mutex *p){
- return p->nRef!=0 && p->owner==GetCurrentThreadId();
- }
- static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){
- return p->nRef==0 || p->owner!=tid;
- }
- static int winMutexNotheld(sqlite3_mutex *p){
- DWORD tid = GetCurrentThreadId();
- return winMutexNotheld2(p, tid);
- }
- #endif
- /*
- ** Initialize and deinitialize the mutex subsystem.
- */
- static sqlite3_mutex winMutex_staticMutexes[6] = {
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER,
- SQLITE3_MUTEX_INITIALIZER
- };
- static int winMutex_isInit = 0;
- /* As winMutexInit() and winMutexEnd() are called as part
- ** of the sqlite3_initialize and sqlite3_shutdown()
- ** processing, the "interlocked" magic is probably not
- ** strictly necessary.
- */
- static long winMutex_lock = 0;
- static int winMutexInit(void){
- /* The first to increment to 1 does actual initialization */
- if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){
- int i;
- for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
- InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
- }
- winMutex_isInit = 1;
- }else{
- /* Someone else is in the process of initing the static mutexes */
- while( !winMutex_isInit ){
- Sleep(1);
- }
- }
- return SQLITE_OK;
- }
- static int winMutexEnd(void){
- /* The first to decrement to 0 does actual shutdown
- ** (which should be the last to shutdown.) */
- if( InterlockedCompareExchange(&winMutex_lock, 0, 1)==1 ){
- if( winMutex_isInit==1 ){
- int i;
- for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
- DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
- }
- winMutex_isInit = 0;
- }
- }
- return SQLITE_OK;
- }
- /*
- ** The sqlite3_mutex_alloc() routine allocates a new
- ** mutex and returns a pointer to it. If it returns NULL
- ** that means that a mutex could not be allocated. SQLite
- ** will unwind its stack and return an error. The argument
- ** to sqlite3_mutex_alloc() is one of these integer constants:
- **
- ** <ul>
- ** <li> SQLITE_MUTEX_FAST
- ** <li> SQLITE_MUTEX_RECURSIVE
- ** <li> SQLITE_MUTEX_STATIC_MASTER
- ** <li> SQLITE_MUTEX_STATIC_MEM
- ** <li> SQLITE_MUTEX_STATIC_MEM2
- ** <li> SQLITE_MUTEX_STATIC_PRNG
- ** <li> SQLITE_MUTEX_STATIC_LRU
- ** <li> SQLITE_MUTEX_STATIC_PMEM
- ** </ul>
- **
- ** The first two constants cause sqlite3_mutex_alloc() to create
- ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
- ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
- ** The mutex implementation does not need to make a distinction
- ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
- ** not want to. But SQLite will only request a recursive mutex in
- ** cases where it really needs one. If a faster non-recursive mutex
- ** implementation is available on the host platform, the mutex subsystem
- ** might return such a mutex in response to SQLITE_MUTEX_FAST.
- **
- ** The other allowed parameters to sqlite3_mutex_alloc() each return
- ** a pointer to a static preexisting mutex. Six static mutexes are
- ** used by the current version of SQLite. Future versions of SQLite
- ** may add additional static mutexes. Static mutexes are for internal
- ** use by SQLite only. Applications that use SQLite mutexes should
- ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
- ** SQLITE_MUTEX_RECURSIVE.
- **
- ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
- ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
- ** returns a different mutex on every call. But for the static
- ** mutex types, the same mutex is returned on every call that has
- ** the same type number.
- */
- static sqlite3_mutex *winMutexAlloc(int iType){
- sqlite3_mutex *p;
- switch( iType ){
- case SQLITE_MUTEX_FAST:
- case SQLITE_MUTEX_RECURSIVE: {
- p = sqlite3MallocZero( sizeof(*p) );
- if( p ){
- #ifdef SQLITE_DEBUG
- p->id = iType;
- #endif
- InitializeCriticalSection(&p->mutex);
- }
- break;
- }
- default: {
- assert( winMutex_isInit==1 );
- assert( iType-2 >= 0 );
- assert( iType-2 < ArraySize(winMutex_staticMutexes) );
- p = &winMutex_staticMutexes[iType-2];
- #ifdef SQLITE_DEBUG
- p->id = iType;
- #endif
- break;
- }
- }
- return p;
- }
- /*
- ** This routine deallocates a previously
- ** allocated mutex. SQLite is careful to deallocate every
- ** mutex that it allocates.
- */
- static void winMutexFree(sqlite3_mutex *p){
- assert( p );
- assert( p->nRef==0 && p->owner==0 );
- assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
- DeleteCriticalSection(&p->mutex);
- sqlite3_free(p);
- }
- /*
- ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- ** to enter a mutex. If another thread is already within the mutex,
- ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
- ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
- ** be entered multiple times by the same thread. In such cases the,
- ** mutex must be exited an equal number of times before another thread
- ** can enter. If the same thread tries to enter any other kind of mutex
- ** more than once, the behavior is undefined.
- */
- static void winMutexEnter(sqlite3_mutex *p){
- #ifdef SQLITE_DEBUG
- DWORD tid = GetCurrentThreadId();
- assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
- #endif
- EnterCriticalSection(&p->mutex);
- #ifdef SQLITE_DEBUG
- assert( p->nRef>0 || p->owner==0 );
- p->owner = tid;
- p->nRef++;
- if( p->trace ){
- printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
- }
- #endif
- }
- static int winMutexTry(sqlite3_mutex *p){
- #ifndef NDEBUG
- DWORD tid = GetCurrentThreadId();
- #endif
- int rc = SQLITE_BUSY;
- assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
- /*
- ** The sqlite3_mutex_try() routine is very rarely used, and when it
- ** is used it is merely an optimization. So it is OK for it to always
- ** fail.
- **
- ** The TryEnterCriticalSection() interface is only available on WinNT.
- ** And some windows compilers complain if you try to use it without
- ** first doing some #defines that prevent SQLite from building on Win98.
- ** For that reason, we will omit this optimization for now. See
- ** ticket #2685.
- */
- #if 0
- if( mutexIsNT() && TryEnterCriticalSection(&p->mutex) ){
- p->owner = tid;
- p->nRef++;
- rc = SQLITE_OK;
- }
- #else
- UNUSED_PARAMETER(p);
- #endif
- #ifdef SQLITE_DEBUG
- if( rc==SQLITE_OK && p->trace ){
- printf("try mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
- }
- #endif
- return rc;
- }
- /*
- ** The sqlite3_mutex_leave() routine exits a mutex that was
- ** previously entered by the same thread. The behavior
- ** is undefined if the mutex is not currently entered or
- ** is not currently allocated. SQLite will never do either.
- */
- static void winMutexLeave(sqlite3_mutex *p){
- #ifndef NDEBUG
- DWORD tid = GetCurrentThreadId();
- assert( p->nRef>0 );
- assert( p->owner==tid );
- p->nRef--;
- if( p->nRef==0 ) p->owner = 0;
- assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
- #endif
- LeaveCriticalSection(&p->mutex);
- #ifdef SQLITE_DEBUG
- if( p->trace ){
- printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
- }
- #endif
- }
- SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
- static const sqlite3_mutex_methods sMutex = {
- winMutexInit,
- winMutexEnd,
- winMutexAlloc,
- winMutexFree,
- winMutexEnter,
- winMutexTry,
- winMutexLeave,
- #ifdef SQLITE_DEBUG
- winMutexHeld,
- winMutexNotheld
- #else
- 0,
- 0
- #endif
- };
- return &sMutex;
- }
- #endif /* SQLITE_MUTEX_W32 */
- /************** End of mutex_w32.c *******************************************/
- /************** Begin file malloc.c ******************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- **
- ** Memory allocation functions used throughout sqlite.
- */
- /* #include <stdarg.h> */
- /*
- ** Attempt to release up to n bytes of non-essential memory currently
- ** held by SQLite. An example of non-essential memory is memory used to
- ** cache database pages that are not currently in use.
- */
- SQLITE_API int sqlite3_release_memory(int n){
- #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
- return sqlite3PcacheReleaseMemory(n);
- #else
- /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
- ** is a no-op returning zero if SQLite is not compiled with
- ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */
- UNUSED_PARAMETER(n);
- return 0;
- #endif
- }
- /*
- ** An instance of the following object records the location of
- ** each unused scratch buffer.
- */
- typedef struct ScratchFreeslot {
- struct ScratchFreeslot *pNext; /* Next unused scratch buffer */
- } ScratchFreeslot;
- /*
- ** State information local to the memory allocation subsystem.
- */
- static SQLITE_WSD struct Mem0Global {
- sqlite3_mutex *mutex; /* Mutex to serialize access */
- /*
- ** The alarm callback and its arguments. The mem0.mutex lock will
- ** be held while the callback is running. Recursive calls into
- ** the memory subsystem are allowed, but no new callbacks will be
- ** issued.
- */
- sqlite3_int64 alarmThreshold;
- void (*alarmCallback)(void*, sqlite3_int64,int);
- void *alarmArg;
- /*
- ** Pointers to the end of sqlite3GlobalConfig.pScratch memory
- ** (so that a range test can be used to determine if an allocation
- ** being freed came from pScratch) and a pointer to the list of
- ** unused scratch allocations.
- */
- void *pScratchEnd;
- ScratchFreeslot *pScratchFree;
- u32 nScratchFree;
- /*
- ** True if heap is nearly "full" where "full" is defined by the
- ** sqlite3_soft_heap_limit() setting.
- */
- int nearlyFull;
- } mem0 = { 0, 0, 0, 0, 0, 0, 0, 0 };
- #define mem0 GLOBAL(struct Mem0Global, mem0)
- /*
- ** This routine runs when the memory allocator sees that the
- ** total memory allocation is about to exceed the soft heap
- ** limit.
- */
- static void softHeapLimitEnforcer(
- void *NotUsed,
- sqlite3_int64 NotUsed2,
- int allocSize
- ){
- UNUSED_PARAMETER2(NotUsed, NotUsed2);
- sqlite3_release_memory(allocSize);
- }
- /*
- ** Change the alarm callback
- */
- static int sqlite3MemoryAlarm(
- void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
- void *pArg,
- sqlite3_int64 iThreshold
- ){
- int nUsed;
- sqlite3_mutex_enter(mem0.mutex);
- mem0.alarmCallback = xCallback;
- mem0.alarmArg = pArg;
- mem0.alarmThreshold = iThreshold;
- nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
- mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);
- sqlite3_mutex_leave(mem0.mutex);
- return SQLITE_OK;
- }
- #ifndef SQLITE_OMIT_DEPRECATED
- /*
- ** Deprecated external interface. Internal/core SQLite code
- ** should call sqlite3MemoryAlarm.
- */
- SQLITE_API int sqlite3_memory_alarm(
- void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
- void *pArg,
- sqlite3_int64 iThreshold
- ){
- return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
- }
- #endif
- /*
- ** Set the soft heap-size limit for the library. Passing a zero or
- ** negative value indicates no limit.
- */
- SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
- sqlite3_int64 priorLimit;
- sqlite3_int64 excess;
- #ifndef SQLITE_OMIT_AUTOINIT
- int rc = sqlite3_initialize();
- if( rc ) return -1;
- #endif
- sqlite3_mutex_enter(mem0.mutex);
- priorLimit = mem0.alarmThreshold;
- sqlite3_mutex_leave(mem0.mutex);
- if( n<0 ) return priorLimit;
- if( n>0 ){
- sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, n);
- }else{
- sqlite3MemoryAlarm(0, 0, 0);
- }
- excess = sqlite3_memory_used() - n;
- if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
- return priorLimit;
- }
- SQLITE_API void sqlite3_soft_heap_limit(int n){
- if( n<0 ) n = 0;
- sqlite3_soft_heap_limit64(n);
- }
- /*
- ** Initialize the memory allocation subsystem.
- */
- SQLITE_PRIVATE int sqlite3MallocInit(void){
- if( sqlite3GlobalConfig.m.xMalloc==0 ){
- sqlite3MemSetDefault();
- }
- memset(&mem0, 0, sizeof(mem0));
- if( sqlite3GlobalConfig.bCoreMutex ){
- mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
- }
- if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100
- && sqlite3GlobalConfig.nScratch>0 ){
- int i, n, sz;
- ScratchFreeslot *pSlot;
- sz = ROUNDDOWN8(sqlite3GlobalConfig.szScratch);
- sqlite3GlobalConfig.szScratch = sz;
- pSlot = (ScratchFreeslot*)sqlite3GlobalConfig.pScratch;
- n = sqlite3GlobalConfig.nScratch;
- mem0.pScratchFree = pSlot;
- mem0.nScratchFree = n;
- for(i=0; i<n-1; i++){
- pSlot->pNext = (ScratchFreeslot*)(sz+(char*)pSlot);
- pSlot = pSlot->pNext;
- }
- pSlot->pNext = 0;
- mem0.pScratchEnd = (void*)&pSlot[1];
- }else{
- mem0.pScratchEnd = 0;
- sqlite3GlobalConfig.pScratch = 0;
- sqlite3GlobalConfig.szScratch = 0;
- sqlite3GlobalConfig.nScratch = 0;
- }
- if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
- || sqlite3GlobalConfig.nPage<1 ){
- sqlite3GlobalConfig.pPage = 0;
- sqlite3GlobalConfig.szPage = 0;
- sqlite3GlobalConfig.nPage = 0;
- }
- return sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
- }
- /*
- ** Return true if the heap is currently under memory pressure - in other
- ** words if the amount of heap used is close to the limit set by
- ** sqlite3_soft_heap_limit().
- */
- SQLITE_PRIVATE int sqlite3HeapNearlyFull(void){
- return mem0.nearlyFull;
- }
- /*
- ** Deinitialize the memory allocation subsystem.
- */
- SQLITE_PRIVATE void sqlite3MallocEnd(void){
- if( sqlite3GlobalConfig.m.xShutdown ){
- sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
- }
- memset(&mem0, 0, sizeof(mem0));
- }
- /*
- ** Return the amount of memory currently checked out.
- */
- SQLITE_API sqlite3_int64 sqlite3_memory_used(void){
- int n, mx;
- sqlite3_int64 res;
- sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
- res = (sqlite3_int64)n; /* Work around bug in Borland C. Ticket #3216 */
- return res;
- }
- /*
- ** Return the maximum amount of memory that has ever been
- ** checked out since either the beginning of this process
- ** or since the most recent reset.
- */
- SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
- int n, mx;
- sqlite3_int64 res;
- sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
- res = (sqlite3_int64)mx; /* Work around bug in Borland C. Ticket #3216 */
- return res;
- }
- /*
- ** Trigger the alarm
- */
- static void sqlite3MallocAlarm(int nByte){
- void (*xCallback)(void*,sqlite3_int64,int);
- sqlite3_int64 nowUsed;
- void *pArg;
- if( mem0.alarmCallback==0 ) return;
- xCallback = mem0.alarmCallback;
- nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
- pArg = mem0.alarmArg;
- mem0.alarmCallback = 0;
- sqlite3_mutex_leave(mem0.mutex);
- xCallback(pArg, nowUsed, nByte);
- sqlite3_mutex_enter(mem0.mutex);
- mem0.alarmCallback = xCallback;
- mem0.alarmArg = pArg;
- }
- /*
- ** Do a memory allocation with statistics and alarms. Assume the
- ** lock is already held.
- */
- static int mallocWithAlarm(int n, void **pp){
- int nFull;
- void *p;
- assert( sqlite3_mutex_held(mem0.mutex) );
- nFull = sqlite3GlobalConfig.m.xRoundup(n);
- sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
- if( mem0.alarmCallback!=0 ){
- int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
- if( nUsed >= mem0.alarmThreshold - nFull ){
- mem0.nearlyFull = 1;
- sqlite3MallocAlarm(nFull);
- }else{
- mem0.nearlyFull = 0;
- }
- }
- p = sqlite3GlobalConfig.m.xMalloc(nFull);
- #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
- if( p==0 && mem0.alarmCallback ){
- sqlite3MallocAlarm(nFull);
- p = sqlite3GlobalConfig.m.xMalloc(nFull);
- }
- #endif
- if( p ){
- nFull = sqlite3MallocSize(p);
- sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
- sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, 1);
- }
- *pp = p;
- return nFull;
- }
- /*
- ** Allocate memory. This routine is like sqlite3_malloc() except that it
- ** assumes the memory subsystem has already been initialized.
- */
- SQLITE_PRIVATE void *sqlite3Malloc(int n){
- void *p;
- if( n<=0 /* IMP: R-65312-04917 */
- || n>=0x7fffff00
- ){
- /* A memory allocation of a number of bytes which is near the maximum
- ** signed integer value might cause an integer overflow inside of the
- ** xMalloc(). Hence we limit the maximum size to 0x7fffff00, giving
- ** 255 bytes of overhead. SQLite itself will never use anything near
- ** this amount. The only way to reach the limit is with sqlite3_malloc() */
- p = 0;
- }else if( sqlite3GlobalConfig.bMemstat ){
- sqlite3_mutex_enter(mem0.mutex);
- mallocWithAlarm(n, &p);
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- p = sqlite3GlobalConfig.m.xMalloc(n);
- }
- assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-04675-44850 */
- return p;
- }
- /*
- ** This version of the memory allocation is for use by the application.
- ** First make sure the memory subsystem is initialized, then do the
- ** allocation.
- */
- SQLITE_API void *sqlite3_malloc(int n){
- #ifndef SQLITE_OMIT_AUTOINIT
- if( sqlite3_initialize() ) return 0;
- #endif
- return sqlite3Malloc(n);
- }
- /*
- ** Each thread may only have a single outstanding allocation from
- ** xScratchMalloc(). We verify this constraint in the single-threaded
- ** case by setting scratchAllocOut to 1 when an allocation
- ** is outstanding clearing it when the allocation is freed.
- */
- #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
- static int scratchAllocOut = 0;
- #endif
- /*
- ** Allocate memory that is to be used and released right away.
- ** This routine is similar to alloca() in that it is not intended
- ** for situations where the memory might be held long-term. This
- ** routine is intended to get memory to old large transient data
- ** structures that would not normally fit on the stack of an
- ** embedded processor.
- */
- SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){
- void *p;
- assert( n>0 );
- sqlite3_mutex_enter(mem0.mutex);
- if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){
- p = mem0.pScratchFree;
- mem0.pScratchFree = mem0.pScratchFree->pNext;
- mem0.nScratchFree--;
- sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
- sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- if( sqlite3GlobalConfig.bMemstat ){
- sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
- n = mallocWithAlarm(n, &p);
- if( p ) sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, n);
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- sqlite3_mutex_leave(mem0.mutex);
- p = sqlite3GlobalConfig.m.xMalloc(n);
- }
- sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
- }
- assert( sqlite3_mutex_notheld(mem0.mutex) );
- #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
- /* Verify that no more than two scratch allocations per thread
- ** are outstanding at one time. (This is only checked in the
- ** single-threaded case since checking in the multi-threaded case
- ** would be much more complicated.) */
- assert( scratchAllocOut<=1 );
- if( p ) scratchAllocOut++;
- #endif
- return p;
- }
- SQLITE_PRIVATE void sqlite3ScratchFree(void *p){
- if( p ){
- #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
- /* Verify that no more than two scratch allocation per thread
- ** is outstanding at one time. (This is only checked in the
- ** single-threaded case since checking in the multi-threaded case
- ** would be much more complicated.) */
- assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
- scratchAllocOut--;
- #endif
- if( p>=sqlite3GlobalConfig.pScratch && p<mem0.pScratchEnd ){
- /* Release memory from the SQLITE_CONFIG_SCRATCH allocation */
- ScratchFreeslot *pSlot;
- pSlot = (ScratchFreeslot*)p;
- sqlite3_mutex_enter(mem0.mutex);
- pSlot->pNext = mem0.pScratchFree;
- mem0.pScratchFree = pSlot;
- mem0.nScratchFree++;
- assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
- sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- /* Release memory back to the heap */
- assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
- assert( sqlite3MemdebugNoType(p, ~MEMTYPE_SCRATCH) );
- sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
- if( sqlite3GlobalConfig.bMemstat ){
- int iSize = sqlite3MallocSize(p);
- sqlite3_mutex_enter(mem0.mutex);
- sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
- sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
- sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
- sqlite3GlobalConfig.m.xFree(p);
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- sqlite3GlobalConfig.m.xFree(p);
- }
- }
- }
- }
- /*
- ** TRUE if p is a lookaside memory allocation from db
- */
- #ifndef SQLITE_OMIT_LOOKASIDE
- static int isLookaside(sqlite3 *db, void *p){
- return p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
- }
- #else
- #define isLookaside(A,B) 0
- #endif
- /*
- ** Return the size of a memory allocation previously obtained from
- ** sqlite3Malloc() or sqlite3_malloc().
- */
- SQLITE_PRIVATE int sqlite3MallocSize(void *p){
- assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
- assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
- return sqlite3GlobalConfig.m.xSize(p);
- }
- SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
- assert( db==0 || sqlite3_mutex_held(db->mutex) );
- if( db && isLookaside(db, p) ){
- return db->lookaside.sz;
- }else{
- assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
- assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
- assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
- return sqlite3GlobalConfig.m.xSize(p);
- }
- }
- /*
- ** Free memory previously obtained from sqlite3Malloc().
- */
- SQLITE_API void sqlite3_free(void *p){
- if( p==0 ) return; /* IMP: R-49053-54554 */
- assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
- assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
- if( sqlite3GlobalConfig.bMemstat ){
- sqlite3_mutex_enter(mem0.mutex);
- sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
- sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
- sqlite3GlobalConfig.m.xFree(p);
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- sqlite3GlobalConfig.m.xFree(p);
- }
- }
- /*
- ** Free memory that might be associated with a particular database
- ** connection.
- */
- SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
- assert( db==0 || sqlite3_mutex_held(db->mutex) );
- if( db ){
- if( db->pnBytesFreed ){
- *db->pnBytesFreed += sqlite3DbMallocSize(db, p);
- return;
- }
- if( isLookaside(db, p) ){
- LookasideSlot *pBuf = (LookasideSlot*)p;
- pBuf->pNext = db->lookaside.pFree;
- db->lookaside.pFree = pBuf;
- db->lookaside.nOut--;
- return;
- }
- }
- assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
- assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
- assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
- sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
- sqlite3_free(p);
- }
- /*
- ** Change the size of an existing memory allocation
- */
- SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
- int nOld, nNew, nDiff;
- void *pNew;
- if( pOld==0 ){
- return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */
- }
- if( nBytes<=0 ){
- sqlite3_free(pOld); /* IMP: R-31593-10574 */
- return 0;
- }
- if( nBytes>=0x7fffff00 ){
- /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
- return 0;
- }
- nOld = sqlite3MallocSize(pOld);
- /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
- ** argument to xRealloc is always a value returned by a prior call to
- ** xRoundup. */
- nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
- if( nOld==nNew ){
- pNew = pOld;
- }else if( sqlite3GlobalConfig.bMemstat ){
- sqlite3_mutex_enter(mem0.mutex);
- sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
- nDiff = nNew - nOld;
- if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
- mem0.alarmThreshold-nDiff ){
- sqlite3MallocAlarm(nDiff);
- }
- assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
- assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
- pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
- if( pNew==0 && mem0.alarmCallback ){
- sqlite3MallocAlarm(nBytes);
- pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
- }
- if( pNew ){
- nNew = sqlite3MallocSize(pNew);
- sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
- }
- sqlite3_mutex_leave(mem0.mutex);
- }else{
- pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
- }
- assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
- return pNew;
- }
- /*
- ** The public interface to sqlite3Realloc. Make sure that the memory
- ** subsystem is initialized prior to invoking sqliteRealloc.
- */
- SQLITE_API void *sqlite3_realloc(void *pOld, int n){
- #ifndef SQLITE_OMIT_AUTOINIT
- if( sqlite3_initialize() ) return 0;
- #endif
- return sqlite3Realloc(pOld, n);
- }
- /*
- ** Allocate and zero memory.
- */
- SQLITE_PRIVATE void *sqlite3MallocZero(int n){
- void *p = sqlite3Malloc(n);
- if( p ){
- memset(p, 0, n);
- }
- return p;
- }
- /*
- ** Allocate and zero memory. If the allocation fails, make
- ** the mallocFailed flag in the connection pointer.
- */
- SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, int n){
- void *p = sqlite3DbMallocRaw(db, n);
- if( p ){
- memset(p, 0, n);
- }
- return p;
- }
- /*
- ** Allocate and zero memory. If the allocation fails, make
- ** the mallocFailed flag in the connection pointer.
- **
- ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
- ** failure on the same database connection) then always return 0.
- ** Hence for a particular database connection, once malloc starts
- ** failing, it fails consistently until mallocFailed is reset.
- ** This is an important assumption. There are many places in the
- ** code that do things like this:
- **
- ** int *a = (int*)sqlite3DbMallocRaw(db, 100);
- ** int *b = (int*)sqlite3DbMallocRaw(db, 200);
- ** if( b ) a[10] = 9;
- **
- ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
- ** that all prior mallocs (ex: "a") worked too.
- */
- SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, int n){
- void *p;
- assert( db==0 || sqlite3_mutex_held(db->mutex) );
- assert( db==0 || db->pnBytesFreed==0 );
- #ifndef SQLITE_OMIT_LOOKASIDE
- if( db ){
- LookasideSlot *pBuf;
- if( db->mallocFailed ){
- return 0;
- }
- if( db->lookaside.bEnabled ){
- if( n>db->lookaside.sz ){
- db->lookaside.anStat[1]++;
- }else if( (pBuf = db->lookaside.pFree)==0 ){
- db->lookaside.anStat[2]++;
- }else{
- db->lookaside.pFree = pBuf->pNext;
- db->lookaside.nOut++;
- db->lookaside.anStat[0]++;
- if( db->lookaside.nOut>db->lookaside.mxOut ){
- db->lookaside.mxOut = db->lookaside.nOut;
- }
- return (void*)pBuf;
- }
- }
- }
- #else
- if( db && db->mallocFailed ){
- return 0;
- }
- #endif
- p = sqlite3Malloc(n);
- if( !p && db ){
- db->mallocFailed = 1;
- }
- sqlite3MemdebugSetType(p, MEMTYPE_DB |
- ((db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
- return p;
- }
- /*
- ** Resize the block of memory pointed to by p to n bytes. If the
- ** resize fails, set the mallocFailed flag in the connection object.
- */
- SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
- void *pNew = 0;
- assert( db!=0 );
- assert( sqlite3_mutex_held(db->mutex) );
- if( db->mallocFailed==0 ){
- if( p==0 ){
- return sqlite3DbMallocRaw(db, n);
- }
- if( isLookaside(db, p) ){
- if( n<=db->lookaside.sz ){
- return p;
- }
- pNew = sqlite3DbMallocRaw(db, n);
- if( pNew ){
- memcpy(pNew, p, db->lookaside.sz);
- sqlite3DbFree(db, p);
- }
- }else{
- assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
- assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
- sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
- pNew = sqlite3_realloc(p, n);
- if( !pNew ){
- sqlite3MemdebugSetType(p, MEMTYPE_DB|MEMTYPE_HEAP);
- db->mallocFailed = 1;
- }
- sqlite3MemdebugSetType(pNew, MEMTYPE_DB |
- (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
- }
- }
- return pNew;
- }
- /*
- ** Attempt to reallocate p. If the reallocation fails, then free p
- ** and set the mallocFailed flag in the database connection.
- */
- SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
- void *pNew;
- pNew = sqlite3DbRealloc(db, p, n);
- if( !pNew ){
- sqlite3DbFree(db, p);
- }
- return pNew;
- }
- /*
- ** Make a copy of a string in memory obtained from sqliteMalloc(). These
- ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
- ** is because when memory debugging is turned on, these two functions are
- ** called via macros that record the current file and line number in the
- ** ThreadData structure.
- */
- SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
- char *zNew;
- size_t n;
- if( z==0 ){
- return 0;
- }
- n = sqlite3Strlen30(z) + 1;
- assert( (n&0x7fffffff)==n );
- zNew = sqlite3DbMallocRaw(db, (int)n);
- if( zNew ){
- memcpy(zNew, z, n);
- }
- return zNew;
- }
- SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
- char *zNew;
- if( z==0 ){
- return 0;
- }
- assert( (n&0x7fffffff)==n );
- zNew = sqlite3DbMallocRaw(db, n+1);
- if( zNew ){
- memcpy(zNew, z, n);
- zNew[n] = 0;
- }
- return zNew;
- }
- /*
- ** Create a string from the zFromat argument and the va_list that follows.
- ** Store the string in memory obtained from sqliteMalloc() and make *pz
- ** point to that string.
- */
- SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
- va_list ap;
- char *z;
- va_start(ap, zFormat);
- z = sqlite3VMPrintf(db, zFormat, ap);
- va_end(ap);
- sqlite3DbFree(db, *pz);
- *pz = z;
- }
- /*
- ** This function must be called before exiting any API function (i.e.
- ** returning control to the user) that has called sqlite3_malloc or
- ** sqlite3_realloc.
- **
- ** The returned value is normally a copy of the second argument to this
- ** function. However, if a malloc() failure has occurred since the previous
- ** invocation SQLITE_NOMEM is returned instead.
- **
- ** If the first argument, db, is not NULL and a malloc() error has occurred,
- ** then the connection error-code (the value returned by sqlite3_errcode())
- ** is set to SQLITE_NOMEM.
- */
- SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){
- /* If the db handle is not NULL, then we must hold the connection handle
- ** mutex here. Otherwise the read (and possible write) of db->mallocFailed
- ** is unsafe, as is the call to sqlite3Error().
- */
- assert( !db || sqlite3_mutex_held(db->mutex) );
- if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
- sqlite3Error(db, SQLITE_NOMEM, 0);
- db->mallocFailed = 0;
- rc = SQLITE_NOMEM;
- }
- return rc & (db ? db->errMask : 0xff);
- }
- /************** End of malloc.c **********************************************/
- /************** Begin file printf.c ******************************************/
- /*
- ** The "printf" code that follows dates from the 1980's. It is in
- ** the public domain. The original comments are included here for
- ** completeness. They are very out-of-date but might be useful as
- ** an historical reference. Most of the "enhancements" have been backed
- ** out so that the functionality is now the same as standard printf().
- **
- **************************************************************************
- **
- ** This file contains code for a set of "printf"-like routines. These
- ** routines format strings much like the printf() from the standard C
- ** library, though the implementation here has enhancements to support
- ** SQLlite.
- */
- /*
- ** Conversion types fall into various categories as defined by the
- ** following enumeration.
- */
- #define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */
- #define etFLOAT 2 /* Floating point. %f */
- #define etEXP 3 /* Exponentional notation. %e and %E */
- #define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */
- #define etSIZE 5 /* Return number of characters processed so far. %n */
- #define etSTRING 6 /* Strings. %s */
- #define etDYNSTRING 7 /* Dynamically allocated strings. %z */
- #define etPERCENT 8 /* Percent symbol. %% */
- #define etCHARX 9 /* Characters. %c */
- /* The rest are extensions, not normally found in printf() */
- #define etSQLESCAPE 10 /* Strings with '\'' doubled. %q */
- #define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '',
- NULL pointers replaced by SQL NULL. %Q */
- #define etTOKEN 12 /* a pointer to a Token structure */
- #define etSRCLIST 13 /* a pointer to a SrcList */
- #define etPOINTER 14 /* The %p conversion */
- #define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */
- #define etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
- #define etINVALID 0 /* Any unrecognized conversion type */
- /*
- ** An "etByte" is an 8-bit unsigned value.
- */
- typedef unsigned char etByte;
- /*
- ** Each builtin conversion character (ex: the 'd' in "%d") is described
- ** by an instance of the following structure
- */
- typedef struct et_info { /* Information about each format field */
- char fmttype; /* The format field code letter */
- etByte base; /* The base for radix conversion */
- etByte flags; /* One or more of FLAG_ constants below */
- etByte type; /* Conversion paradigm */
- etByte charset; /* Offset into aDigits[] of the digits string */
- etByte prefix; /* Offset into aPrefix[] of the prefix string */
- } et_info;
- /*
- ** Allowed values for et_info.flags
- */
- #define FLAG_SIGNED 1 /* True if the value to convert is signed */
- #define FLAG_INTERN 2 /* True if for internal use only */
- #define FLAG_STRING 4 /* Allow infinity precision */
- /*
- ** The following table is searched linearly, so it is good to put the
- ** most frequently used conversion types first.
- */
- static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
- static const char aPrefix[] = "-x0\000X0";
- static const et_info fmtinfo[] = {
- { 'd', 10, 1, etRADIX, 0, 0 },
- { 's', 0, 4, etSTRING, 0, 0 },
- { 'g', 0, 1, etGENERIC, 30, 0 },
- { 'z', 0, 4, etDYNSTRING, 0, 0 },
- { 'q', 0, 4, etSQLESCAPE, 0, 0 },
- { 'Q', 0, 4, etSQLESCAPE2, 0, 0 },
- { 'w', 0, 4, etSQLESCAPE3, 0, 0 },
- { 'c', 0, 0, etCHARX, 0, 0 },
- { 'o', 8, 0, etRADIX, 0, 2 },
- { 'u', 10, 0, etRADIX, 0, 0 },
- { 'x', 16, 0, etRADIX, 16, 1 },
- { 'X', 16, 0, etRADIX, 0, 4 },
- #ifndef SQLITE_OMIT_FLOATING_POINT
- { 'f', 0, 1, etFLOAT, 0, 0 },
- { 'e', 0, 1, etEXP, 30, 0 },
- { 'E', 0, 1, etEXP, 14, 0 },
- { 'G', 0, 1, etGENERIC, 14, 0 },
- #endif
- { 'i', 10, 1, etRADIX, 0, 0 },
- { 'n', 0, 0, etSIZE, 0, 0 },
- { '%', 0, 0, etPERCENT, 0, 0 },
- { 'p', 16, 0, etPOINTER, 0, 1 },
- /* All the rest have the FLAG_INTERN bit set and are thus for internal
- ** use only */
- { 'T', 0, 2, etTOKEN, 0, 0 },
- { 'S', 0, 2, etSRCLIST, 0, 0 },
- { 'r', 10, 3, etORDINAL, 0, 0 },
- };
- /*
- ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
- ** conversions will work.
- */
- #ifndef SQLITE_OMIT_FLOATING_POINT
- /*
- ** "*val" is a double such that 0.1 <= *val < 10.0
- ** Return the ascii code for the leading digit of *val, then
- ** multiply "*val" by 10.0 to renormalize.
- **
- ** Example:
- ** input: *val = 3.14159
- ** output: *val = 1.4159 function return = '3'
- **
- ** The counter *cnt is incremented each time. After counter exceeds
- ** 16 (the number of significant digits in a 64-bit float) '0' is
- ** always returned.
- */
- static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
- int digit;
- LONGDOUBLE_TYPE d;
- if( (*cnt)++ >= 16 ) return '0';
- digit = (int)*val;
- d = digit;
- digit += '0';
- *val = (*val - d)*10.0;
- return (char)digit;
- }
- #endif /* SQLITE_OMIT_FLOATING_POINT */
- /*
- ** Append N space characters to the given string buffer.
- */
- SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum *pAccum, int N){
- static const char zSpaces[] = " ";
- while( N>=(int)sizeof(zSpaces)-1 ){
- sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
- N -= sizeof(zSpaces)-1;
- }
- if( N>0 ){
- sqlite3StrAccumAppend(pAccum, zSpaces, N);
- }
- }
- /*
- ** On machines with a small stack size, you can redefine the
- ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
- */
- #ifndef SQLITE_PRINT_BUF_SIZE
- # define SQLITE_PRINT_BUF_SIZE 70
- #endif
- #define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */
- /*
- ** Render a string given by "fmt" into the StrAccum object.
- */
- SQLITE_PRIVATE void sqlite3VXPrintf(
- StrAccum *pAccum, /* Accumulate results here */
- int useExtended, /* Allow extended %-conversions */
- const char *fmt, /* Format string */
- va_list ap /* arguments */
- ){
- int c; /* Next character in the format string */
- char *bufpt; /* Pointer to the conversion buffer */
- int precision; /* Precision of the current field */
- int length; /* Length of the field */
- int idx; /* A general purpose loop counter */
- int width; /* Width of the current field */
- etByte flag_leftjustify; /* True if "-" flag is present */
- etByte flag_plussign; /* True if "+" flag is present */
- etByte flag_blanksign; /* True if " " flag is present */
- etByte flag_alternateform; /* True if "#" flag is present */
- etByte flag_altform2; /* True if "!" flag is present */
- etByte flag_zeropad; /* True if field width constant starts with zero */
- etByte flag_long; /* True if "l" flag is present */
- etByte flag_longlong; /* True if the "ll" flag is present */
- etByte done; /* Loop termination flag */
- etByte xtype = 0; /* Conversion paradigm */
- char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
- sqlite_uint64 longvalue; /* Value for integer types */
- LONGDOUBLE_TYPE realvalue; /* Value for real types */
- const et_info *infop; /* Pointer to the appropriate info structure */
- char *zOut; /* Rendering buffer */
- int nOut; /* Size of the rendering buffer */
- char *zExtra; /* Malloced memory used by some conversion */
- #ifndef SQLITE_OMIT_FLOATING_POINT
- int exp, e2; /* exponent of real numbers */
- int nsd; /* Number of significant digits returned */
- double rounder; /* Used for rounding floating point values */
- etByte flag_dp; /* True if decimal point should be shown */
- etByte flag_rtz; /* True if trailing zeros should be removed */
- #endif
- char buf[etBUFSIZE]; /* Conversion buffer */
- bufpt = 0;
- for(; (c=(*fmt))!=0; ++fmt){
- if( c!='%' ){
- int amt;
- bufpt = (char *)fmt;
- amt = 1;
- while( (c=(*++fmt))!='%' && c!=0 ) amt++;
- sqlite3StrAccumAppend(pAccum, bufpt, amt);
- if( c==0 ) break;
- }
- if( (c=(*++fmt))==0 ){
- sqlite3StrAccumAppend(pAccum, "%", 1);
- break;
- }
- /* Find out what flags are present */
- flag_leftjustify = flag_plussign = flag_blanksign =
- flag_alternateform = flag_altform2 = flag_zeropad = 0;
- done = 0;
- do{
- switch( c ){
- case '-': flag_leftjustify = 1; break;
- case '+': flag_plussign = 1; break;
- case ' ': flag_blanksign = 1; break;
- case '#': flag_alternateform = 1; break;
- case '!': flag_altform2 = 1; break;
- case '0': flag_zeropad = 1; break;
- default: done = 1; break;
- }
- }while( !done && (c=(*++fmt))!=0 );
- /* Get the field width */
- width = 0;
- if( c=='*' ){
- width = va_arg(ap,int);
- if( width<0 ){
- flag_leftjustify = 1;
- width = -width;
- }
- c = *++fmt;
- }else{
- while( c>='0' && c<='9' ){
- width = width*10 + c - '0';
- c = *++fmt;
- }
- }
- /* Get the precision */
- if( c=='.' ){
- precision = 0;
- c = *++fmt;
- if( c=='*' ){
- precision = va_arg(ap,int);
- if( precision<0 ) precision = -precision;
- c = *++fmt;
- }else{
- while( c>='0' && c<='9' ){
- precision = precision*10 + c - '0';
- c = *++fmt;
- }
- }
- }else{
- precision = -1;
- }
- /* Get the conversion type modifier */
- if( c=='l' ){
- flag_long = 1;
- c = *++fmt;
- if( c=='l' ){
- flag_longlong = 1;
- c = *++fmt;
- }else{
- flag_longlong = 0;
- }
- }else{
- flag_long = flag_longlong = 0;
- }
- /* Fetch the info entry for the field */
- infop = &fmtinfo[0];
- xtype = etINVALID;
- for(idx=0; idx<ArraySize(fmtinfo); idx++){
- if( c==fmtinfo[idx].fmttype ){
- infop = &fmtinfo[idx];
- if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
- xtype = infop->type;
- }else{
- return;
- }
- break;
- }
- }
- zExtra = 0;
- /*
- ** At this point, variables are initialized as follows:
- **
- ** flag_alternateform TRUE if a '#' is present.
- ** flag_altform2 TRUE if a '!' is present.
- ** flag_plussign TRUE if a '+' is present.
- ** flag_leftjustify TRUE if a '-' is present or if the
- ** field width was negative.
- ** flag_zeropad TRUE if the width began with 0.
- ** flag_long TRUE if the letter 'l' (ell) prefixed
- ** the conversion character.
- ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed
- ** the conversion character.
- ** flag_blanksign TRUE if a ' ' is present.
- ** width The specified field width. This is
- ** always non-negative. Zero is the default.
- ** precision The specified precision. The default
- ** is -1.
- ** xtype The class of the conversion.
- ** infop Pointer to the appropriate info struct.
- */
- switch( xtype ){
- case etPOINTER:
- flag_longlong = sizeof(char*)==sizeof(i64);
- flag_long = sizeof(char*)==sizeof(long int);
- /* Fall through into the next case */
- case etORDINAL:
- case etRADIX:
- if( infop->flags & FLAG_SIGNED ){
- i64 v;
- if( flag_longlong ){
- v = va_arg(ap,i64);
- }else if( flag_long ){
- v = va_arg(ap,long int);
- }else{
- v = va_arg(ap,int);
- }
- if( v<0 ){
- if( v==SMALLEST_INT64 ){
- longvalue = ((u64)1)<<63;
- }else{
- longvalue = -v;
- }
- prefix = '-';
- }else{
- longvalue = v;
- if( flag_plussign ) prefix = '+';
- else if( flag_blanksign ) prefix = ' ';
- else prefix = 0;
- }
- }else{
- if( flag_longlong ){
- longvalue = va_arg(ap,u64);
- }else if( flag_long ){
- longvalue = va_arg(ap,unsigned long int);
- }else{
- longvalue = va_arg(ap,unsigned int);
- }
- prefix = 0;
- }
- if( longvalue==0 ) flag_alternateform = 0;
- if( flag_zeropad && precision<width-(prefix!=0) ){
- precision = width-(prefix!=0);
- }
- if( precision<etBUFSIZE-10 ){
- nOut = etBUFSIZE;
- zOut = buf;
- }else{
- nOut = precision + 10;
- zOut = zExtra = sqlite3Malloc( nOut );
- if( zOut==0 ){
- pAccum->mallocFailed = 1;
- return;
- }
- }
- bufpt = &zOut[nOut-1];
- if( xtype==etORDINAL ){
- static const char zOrd[] = "thstndrd";
- int x = (int)(longvalue % 10);
- if( x>=4 || (longvalue/10)%10==1 ){
- x = 0;
- }
- *(--bufpt) = zOrd[x*2+1];
- *(--bufpt) = zOrd[x*2];
- }
- {
- register const char *cset; /* Use registers for speed */
- register int base;
- cset = &aDigits[infop->charset];
- base = infop->base;
- do{ /* Convert to ascii */
- *(--bufpt) = cset[longvalue%base];
- longvalue = longvalue/base;
- }while( longvalue>0 );
- }
- length = (int)(&zOut[nOut-1]-bufpt);
- for(idx=precision-length; idx>0; idx--){
- *(--bufpt) = '0'; /* Zero pad */
- }
- if( prefix ) *(--bufpt) = prefix; /* Add sign */
- if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
- const char *pre;
- char x;
- pre = &aPrefix[infop->prefix];
- for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
- }
- length = (int)(&zOut[nOut-1]-bufpt);
- break;
- case etFLOAT:
- case etEXP:
- case etGENERIC:
- realvalue = va_arg(ap,double);
- #ifdef SQLITE_OMIT_FLOATING_POINT
- length = 0;
- #else
- if( precision<0 ) precision = 6; /* Set default precision */
- if( realvalue<0.0 ){
- realvalue = -realvalue;
- prefix = '-';
- }else{
- if( flag_plussign ) prefix = '+';
- else if( flag_blanksign ) prefix = ' ';
- else prefix = 0;
- }
- if( xtype==etGENERIC && precision>0 ) precision--;
- #if 0
- /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */
- for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
- #else
- /* It makes more sense to use 0.5 */
- for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
- #endif
- if( xtype==etFLOAT ) realvalue += rounder;
- /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
- exp = 0;
- if( sqlite3IsNaN((double)realvalue) ){
- bufpt = "NaN";
- length = 3;
- break;
- }
- if( realvalue>0.0 ){
- while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }
- while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
- while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
- while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
- while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
- if( exp>350 ){
- if( prefix=='-' ){
- bufpt = "-Inf";
- }else if( prefix=='+' ){
- bufpt = "+Inf";
- }else{
- bufpt = "Inf";
- }
- length = sqlite3Strlen30(bufpt);
- break;
- }
- }
- bufpt = buf;
- /*
- ** If the field type is etGENERIC, then convert to either etEXP
- ** or etFLOAT, as appropriate.
- */
- if( xtype!=etFLOAT ){
- realvalue += rounder;
- if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
- }
- if( xtype==etGENERIC ){
- flag_rtz = !flag_alternateform;
- if( exp<-4 || exp>precision ){
- xtype = etEXP;
- }else{
- precision = precision - exp;
- xtype = etFLOAT;
- }
- }else{
- flag_rtz = 0;
- }
- if( xtype==etEXP ){
- e2 = 0;
- }else{
- e2 = exp;
- }
- if( e2+precision+width > etBUFSIZE - 15 ){
- bufpt = zExtra = sqlite3Malloc( e2+precision+width+15 );
- if( bufpt==0 ){
- pAccum->mallocFailed = 1;
- return;
- }
- }
- zOut = bufpt;
- nsd = 0;
- flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
- /* The sign in front of the number */
- if( prefix ){
- *(bufpt++) = prefix;
- }
- /* Digits prior to the decimal point */
- if( e2<0 ){
- *(bufpt++) = '0';
- }else{
- for(; e2>=0; e2--){
- *(bufpt++) = et_getdigit(&realvalue,&nsd);
- }
- }
- /* The decimal point */
- if( flag_dp ){
- *(bufpt++) = '.';
- }
- /* "0" digits after the decimal point but before the first
- ** significant digit of the number */
- for(e2++; e2<0; precision--, e2++){
- assert( precision>0 );
- *(bufpt++) = '0';
- }
- /* Significant digits after the decimal point */
- while( (precision--)>0 ){
- *(bufpt++) = et_getdigit(&realvalue,&nsd);
- }
- /* Remove trailing zeros and the "." if no digits follow the "." */
- if( flag_rtz && flag_dp ){
- while( bufpt[-1]=='0' ) *(--bufpt) = 0;
- assert( bufpt>zOut );
- if( bufpt[-1]=='.' ){
- if( flag_altform2 ){
- *(bufpt++) = '0';
- }else{
- *(--bufpt) = 0;
- }
- }
- }
- /* Add the "eNNN" suffix */
- if( xtype==etEXP ){
- *(bufpt++) = aDigits[infop->charset];
- if( exp<0 ){
- *(bufpt++) = '-'; exp = -exp;
- }else{
- *(bufpt++) = '+';
- }
- if( exp>=100 ){
- *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */
- exp %= 100;
- }
- *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */
- *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */
- }
- *bufpt = 0;
- /* The converted number is in buf[] and zero terminated. Output it.
- ** Note that the number is in the usual order, not reversed as with
- ** integer conversions. */
- length = (int)(bufpt-zOut);
- bufpt = zOut;
- /* Special case: Add leading zeros if the flag_zeropad flag is
- ** set and we are not left justified */
- if( flag_zeropad && !flag_leftjustify && length < width){
- int i;
- int nPad = width - length;
- for(i=width; i>=nPad; i--){
- bufpt[i] = bufpt[i-nPad];
- }
- i = prefix!=0;
- while( nPad-- ) bufpt[i++] = '0';
- length = width;
- }
- #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
- break;
- case etSIZE:
- *(va_arg(ap,int*)) = pAccum->nChar;
- length = width = 0;
- break;
- case etPERCENT:
- buf[0] = '%';
- bufpt = buf;
- length = 1;
- break;
- case etCHARX:
- c = va_arg(ap,int);
- buf[0] = (char)c;
- if( precision>=0 ){
- for(idx=1; idx<precision; idx++) buf[idx] = (char)c;
- length = precision;
- }else{
- length =1;
- }
- bufpt = buf;
- break;
- case etSTRING:
- case etDYNSTRING:
- bufpt = va_arg(ap,char*);
- if( bufpt==0 ){
- bufpt = "";
- }else if( xtype==etDYNSTRING ){
- zExtra = bufpt;
- }
- if( precision>=0 ){
- for(length=0; length<precision && bufpt[length]; length++){}
- }else{
- length = sqlite3Strlen30(bufpt);
- }
- break;
- case etSQLESCAPE:
- case etSQLESCAPE2:
- case etSQLESCAPE3: {
- int i, j, k, n, isnull;
- int needQuote;
- char ch;
- char q = ((xtype==etSQLESCAPE3)?'"':'\''); /* Quote character */
- char *escarg = va_arg(ap,char*);
- isnull = escarg==0;
- if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
- k = precision;
- for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
- if( ch==q ) n++;
- }
- needQuote = !isnull && xtype==etSQLESCAPE2;
- n += i + 1 + needQuote*2;
- if( n>etBUFSIZE ){
- bufpt = zExtra = sqlite3Malloc( n );
- if( bufpt==0 ){
- pAccum->mallocFailed = 1;
- return;
- }
- }else{
- bufpt = buf;
- }
- j = 0;
- if( needQuote ) bufpt[j++] = q;
- k = i;
- for(i=0; i<k; i++){
- bufpt[j++] = ch = escarg[i];
- if( ch==q ) bufpt[j++] = ch;
- }
- if( needQuote ) bufpt[j++] = q;
- bufpt[j] = 0;
- length = j;
- /* The precision in %q and %Q means how many input characters to
- ** consume, not the length of the output...
- ** if( precision>=0 && precision<length ) length = precision; */
- break;
- }
- case etTOKEN: {
- Token *pToken = va_arg(ap, Token*);
- if( pToken ){
- sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
- }
- length = width = 0;
- break;
- }
- case etSRCLIST: {
- SrcList *pSrc = va_arg(ap, SrcList*);
- int k = va_arg(ap, int);
- struct SrcList_item *pItem = &pSrc->a[k];
- assert( k>=0 && k<pSrc->nSrc );
- if( pItem->zDatabase ){
- sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);
- sqlite3StrAccumAppend(pAccum, ".", 1);
- }
- sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
- length = width = 0;
- break;
- }
- default: {
- assert( xtype==etINVALID );
- return;
- }
- }/* End switch over the format type */
- /*
- ** The text of the conversion is pointed to by "bufpt" and is
- ** "length" characters long. The field width is "width". Do
- ** the output.
- */
- if( !flag_leftjustify ){
- register int nspace;
- nspace = width-length;
- if( nspace>0 ){
- sqlite3AppendSpace(pAccum, nspace);
- }
- }
- if( length>0 ){
- sqlite3StrAccumAppend(pAccum, bufpt, length);
- }
- if( flag_leftjustify ){
- register int nspace;
- nspace = width-length;
- if( nspace>0 ){
- sqlite3AppendSpace(pAccum, nspace);
- }
- }
- sqlite3_free(zExtra);
- }/* End for loop over the format string */
- } /* End of function */
- /*
- ** Append N bytes of text from z to the StrAccum object.
- */
- SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
- assert( z!=0 || N==0 );
- if( p->tooBig | p->mallocFailed ){
- testcase(p->tooBig);
- testcase(p->mallocFailed);
- return;
- }
- assert( p->zText!=0 || p->nChar==0 );
- if( N<0 ){
- N = sqlite3Strlen30(z);
- }
- if( N==0 || NEVER(z==0) ){
- return;
- }
- if( p->nChar+N >= p->nAlloc ){
- char *zNew;
- if( !p->useMalloc ){
- p->tooBig = 1;
- N = p->nAlloc - p->nChar - 1;
- if( N<=0 ){
- return;
- }
- }else{
- char *zOld = (p->zText==p->zBase ? 0 : p->zText);
- i64 szNew = p->nChar;
- szNew += N + 1;
- if( szNew > p->mxAlloc ){
- sqlite3StrAccumReset(p);
- p->tooBig = 1;
- return;
- }else{
- p->nAlloc = (int)szNew;
- }
- if( p->useMalloc==1 ){
- zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
- }else{
- zNew = sqlite3_realloc(zOld, p->nAlloc);
- }
- if( zNew ){
- if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
- p->zText = zNew;
- }else{
- p->mallocFailed = 1;
- sqlite3StrAccumReset(p);
- return;
- }
- }
- }
- assert( p->zText );
- memcpy(&p->zText[p->nChar], z, N);
- p->nChar += N;
- }
- /*
- ** Finish off a string by making sure it is zero-terminated.
- ** Return a pointer to the resulting string. Return a NULL
- ** pointer if any kind of error was encountered.
- */
- SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
- if( p->zText ){
- p->zText[p->nChar] = 0;
- if( p->useMalloc && p->zText==p->zBase ){
- if( p->useMalloc==1 ){
- p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
- }else{
- p->zText = sqlite3_malloc(p->nChar+1);
- }
- if( p->zText ){
- memcpy(p->zText, p->zBase, p->nChar+1);
- }else{
- p->mallocFailed = 1;
- }
- }
- }
- return p->zText;
- }
- /*
- ** Reset an StrAccum string. Reclaim all malloced memory.
- */
- SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){
- if( p->zText!=p->zBase ){
- if( p->useMalloc==1 ){
- sqlite3DbFree(p->db, p->zText);
- }else{
- sqlite3_free(p->zText);
- }
- }
- p->zText = 0;
- }
- /*
- ** Initialize a string accumulator
- */
- SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
- p->zText = p->zBase = zBase;
- p->db = 0;
- p->nChar = 0;
- p->nAlloc = n;
- p->mxAlloc = mx;
- p->useMalloc = 1;
- p->tooBig = 0;
- p->mallocFailed = 0;
- }
- /*
- ** Print into memory obtained from sqliteMalloc(). Use the internal
- ** %-conversion extensions.
- */
- SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
- char *z;
- char zBase[SQLITE_PRINT_BUF_SIZE];
- StrAccum acc;
- assert( db!=0 );
- sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
- db->aLimit[SQLITE_LIMIT_LENGTH]);
- acc.db = db;
- sqlite3VXPrintf(&acc, 1, zFormat, ap);
- z = sqlite3StrAccumFinish(&acc);
- if( acc.mallocFailed ){
- db->mallocFailed = 1;
- }
- return z;
- }
- /*
- ** Print into memory obtained from sqliteMalloc(). Use the internal
- ** %-conversion extensions.
- */
- SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
- va_list ap;
- char *z;
- va_start(ap, zFormat);
- z = sqlite3VMPrintf(db, zFormat, ap);
- va_end(ap);
- return z;
- }
- /*
- ** Like sqlite3MPrintf(), but call sqlite3DbFree() on zStr after formatting
- ** the string and before returnning. This routine is intended to be used
- ** to modify an existing string. For example:
- **
- ** x = sqlite3MPrintf(db, x, "prefix %s suffix", x);
- **
- */
- SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zFormat, ...){
- va_list ap;
- char *z;
- va_start(ap, zFormat);
- z = sqlite3VMPrintf(db, zFormat, ap);
- va_end(ap);
- sqlite3DbFree(db, zStr);
- return z;
- }
- /*
- ** Print into memory obtained from sqlite3_malloc(). Omit the internal
- ** %-conversion extensions.
- */
- SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){
- char *z;
- char zBase[SQLITE_PRINT_BUF_SIZE];
- StrAccum acc;
- #ifndef SQLITE_OMIT_AUTOINIT
- if( sqlite3_initialize() ) return 0;
- #endif
- sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
- acc.useMalloc = 2;
- sqlite3VXPrintf(&acc, 0, zFormat, ap);
- z = sqlite3StrAccumFinish(&acc);
- return z;
- }
- /*
- ** Print into memory obtained from sqlite3_malloc()(). Omit the internal
- ** %-conversion extensions.
- */
- SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){
- va_list ap;
- char *z;
- #ifndef SQLITE_OMIT_AUTOINIT
- if( sqlite3_initialize() ) return 0;
- #endif
- va_start(ap, zFormat);
- z = sqlite3_vmprintf(zFormat, ap);
- va_end(ap);
- return z;
- }
- /*
- ** sqlite3_snprintf() works like snprintf() except that it ignores the
- ** current locale settings. This is important for SQLite because we
- ** are not able to use a "," as the decimal point in place of "." as
- ** specified by some locales.
- **
- ** Oops: The first two arguments of sqlite3_snprintf() are backwards
- ** from the snprintf() standard. Unfortunately, it is too late to change
- ** this without breaking compatibility, so we just have to live with the
- ** mistake.
- **
- ** sqlite3_vsnprintf() is the varargs version.
- */
- SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
- StrAccum acc;
- if( n<=0 ) return zBuf;
- sqlite3StrAccumInit(&acc, zBuf, n, 0);
- acc.useMalloc = 0;
- sqlite3VXPrintf(&acc, 0, zFormat, ap);
- return sqlite3StrAccumFinish(&acc);
- }
- SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
- char *z;
- va_list ap;
- va_start(ap,zFormat);
- z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
- va_end(ap);
- return z;
- }
- /*
- ** This is the routine that actually formats the sqlite3_log() message.
- ** We house it in a separate routine from sqlite3_log() to avoid using
- ** stack space on small-stack systems when logging is disabled.
- **
- ** sqlite3_log() must render into a static buffer. It cannot dynamically
- ** allocate memory because it might be called while the memory allocator
- ** mutex is held.
- */
- static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
- StrAccum acc; /* String accumulator */
- char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */
- sqlite3StrAccumInit(&acc, zMsg, sizeof(zMsg), 0);
- acc.useMalloc = 0;
- sqlite3VXPrintf(&acc, 0, zFormat, ap);
- sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
- sqlite3StrAccumFinish(&acc));
- }
- /*
- ** Format and write a message to the log if logging is enabled.
- */
- SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){
- va_list ap; /* Vararg list */
- if( sqlite3GlobalConfig.xLog ){
- va_start(ap, zFormat);
- renderLogMsg(iErrCode, zFormat, ap);
- va_end(ap);
- }
- }
- #if defined(SQLITE_DEBUG)
- /*
- ** A version of printf() that understands %lld. Used for debugging.
- ** The printf() built into some versions of windows does not understand %lld
- ** and segfaults if you give it a long long int.
- */
- SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
- va_list ap;
- StrAccum acc;
- char zBuf[500];
- sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);
- acc.useMalloc = 0;
- va_start(ap,zFormat);
- sqlite3VXPrintf(&acc, 0, zFormat, ap);
- va_end(ap);
- sqlite3StrAccumFinish(&acc);
- fprintf(stdout,"%s", zBuf);
- fflush(stdout);
- }
- #endif
- #ifndef SQLITE_OMIT_TRACE
- /*
- ** variable-argument wrapper around sqlite3VXPrintf().
- */
- SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
- va_list ap;
- va_start(ap,zFormat);
- sqlite3VXPrintf(p, 1, zFormat, ap);
- va_end(ap);
- }
- #endif
- /************** End of printf.c **********************************************/
- /************** Begin file random.c ******************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains code to implement a pseudo-random number
- ** generator (PRNG) for SQLite.
- **
- ** Random numbers are used by some of the database backends in order
- ** to generate random integer keys for tables or random filenames.
- */
- /* All threads share a single random number generator.
- ** This structure is the current state of the generator.
- */
- static SQLITE_WSD struct sqlite3PrngType {
- unsigned char isInit; /* True if initialized */
- unsigned char i, j; /* State variables */
- unsigned char s[256]; /* State variables */
- } sqlite3Prng;
- /*
- ** Get a single 8-bit random value from the RC4 PRNG. The Mutex
- ** must be held while executing this routine.
- **
- ** Why not just use a library random generator like lrand48() for this?
- ** Because the OP_NewRowid opcode in the VDBE depends on having a very
- ** good source of random numbers. The lrand48() library function may
- ** well be good enough. But maybe not. Or maybe lrand48() has some
- ** subtle problems on some systems that could cause problems. It is hard
- ** to know. To minimize the risk of problems due to bad lrand48()
- ** implementations, SQLite uses this random number generator based
- ** on RC4, which we know works very well.
- **
- ** (Later): Actually, OP_NewRowid does not depend on a good source of
- ** randomness any more. But we will leave this code in all the same.
- */
- static u8 randomByte(void){
- unsigned char t;
- /* The "wsdPrng" macro will resolve to the pseudo-random number generator
- ** state vector. If writable static data is unsupported on the target,
- ** we have to locate the state vector at run-time. In the more common
- ** case where writable static data is supported, wsdPrng can refer directly
- ** to the "sqlite3Prng" state vector declared above.
- */
- #ifdef SQLITE_OMIT_WSD
- struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
- # define wsdPrng p[0]
- #else
- # define wsdPrng sqlite3Prng
- #endif
- /* Initialize the state of the random number generator once,
- ** the first time this routine is called. The seed value does
- ** not need to contain a lot of randomness since we are not
- ** trying to do secure encryption or anything like that...
- **
- ** Nothing in this file or anywhere else in SQLite does any kind of
- ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random
- ** number generator) not as an encryption device.
- */
- if( !wsdPrng.isInit ){
- int i;
- char k[256];
- wsdPrng.j = 0;
- wsdPrng.i = 0;
- sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
- for(i=0; i<256; i++){
- wsdPrng.s[i] = (u8)i;
- }
- for(i=0; i<256; i++){
- wsdPrng.j += wsdPrng.s[i] + k[i];
- t = wsdPrng.s[wsdPrng.j];
- wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
- wsdPrng.s[i] = t;
- }
- wsdPrng.isInit = 1;
- }
- /* Generate and return single random byte
- */
- wsdPrng.i++;
- t = wsdPrng.s[wsdPrng.i];
- wsdPrng.j += t;
- wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];
- wsdPrng.s[wsdPrng.j] = t;
- t += wsdPrng.s[wsdPrng.i];
- return wsdPrng.s[t];
- }
- /*
- ** Return N random bytes.
- */
- SQLITE_API void sqlite3_randomness(int N, void *pBuf){
- unsigned char *zBuf = pBuf;
- #if SQLITE_THREADSAFE
- sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
- #endif
- sqlite3_mutex_enter(mutex);
- while( N-- ){
- *(zBuf++) = randomByte();
- }
- sqlite3_mutex_leave(mutex);
- }
- #ifndef SQLITE_OMIT_BUILTIN_TEST
- /*
- ** For testing purposes, we sometimes want to preserve the state of
- ** PRNG and restore the PRNG to its saved state at a later time, or
- ** to reset the PRNG to its initial state. These routines accomplish
- ** those tasks.
- **
- ** The sqlite3_test_control() interface calls these routines to
- ** control the PRNG.
- */
- static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng;
- SQLITE_PRIVATE void sqlite3PrngSaveState(void){
- memcpy(
- &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),
- &GLOBAL(struct sqlite3PrngType, sqlite3Prng),
- sizeof(sqlite3Prng)
- );
- }
- SQLITE_PRIVATE void sqlite3PrngRestoreState(void){
- memcpy(
- &GLOBAL(struct sqlite3PrngType, sqlite3Prng),
- &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),
- sizeof(sqlite3Prng)
- );
- }
- SQLITE_PRIVATE void sqlite3PrngResetState(void){
- GLOBAL(struct sqlite3PrngType, sqlite3Prng).isInit = 0;
- }
- #endif /* SQLITE_OMIT_BUILTIN_TEST */
- /************** End of random.c **********************************************/
- /************** Begin file utf.c *********************************************/
- /*
- ** 2004 April 13
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This file contains routines used to translate between UTF-8,
- ** UTF-16, UTF-16BE, and UTF-16LE.
- **
- ** Notes on UTF-8:
- **
- ** Byte-0 Byte-1 Byte-2 Byte-3 Value
- ** 0xxxxxxx 00000000 00000000 0xxxxxxx
- ** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx
- ** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx
- ** 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx
- **
- **
- ** Notes on UTF-16: (with wwww+1==uuuuu)
- **
- ** Word-0 Word-1 Value
- ** 110110ww wwzzzzyy 110111yy yyxxxxxx 000uuuuu zzzzyyyy yyxxxxxx
- ** zzzzyyyy yyxxxxxx 00000000 zzzzyyyy yyxxxxxx
- **
- **
- ** BOM or Byte Order Mark:
- ** 0xff 0xfe little-endian utf-16 follows
- ** 0xfe 0xff big-endian utf-16 follows
- **
- */
- /* #include <assert.h> */
- #ifndef SQLITE_AMALGAMATION
- /*
- ** The following constant value is used by the SQLITE_BIGENDIAN and
- ** SQLITE_LITTLEENDIAN macros.
- */
- SQLITE_PRIVATE const int sqlite3one = 1;
- #endif /* SQLITE_AMALGAMATION */
- /*
- ** This lookup table is used to help decode the first byte of
- ** a multi-byte UTF8 character.
- */
- static const unsigned char sqlite3Utf8Trans1[] = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
- };
- #define WRITE_UTF8(zOut, c) { \
- if( c<0x00080 ){ \
- *zOut++ = (u8)(c&0xFF); \
- } \
- else if( c<0x00800 ){ \
- *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \
- *zOut++ = 0x80 + (u8)(c & 0x3F); \
- } \
- else if( c<0x10000 ){ \
- *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \
- *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
- *zOut++ = 0x80 + (u8)(c & 0x3F); \
- }else{ \
- *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \
- *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \
- *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
- *zOut++ = 0x80 + (u8)(c & 0x3F); \
- } \
- }
- #define WRITE_UTF16LE(zOut, c) { \
- if( c<=0xFFFF ){ \
- *zOut++ = (u8)(c&0x00FF); \
- *zOut++ = (u8)((c>>8)&0x00FF); \
- }else{ \
- *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
- *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
- *zOut++ = (u8)(c&0x00FF); \
- *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
- } \
- }
- #define WRITE_UTF16BE(zOut, c) { \
- if( c<=0xFFFF ){ \
- *zOut++ = (u8)((c>>8)&0x00FF); \
- *zOut++ = (u8)(c&0x00FF); \
- }else{ \
- *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
- *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
- *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
- *zOut++ = (u8)(c&0x00FF); \
- } \
- }
- #define READ_UTF16LE(zIn, TERM, c){ \
- c = (*zIn++); \
- c += ((*zIn++)<<8); \
- if( c>=0xD800 && c<0xE000 && TERM ){ \
- int c2 = (*zIn++); \
- c2 += ((*zIn++)<<8); \
- c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \
- } \
- }
- #define READ_UTF16BE(zIn, TERM, c){ \
- c = ((*zIn++)<<8); \
- c += (*zIn++); \
- if( c>=0xD800 && c<0xE000 && TERM ){ \
- int c2 = ((*zIn++)<<8); \
- c2 += (*zIn++); \
- c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \
- } \
- }
- /*
- ** Translate a single UTF-8 character. Return the unicode value.
- **
- ** During translation, assume that the byte that zTerm points
- ** is a 0x00.
- **
- ** Write a pointer to the next unread byte back into *pzNext.
- **
- ** Notes On Invalid UTF-8:
- **
- ** * This routine never allows a 7-bit character (0x00 through 0x7f) to
- ** be encoded as a multi-byte character. Any multi-byte character that
- ** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
- **
- ** * This routine never allows a UTF16 surrogate value to be encoded.
- ** If a multi-byte character attempts to encode a value between
- ** 0xd800 and 0xe000 then it is rendered as 0xfffd.
- **
- ** * Bytes in the range of 0x80 through 0xbf which occur as the first
- ** byte of a character are interpreted as single-byte characters
- ** and rendered as themselves even though they are technically
- ** invalid characters.
- **
- ** * This routine accepts an infinite number of different UTF8 encodings
- ** for unicode values 0x80 and greater. It do not change over-length
- ** encodings to 0xfffd as some systems recommend.
- */
- #define READ_UTF8(zIn, zTerm, c) \
- c = *(zIn++); \
- if( c>=0xc0 ){ \
- c = sqlite3Utf8Trans1[c-0xc0]; \
- while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \
- c = (c<<6) + (0x3f & *(zIn++)); \
- } \
- if( c<0x80 \
- || (c&0xFFFFF800)==0xD800 \
- || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \
- }
- SQLITE_PRIVATE u32 sqlite3Utf8Read(
- const unsigned char *zIn, /* First byte of UTF-8 character */
- const unsigned char **pzNext /* Write first byte past UTF-8 char here */
- ){
- unsigned int c;
- /* Same as READ_UTF8() above but without the zTerm parameter.
- ** For this routine, we assume the UTF8 string is always zero-terminated.
- */
- c = *(zIn++);
- if( c>=0xc0 ){
- c = sqlite3Utf8Trans1[c-0xc0];
- while( (*zIn & 0xc0)==0x80 ){
- c = (c<<6) + (0x3f & *(zIn++));
- }
- if( c<0x80
- || (c&0xFFFFF800)==0xD800
- || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; }
- }
- *pzNext = zIn;
- return c;
- }
- /*
- ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
- ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
- */
- /* #define TRANSLATE_TRACE 1 */
- #ifndef SQLITE_OMIT_UTF16
- /*
- ** This routine transforms the internal text encoding used by pMem to
- ** desiredEnc. It is an error if the string is already of the desired
- ** encoding, or if *pMem does not contain a string value.
- */
- SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
- int len; /* Maximum length of output string in bytes */
- unsigned char *zOut; /* Output buffer */
- unsigned char *zIn; /* Input iterator */
- unsigned char *zTerm; /* End of input */
- unsigned char *z; /* Output iterator */
- unsigned int c;
- assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
- assert( pMem->flags&MEM_Str );
- assert( pMem->enc!=desiredEnc );
- assert( pMem->enc!=0 );
- assert( pMem->n>=0 );
- #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
- {
- char zBuf[100];
- sqlite3VdbeMemPrettyPrint(pMem, zBuf);
- fprintf(stderr, "INPUT: %s\n", zBuf);
- }
- #endif
- /* If the translation is between UTF-16 little and big endian, then
- ** all that is required is to swap the byte order. This case is handled
- ** differently from the others.
- */
- if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
- u8 temp;
- int rc;
- rc = sqlite3VdbeMemMakeWriteable(pMem);
- if( rc!=SQLITE_OK ){
- assert( rc==SQLITE_NOMEM );
- return SQLITE_NOMEM;
- }
- zIn = (u8*)pMem->z;
- zTerm = &zIn[pMem->n&~1];
- while( zIn<zTerm ){
- temp = *zIn;
- *zIn = *(zIn+1);
- zIn++;
- *zIn++ = temp;
- }
- pMem->enc = desiredEnc;
- goto translate_out;
- }
- /* Set len to the maximum number of bytes required in the output buffer. */
- if( desiredEnc==SQLITE_UTF8 ){
- /* When converting from UTF-16, the maximum growth results from
- ** translating a 2-byte character to a 4-byte UTF-8 character.
- ** A single byte is required for the output string
- ** nul-terminator.
- */
- pMem->n &= ~1;
- len = pMem->n * 2 + 1;
- }else{
- /* When converting from UTF-8 to UTF-16 the maximum growth is caused
- ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
- ** character. Two bytes are required in the output buffer for the
- ** nul-terminator.
- */
- len = pMem->n * 2 + 2;
- }
- /* Set zIn to point at the start of the input buffer and zTerm to point 1
- ** byte past the end.
- **
- ** Variable zOut is set to point at the output buffer, space obtained
- ** from sqlite3_malloc().
- */
- zIn = (u8*)pMem->z;
- zTerm = &zIn[pMem->n];
- zOut = sqlite3DbMallocRaw(pMem->db, len);
- if( !zOut ){
- return SQLITE_NOMEM;
- }
- z = zOut;
- if( pMem->enc==SQLITE_UTF8 ){
- if( desiredEnc==SQLITE_UTF16LE ){
- /* UTF-8 -> UTF-16 Little-endian */
- while( zIn<zTerm ){
- /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
- READ_UTF8(zIn, zTerm, c);
- WRITE_UTF16LE(z, c);
- }
- }else{
- assert( desiredEnc==SQLITE_UTF16BE );
- /* UTF-8 -> UTF-16 Big-endian */
- while( zIn<zTerm ){
- /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
- READ_UTF8(zIn, zTerm, c);
- WRITE_UTF16BE(z, c);
- }
- }
- pMem->n = (int)(z - zOut);
- *z++ = 0;
- }else{
- assert( desiredEnc==SQLITE_UTF8 );
- if( pMem->enc==SQLITE_UTF16LE ){
- /* UTF-16 Little-endian -> UTF-8 */
- while( zIn<zTerm ){
- READ_UTF16LE(zIn, zIn<zTerm, c);
- WRITE_UTF8(z, c);
- }
- }else{
- /* UTF-16 Big-endian -> UTF-8 */
- while( zIn<zTerm ){
- READ_UTF16BE(zIn, zIn<zTerm, c);
- WRITE_UTF8(z, c);
- }
- }
- pMem->n = (int)(z - zOut);
- }
- *z = 0;
- assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
- sqlite3VdbeMemRelease(pMem);
- pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
- pMem->enc = desiredEnc;
- pMem->flags |= (MEM_Term|MEM_Dyn);
- pMem->z = (char*)zOut;
- pMem->zMalloc = pMem->z;
- translate_out:
- #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
- {
- char zBuf[100];
- sqlite3VdbeMemPrettyPrint(pMem, zBuf);
- fprintf(stderr, "OUTPUT: %s\n", zBuf);
- }
- #endif
- return SQLITE_OK;
- }
- /*
- ** This routine checks for a byte-order mark at the beginning of the
- ** UTF-16 string stored in *pMem. If one is present, it is removed and
- ** the encoding of the Mem adjusted. This routine does not do any
- ** byte-swapping, it just sets Mem.enc appropriately.
- **
- ** The allocation (static, dynamic etc.) and encoding of the Mem may be
- ** changed by this function.
- */
- SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){
- int rc = SQLITE_OK;
- u8 bom = 0;
- assert( pMem->n>=0 );
- if( pMem->n>1 ){
- u8 b1 = *(u8 *)pMem->z;
- u8 b2 = *(((u8 *)pMem->z) + 1);
- if( b1==0xFE && b2==0xFF ){
- bom = SQLITE_UTF16BE;
- }
- if( b1==0xFF && b2==0xFE ){
- bom = SQLITE_UTF16LE;
- }
- }
-
- if( bom ){
- rc = sqlite3VdbeMemMakeWriteable(pMem);
- if( rc==SQLITE_OK ){
- pMem->n -= 2;
- memmove(pMem->z, &pMem->z[2], pMem->n);
- pMem->z[pMem->n] = '\0';
- pMem->z[pMem->n+1] = '\0';
- pMem->flags |= MEM_Term;
- pMem->enc = bom;
- }
- }
- return rc;
- }
- #endif /* SQLITE_OMIT_UTF16 */
- /*
- ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
- ** return the number of unicode characters in pZ up to (but not including)
- ** the first 0x00 byte. If nByte is not less than zero, return the
- ** number of unicode characters in the first nByte of pZ (or up to
- ** the first 0x00, whichever comes first).
- */
- SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){
- int r = 0;
- const u8 *z = (const u8*)zIn;
- const u8 *zTerm;
- if( nByte>=0 ){
- zTerm = &z[nByte];
- }else{
- zTerm = (const u8*)(-1);
- }
- assert( z<=zTerm );
- while( *z!=0 && z<zTerm ){
- SQLITE_SKIP_UTF8(z);
- r++;
- }
- return r;
- }
- /* This test function is not currently used by the automated test-suite.
- ** Hence it is only available in debug builds.
- */
- #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
- /*
- ** Translate UTF-8 to UTF-8.
- **
- ** This has the effect of making sure that the string is well-formed
- ** UTF-8. Miscoded characters are removed.
- **
- ** The translation is done in-place and aborted if the output
- ** overruns the input.
- */
- SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char *zIn){
- unsigned char *zOut = zIn;
- unsigned char *zStart = zIn;
- u32 c;
- while( zIn[0] && zOut<=zIn ){
- c = sqlite3Utf8Read(zIn, (const u8**)&zIn);
- if( c!=0xfffd ){
- WRITE_UTF8(zOut, c);
- }
- }
- *zOut = 0;
- return (int)(zOut - zStart);
- }
- #endif
- #ifndef SQLITE_OMIT_UTF16
- /*
- ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
- ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
- ** be freed by the calling function.
- **
- ** NULL is returned if there is an allocation error.
- */
- SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
- Mem m;
- memset(&m, 0, sizeof(m));
- m.db = db;
- sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
- sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
- if( db->mallocFailed ){
- sqlite3VdbeMemRelease(&m);
- m.z = 0;
- }
- assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
- assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
- assert( (m.flags & MEM_Dyn)!=0 || db->mallocFailed );
- assert( m.z || db->mallocFailed );
- return m.z;
- }
- /*
- ** Convert a UTF-8 string to the UTF-16 encoding specified by parameter
- ** enc. A pointer to the new string is returned, and the value of *pnOut
- ** is set to the length of the returned string in bytes. The call should
- ** arrange to call sqlite3DbFree() on the returned pointer when it is
- ** no longer required.
- **
- ** If a malloc failure occurs, NULL is returned and the db.mallocFailed
- ** flag set.
- */
- #ifdef SQLITE_ENABLE_STAT3
- SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *db, u8 enc, char *z, int n, int *pnOut){
- Mem m;
- memset(&m, 0, sizeof(m));
- m.db = db;
- sqlite3VdbeMemSetStr(&m, z, n, SQLITE_UTF8, SQLITE_STATIC);
- if( sqlite3VdbeMemTranslate(&m, enc) ){
- assert( db->mallocFailed );
- return 0;
- }
- assert( m.z==m.zMalloc );
- *pnOut = m.n;
- return m.z;
- }
- #endif
- /*
- ** zIn is a UTF-16 encoded unicode string at least nChar characters long.
- ** Return the number of bytes in the first nChar unicode characters
- ** in pZ. nChar must be non-negative.
- */
- SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){
- int c;
- unsigned char const *z = zIn;
- int n = 0;
-
- if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
- while( n<nChar ){
- READ_UTF16BE(z, 1, c);
- n++;
- }
- }else{
- while( n<nChar ){
- READ_UTF16LE(z, 1, c);
- n++;
- }
- }
- return (int)(z-(unsigned char const *)zIn);
- }
- #if defined(SQLITE_TEST)
- /*
- ** This routine is called from the TCL test function "translate_selftest".
- ** It checks that the primitives for serializing and deserializing
- ** characters in each encoding are inverses of each other.
- */
- SQLITE_PRIVATE void sqlite3UtfSelfTest(void){
- unsigned int i, t;
- unsigned char zBuf[20];
- unsigned char *z;
- int n;
- unsigned int c;
- for(i=0; i<0x00110000; i++){
- z = zBuf;
- WRITE_UTF8(z, i);
- n = (int)(z-zBuf);
- assert( n>0 && n<=4 );
- z[0] = 0;
- z = zBuf;
- c = sqlite3Utf8Read(z, (const u8**)&z);
- t = i;
- if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
- if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
- assert( c==t );
- assert( (z-zBuf)==n );
- }
- for(i=0; i<0x00110000; i++){
- if( i>=0xD800 && i<0xE000 ) continue;
- z = zBuf;
- WRITE_UTF16LE(z, i);
- n = (int)(z-zBuf);
- assert( n>0 && n<=4 );
- z[0] = 0;
- z = zBuf;
- READ_UTF16LE(z, 1, c);
- assert( c==i );
- assert( (z-zBuf)==n );
- }
- for(i=0; i<0x00110000; i++){
- if( i>=0xD800 && i<0xE000 ) continue;
- z = zBuf;
- WRITE_UTF16BE(z, i);
- n = (int)(z-zBuf);
- assert( n>0 && n<=4 );
- z[0] = 0;
- z = zBuf;
- READ_UTF16BE(z, 1, c);
- assert( c==i );
- assert( (z-zBuf)==n );
- }
- }
- #endif /* SQLITE_TEST */
- #endif /* SQLITE_OMIT_UTF16 */
- /************** End of utf.c *************************************************/
- /************** Begin file util.c ********************************************/
- /*
- ** 2001 September 15
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** Utility functions used throughout sqlite.
- **
- ** This file contains functions for allocating memory, comparing
- ** strings, and stuff like that.
- **
- */
- /* #include <stdarg.h> */
- #ifdef SQLITE_HAVE_ISNAN
- # include <math.h>
- #endif
- /*
- ** Routine needed to support the testcase() macro.
- */
- #ifdef SQLITE_COVERAGE_TEST
- SQLITE_PRIVATE void sqlite3Coverage(int x){
- static unsigned dummy = 0;
- dummy += (unsigned)x;
- }
- #endif
- #ifndef SQLITE_OMIT_FLOATING_POINT
- /*
- ** Return true if the floating point value is Not a Number (NaN).
- **
- ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
- ** Otherwise, we have our own implementation that works on most systems.
- */
- SQLITE_PRIVATE int sqlite3IsNaN(double x){
- int rc; /* The value return */
- #if !defined(SQLITE_HAVE_ISNAN)
- /*
- ** Systems that support the isnan() library function should probably
- ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have
- ** found that many systems do not have a working isnan() function so
- ** this implementation is provided as an alternative.
- **
- ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
- ** On the other hand, the use of -ffast-math comes with the following
- ** warning:
- **
- ** This option [-ffast-math] should never be turned on by any
- ** -O option since it can result in incorrect output for programs
- ** which depend on an exact implementation of IEEE or ISO
- ** rules/specifications for math functions.
- **
- ** Under MSVC, this NaN test may fail if compiled with a floating-
- ** point precision mode other than /fp:precise. From the MSDN
- ** documentation:
- **
- ** The compiler [with /fp:precise] will properly handle comparisons
- ** involving NaN. For example, x != x evaluates to true if x is NaN
- ** ...
- */
- #ifdef __FAST_MATH__
- # error SQLite will not work correctly with the -ffast-math option of GCC.
- #endif
- volatile double y = x;
- volatile double z = y;
- rc = (y!=z);
- #else /* if defined(SQLITE_HAVE_ISNAN) */
- rc = isnan(x);
- #endif /* SQLITE_HAVE_ISNAN */
- testcase( rc );
- return rc;
- }
- #endif /* SQLITE_OMIT_FLOATING_POINT */
- /*
- ** Compute a string length that is limited to what can be stored in
- ** lower 30 bits of a 32-bit signed integer.
- **
- ** The value returned will never be negative. Nor will it ever be greater
- ** than the actual length of the string. For very long strings (greater
- ** than 1GiB) the value returned might be less than the true string length.
- */
- SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
- const char *z2 = z;
- if( z==0 ) return 0;
- while( *z2 ){ z2++; }
- return 0x3fffffff & (int)(z2 - z);
- }
- /*
- ** Set the most recent error code and error string for the sqlite
- ** handle "db". The error code is set to "err_code".
- **
- ** If it is not NULL, string zFormat specifies the format of the
- ** error string in the style of the printf functions: The following
- ** format characters are allowed:
- **
- ** %s Insert a string
- ** %z A string that should be freed after use
- ** %d Insert an integer
- ** %T Insert a token
- ** %S Insert the first element of a SrcList
- **
- ** zFormat and any string tokens that follow it are assumed to be
- ** encoded in UTF-8.
- **
- ** To clear the most recent error for sqlite handle "db", sqlite3Error
- ** should be called with err_code set to SQLITE_OK and zFormat set
- ** to NULL.
- */
- SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
- if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
- db->errCode = err_code;
- if( zFormat ){
- char *z;
- va_list ap;
- va_start(ap, zFormat);
- z = sqlite3VMPrintf(db, zFormat, ap);
- va_end(ap);
- sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
- }else{
- sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
- }
- }
- }
- /*
- ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
- ** The following formatting characters are allowed:
- **
- ** %s Insert a string
- ** %z A string that should be freed after use
- ** %d Insert an integer
- ** %T Insert a token
- ** %S Insert the first element of a SrcList
- **
- ** This function should be used to report any error that occurs whilst
- ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
- ** last thing the sqlite3_prepare() function does is copy the error
- ** stored by this function into the database handle using sqlite3Error().
- ** Function sqlite3Error() should be used during statement execution
- ** (sqlite3_step() etc.).
- */
- SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
- char *zMsg;
- va_list ap;
- sqlite3 *db = pParse->db;
- va_start(ap, zFormat);
- zMsg = sqlite3VMPrintf(db, zFormat, ap);
- va_end(ap);
- if( db->suppressErr ){
- sqlite3DbFree(db, zMsg);
- }else{
- pParse->nErr++;
- sqlite3DbFree(db, pParse->zErrMsg);
- pParse->zErrMsg = zMsg;
- pParse->rc = SQLITE_ERROR;
- }
- }
- /*
- ** Convert an SQL-style quoted string into a normal string by removing
- ** the quote characters. The conversion is done in-place. If the
- ** input does not begin with a quote character, then this routine
- ** is a no-op.
- **
- ** The input string must be zero-terminated. A new zero-terminator
- ** is added to the dequoted string.
- **
- ** The return value is -1 if no dequoting occurs or the length of the
- ** dequoted string, exclusive of the zero terminator, if dequoting does
- ** occur.
- **
- ** 2002-Feb-14: This routine is extended to remove MS-Access style
- ** brackets from around identifers. For example: "[a-b-c]" becomes
- ** "a-b-c".
- */
- SQLITE_PRIVATE int sqlite3Dequote(char *z){
- char quote;
- int i, j;
- if( z==0 ) return -1;
- quote = z[0];
- switch( quote ){
- case '\'': break;
- case '"': break;
- case '`': break; /* For MySQL compatibility */
- case '[': quote = ']'; break; /* For MS SqlServer compatibility */
- default: return -1;
- }
- for(i=1, j=0; ALWAYS(z[i]); i++){
- if( z[i]==quote ){
- if( z[i+1]==quote ){
- z[j++] = quote;
- i++;
- }else{
- break;
- }
- }else{
- z[j++] = z[i];
- }
- }
- z[j] = 0;
- return j;
- }
- /* Convenient short-hand */
- #define UpperToLower sqlite3UpperToLower
- /*
- ** Some systems have stricmp(). Others have strcasecmp(). Because
- ** there is no consistency, we will define our own.
- **
- ** IMPLEMENTATION-OF: R-20522-24639 The sqlite3_strnicmp() API allows
- ** applications and extensions to compare the contents of two buffers
- ** containing UTF-8 strings in a case-independent fashion, using the same
- ** definition of case independence that SQLite uses internally when
- ** comparing identifiers.
- */
- SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){
- register unsigned char *a, *b;
- a = (unsigned char *)zLeft;
- b = (unsigned char *)zRight;
- while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
- return UpperToLower[*a] - UpperToLower[*b];
- }
- SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
- register unsigned char *a, *b;
- a = (unsigned char *)zLeft;
- b = (unsigned char *)zRight;
- while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
- return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
- }
- /*
- ** The string z[] is an text representation of a real number.
- ** Convert this string to a double and write it into *pResult.
- **
- ** The string z[] is length bytes in length (bytes, not characters) and
- ** uses the encoding enc. The string is not necessarily zero-terminated.
- **
- ** Return TRUE if the result is a valid real number (or integer) and FALSE
- ** if the string is empty or contains extraneous text. Valid numbers
- ** are in one of these formats:
- **
- ** [+-]digits[E[+-]digits]
- ** [+-]digits.[digits][E[+-]digits]
- ** [+-].digits[E[+-]digits]
- **
- ** Leading and trailing whitespace is ignored for the purpose of determining
- ** validity.
- **
- ** If some prefix of the input string is a valid number, this routine
- ** returns FALSE but it still converts the prefix and writes the result
- ** into *pResult.
- */
- SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
- #ifndef SQLITE_OMIT_FLOATING_POINT
- int incr = (enc==SQLITE_UTF8?1:2);
- const char *zEnd = z + length;
- /* sign * significand * (10 ^ (esign * exponent)) */
- int sign = 1; /* sign of significand */
- i64 s = 0; /* significand */
- int d = 0; /* adjust exponent for shifting decimal point */
- int esign = 1; /* sign of exponent */
- int e = 0; /* exponent */
- int eValid = 1; /* True exponent is either not used or is well-formed */
- double result;
- int nDigits = 0;
- *pResult = 0.0; /* Default return value, in case of an error */
- if( enc==SQLITE_UTF16BE ) z++;
- /* skip leading spaces */
- while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
- if( z>=zEnd ) return 0;
- /* get sign of significand */
- if( *z=='-' ){
- sign = -1;
- z+=incr;
- }else if( *z=='+' ){
- z+=incr;
- }
- /* skip leading zeroes */
- while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;
- /* copy max significant digits to significand */
- while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
- s = s*10 + (*z - '0');
- z+=incr, nDigits++;
- }
- /* skip non-significant significand digits
- ** (increase exponent by d to shift decimal left) */
- while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
- if( z>=zEnd ) goto do_atof_calc;
- /* if decimal point is present */
- if( *z=='.' ){
- z+=incr;
- /* copy digits from after decimal to significand
- ** (decrease exponent by d to shift decimal right) */
- while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
- s = s*10 + (*z - '0');
- z+=incr, nDigits++, d--;
- }
- /* skip non-significant digits */
- while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++;
- }
- if( z>=zEnd ) goto do_atof_calc;
- /* if exponent is present */
- if( *z=='e' || *z=='E' ){
- z+=incr;
- eValid = 0;
- if( z>=zEnd ) goto do_atof_calc;
- /* get sign of exponent */
- if( *z=='-' ){
- esign = -1;
- z+=incr;
- }else if( *z=='+' ){
- z+=incr;
- }
- /* copy digits to exponent */
- while( z<zEnd && sqlite3Isdigit(*z) ){
- e = e<10000 ? (e*10 + (*z - '0')) : 10000;
- z+=incr;
- eValid = 1;
- }
- }
- /* skip trailing spaces */
- if( nDigits && eValid ){
- while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
- }
- do_atof_calc:
- /* adjust exponent by d, and update sign */
- e = (e*esign) + d;
- if( e<0 ) {
- esign = -1;
- e *= -1;
- } else {
- esign = 1;
- }
- /* if 0 significand */
- if( !s ) {
- /* In the IEEE 754 standard, zero is signed.
- ** Add the sign if we've seen at least one digit */
- result = (sign<0 && nDigits) ? -(double)0 : (double)0;
- } else {
- /* attempt to reduce exponent */
- if( esign>0 ){
- while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
- }else{
- while( !(s%10) && e>0 ) e--,s/=10;
- }
- /* adjust the sign of significand */
- s = sign<0 ? -s : s;
- /* if exponent, scale significand as appropriate
- ** and store in result. */
- if( e ){
- double scale = 1.0;
- /* attempt to handle extremely small/large numbers better */
- if( e>307 && e<342 ){
- while( e%308 ) { scale *= 1.0e+1; e -= 1; }
- if( esign<0 ){
- result = s / scale;
- result /= 1.0e+308;
- }else{
- result = s * scale;
- result *= 1.0e+308;
- }
- }else if( e>=342 ){
- if( esign<0 ){
- result = 0.0*s;
- }else{
- result = 1e308*1e308*s; /* Infinity */
- }
- }else{
- /* 1.0e+22 is the largest power of 10 than can be
- ** represented exactly. */
- while( e%22 ) { scale *= 1.0e+1; e -= 1; }
- while( e>0 ) { scale *= 1.0e+22; e -= 22; }
- if( esign<0 ){
- result = s / scale;
- }else{
- result = s * scale;
- }
- }
- } else {
- result = (double)s;
- }
- }
- /* store the result */
- *pResult = result;
- /* return true if number and no extra non-whitespace chracters after */
- return z>=zEnd && nDigits>0 && eValid;
- #else
- return !sqlite3Atoi64(z, pResult, length, enc);
- #endif /* SQLITE_OMIT_FLOATING_POINT */
- }
- /*
- ** Compare the 19-character string zNum against the text representation
- ** value 2^63: 9223372036854775808. Return negative, zero, or positive
- ** if zNum is less than, equal to, or greater than the string.
- ** Note that zNum must contain exactly 19 characters.
- **
- ** Unlike memcmp() this routine is guaranteed to return the difference
- ** in the values of the last digit if the only difference is in the
- ** last digit. So, for example,
- **
- ** compare2pow63("9223372036854775800", 1)
- **
- ** will return -8.
- */
- static int compare2pow63(const char *zNum, int incr){
- int c = 0;
- int i;
- /* 012345678901234567 */
- const char *pow63 = "922337203685477580";
- for(i=0; c==0 && i<18; i++){
- c = (zNum[i*incr]-pow63[i])*10;
- }
- if( c==0 ){
- c = zNum[18*incr] - '8';
- testcase( c==(-1) );
- testcase( c==0 );
- testcase( c==(+1) );
- }
- return c;
- }
- /*
- ** Convert zNum to a 64-bit signed integer.
- **
- ** If the zNum value is representable as a 64-bit twos-complement
- ** integer, then write that value into *pNum and return 0.
- **
- ** If zNum is exactly 9223372036854665808, return 2. This special
- ** case is broken out because while 9223372036854665808 cannot be a
- ** signed 64-bit integer, its negative -9223372036854665808 can be.
- **
- ** If zNum is too big for a 64-bit integer and is not
- ** 9223372036854665808 then return 1.
- **
- ** length is the number of bytes in the string (bytes, not characters).
- ** The string is not necessarily zero-terminated. The encoding is
- ** given by enc.
- */
- SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
- int incr = (enc==SQLITE_UTF8?1:2);
- u64 u = 0;
- int neg = 0; /* assume positive */
- int i;
- int c = 0;
- const char *zStart;
- const char *zEnd = zNum + length;
- if( enc==SQLITE_UTF16BE ) zNum++;
- while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
- if( zNum<zEnd ){
- if( *zNum=='-' ){
- neg = 1;
- zNum+=incr;
- }else if( *zNum=='+' ){
- zNum+=incr;
- }
- }
- zStart = zNum;
- while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
- for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
- u = u*10 + c - '0';
- }
- if( u>LARGEST_INT64 ){
- *pNum = SMALLEST_INT64;
- }else if( neg ){
- *pNum = -(i64)u;
- }else{
- *pNum = (i64)u;
- }
- testcase( i==18 );
- testcase( i==19 );
- testcase( i==20 );
- if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr ){
- /* zNum is empty or contains non-numeric text or is longer
- ** than 19 digits (thus guaranteeing that it is too large) */
- return 1;
- }else if( i<19*incr ){
- /* Less than 19 digits, so we know that it fits in 64 bits */
- assert( u<=LARGEST_INT64 );
- return 0;
- }else{
- /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
- c = compare2pow63(zNum, incr);
- if( c<0 ){
- /* zNum is less than 9223372036854775808 so it fits */
- assert( u<=LARGEST_INT64 );
- return 0;
- }else if( c>0 ){
- /* zNum is greater than 9223372036854775808 so it overflows */
- return 1;
- }else{
- /* zNum is exactly 9223372036854775808. Fits if negative. The
- ** special case 2 overflow if positive */
- assert( u-1==LARGEST_INT64 );
- assert( (*pNum)==SMALLEST_INT64 );
- return neg ? 0 : 2;
- }
- }
- }
- /*
- ** If zNum represents an integer that will fit in 32-bits, then set
- ** *pValue to that integer and return true. Otherwise return false.
- **
- ** Any non-numeric characters that following zNum are ignored.
- ** This is different from sqlite3Atoi64() which requires the
- ** input number to be zero-terminated.
- */
- SQLITE_PRIVATE int sqlite3GetInt32(const char *zNum, int *pValue){
- sqlite_int64 v = 0;
- int i, c;
- int neg = 0;
- if( zNum[0]=='-' ){
- neg = 1;
- zNum++;
- }else if( zNum[0]=='+' ){
- zNum++;
- }
- while( zNum[0]=='0' ) zNum++;
- for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
- v = v*10 + c;
- }
- /* The longest decimal representation of a 32 bit integer is 10 digits:
- **
- ** 1234567890
- ** 2^31 -> 2147483648
- */
- testcase( i==10 );
- if( i>10 ){
- return 0;
- }
- testcase( v-neg==2147483647 );
- if( v-neg>2147483647 ){
- return 0;
- }
- if( neg ){
- v = -v;
- }
- *pValue = (int)v;
- return 1;
- }
- /*
- ** Return a 32-bit integer value extracted from a string. If the
- ** string is not an integer, just return 0.
- */
- SQLITE_PRIVATE int sqlite3Atoi(const char *z){
- int x = 0;
- if( z ) sqlite3GetInt32(z, &x);
- return x;
- }
- /*
- ** The variable-length integer encoding is as follows:
- **
- ** KEY:
- ** A = 0xxxxxxx 7 bits of data and one flag bit
- ** B = 1xxxxxxx 7 bits of data and one flag bit
- ** C = xxxxxxxx 8 bits of data
- **
- ** 7 bits - A
- ** 14 bits - BA
- ** 21 bits - BBA
- ** 28 bits - BBBA
- ** 35 bits - BBBBA
- ** 42 bits - BBBBBA
- ** 49 bits - BBBBBBA
- ** 56 bits - BBBBBBBA
- ** 64 bits - BBBBBBBBC
- */
- /*
- ** Write a 64-bit variable-length integer to memory starting at p[0].
- ** The length of data write will be between 1 and 9 bytes. The number
- ** of bytes written is returned.
- **
- ** A variable-length integer consists of the lower 7 bits of each byte
- ** for all bytes that have the 8th bit set and one byte with the 8th
- ** bit clear. Except, if we get to the 9th byte, it stores the full
- ** 8 bits and is the last byte.
- */
- SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){
- int i, j, n;
- u8 buf[10];
- if( v & (((u64)0xff000000)<<32) ){
- p[8] = (u8)v;
- v >>= 8;
- for(i=7; i>=0; i--){
- p[i] = (u8)((v & 0x7f) | 0x80);
- v >>= 7;
- }
- return 9;
- }
- n = 0;
- do{
- buf[n++] = (u8)((v & 0x7f) | 0x80);
- v >>= 7;
- }while( v!=0 );
- buf[0] &= 0x7f;
- assert( n<=9 );
- for(i=0, j=n-1; j>=0; j--, i++){
- p[i] = buf[j];
- }
- return n;
- }
- /*
- ** This routine is a faster version of sqlite3PutVarint() that only
- ** works for 32-bit positive integers and which is optimized for
- ** the common case of small integers. A MACRO version, putVarint32,
- ** is provided which inlines the single-byte case. All code should use
- ** the MACRO version as this function assumes the single-byte case has
- ** already been handled.
- */
- SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char *p, u32 v){
- #ifndef putVarint32
- if( (v & ~0x7f)==0 ){
- p[0] = v;
- return 1;
- }
- #endif
- if( (v & ~0x3fff)==0 ){
- p[0] = (u8)((v>>7) | 0x80);
- p[1] = (u8)(v & 0x7f);
- return 2;
- }
- return sqlite3PutVarint(p, v);
- }
- /*
- ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
- ** are defined here rather than simply putting the constant expressions
- ** inline in order to work around bugs in the RVT compiler.
- **
- ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
- **
- ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
- */
- #define SLOT_2_0 0x001fc07f
- #define SLOT_4_2_0 0xf01fc07f
- /*
- ** Read a 64-bit variable-length integer from memory starting at p[0].
- ** Return the number of bytes read. The value is stored in *v.
- */
- SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
- u32 a,b,s;
- a = *p;
- /* a: p0 (unmasked) */
- if (!(a&0x80))
- {
- *v = a;
- return 1;
- }
- p++;
- b = *p;
- /* b: p1 (unmasked) */
- if (!(b&0x80))
- {
- a &= 0x7f;
- a = a<<7;
- a |= b;
- *v = a;
- return 2;
- }
- /* Verify that constants are precomputed correctly */
- assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
- assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
- p++;
- a = a<<14;
- a |= *p;
- /* a: p0<<14 | p2 (unmasked) */
- if (!(a&0x80))
- {
- a &= SLOT_2_0;
- b &= 0x7f;
- b = b<<7;
- a |= b;
- *v = a;
- return 3;
- }
- /* CSE1 from below */
- a &= SLOT_2_0;
- p++;
- b = b<<14;
- b |= *p;
- /* b: p1<<14 | p3 (unmasked) */
- if (!(b&0x80))
- {
- b &= SLOT_2_0;
- /* moved CSE1 up */
- /* a &= (0x7f<<14)|(0x7f); */
- a = a<<7;
- a |= b;
- *v = a;
- return 4;
- }
- /* a: p0<<14 | p2 (masked) */
- /* b: p1<<14 | p3 (unmasked) */
- /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
- /* moved CSE1 up */
- /* a &= (0x7f<<14)|(0x7f); */
- b &= SLOT_2_0;
- s = a;
- /* s: p0<<14 | p2 (masked) */
- p++;
- a = a<<14;
- a |= *p;
- /* a: p0<<28 | p2<<14 | p4 (unmasked) */
- if (!(a&0x80))
- {
- /* we can skip these cause they were (effectively) done above in calc'ing s */
- /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
- /* b &= (0x7f<<14)|(0x7f); */
- b = b<<7;
- a |= b;
- s = s>>18;
- *v = ((u64)s)<<32 | a;
- return 5;
- }
- /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
- s = s<<7;
- s |= b;
- /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
- p++;
- b = b<<14;
- b |= *p;
- /* b: p1<<28 | p3<<14 | p5 (unmasked) */
- if (!(b&0x80))
- {
- /* we can skip this cause it was (effectively) done above in calc'ing s */
- /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
- a &= SLOT_2_0;
- a = a<<7;
- a |= b;
- s = s>>18;
- *v = ((u64)s)<<32 | a;
- return 6;
- }
- p++;
- a = a<<14;
- a |= *p;
- /* a: p2<<28 | p4<<14 | p6 (unmasked) */
- if (!(a&0x80))
- {
- a &= SLOT_4_2_0;
- b &= SLOT_2_0;
- b = b<<7;
- a |= b;
- s = s>>11;
- *v = ((u64)s)<<32 | a;
- return 7;
- }
- /* CSE2 from below */
- a &= SLOT_2_0;
- p++;
- b = b<<14;
- b |= *p;
- /* b: p3<<28 | p5<<14 | p7 (unmasked) */
- if (!(b&0x80))
- {
- b &= SLOT_4_2_0;
- /* moved CSE2 up */
- /* a &= (0x7f<<14)|(0x7f); */
- a = a<<7;
- a |= b;
- s = s>>4;
- *v = ((u64)s)<<32 | a;
- return 8;
- }
- p++;
- a = a<<15;
- a |= *p;
- /* a: p4<<29 | p6<<15 | p8 (unmasked) */
- /* moved CSE2 up */
- /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
- b &= SLOT_2_0;
- b = b<<8;
- a |= b;
- s = s<<4;
- b = p[-4];
- b &= 0x7f;
- b = b>>3;
- s |= b;
- *v = ((u64)s)<<32 | a;
- return 9;
- }
- /*
- ** Read a 32-bit variable-length integer from memory starting at p[0].
- ** Return the number of bytes read. The value is stored in *v.
- **
- ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
- ** integer, then set *v to 0xffffffff.
- **
- ** A MACRO version, getVarint32, is provided which inlines the
- ** single-byte case. All code should use the MACRO version as
- ** this function assumes the single-byte case has already been handled.
- */
- SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
- u32 a,b;
- /* The 1-byte case. Overwhelmingly the most common. Handled inline
- ** by the getVarin32() macro */
- a = *p;
- /* a: p0 (unmasked) */
- #ifndef getVarint32
- if (!(a&0x80))
- {
- /* Values between 0 and 127 */
- *v = a;
- return 1;
- }
- #endif
- /* The 2-byte case */
- p++;
- b = *p;
- /* b: p1 (unmasked) */
- if (!(b&0x80))
- {
- /* Values between 128 and 16383 */
- a &= 0x7f;
- a = a<<7;
- *v = a | b;
- return 2;
- }
- /* The 3-byte case */
- p++;
- a = a<<14;
- a |= *p;
- /* a: p0<<14 | p2 (unmasked) */
- if (!(a&0x80))
- {
- /* Values between 16384 and 2097151 */
- a &= (0x7f<<14)|(0x7f);
- b &= 0x7f;
- b = b<<7;
- *v = a | b;
- return 3;
- }
- /* A 32-bit varint is used to store size information in btrees.
- ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
- ** A 3-byte varint is sufficient, for example, to record the size
- ** of a 1048569-byte BLOB or string.
- **
- ** We only unroll the first 1-, 2-, and 3- byte cases. The very
- ** rare larger cases can be handled by the slower 64-bit varint
- ** routine.
- */
- #if 1
- {
- u64 v64;
- u8 n;
- p -= 2;
- n = sqlite3GetVarint(p, &v64);
- assert( n>3 && n<=9 );
- if( (v64 & SQLITE_MAX_U32)!=v64 ){
- *v = 0xffffffff;
- }else{
- *v = (u32)v64;
- }
- return n;
- }
- #else
- /* For following code (kept for historical record only) shows an
- ** unrolling for the 3- and 4-byte varint cases. This code is
- ** slightly faster, but it is also larger and much harder to test.
- */
- p++;
- b = b<<14;
- b |= *p;
- /* b: p1<<14 | p3 (unmasked) */
- if (!(b&0x80))
- {
- /* Values between 2097152 and 268435455 */
- b &= (0x7f<<14)|(0x7f);
- a &= (0x7f<<14)|(0x7f);
- a = a<<7;
- *v = a | b;
- return 4;
- }
- p++;
- a = a<<14;
- a |= *p;
- /* a: p0<<28 | p2<<14 | p4 (unmasked) */
- if (!(a&0x80))
- {
- /* Values between 268435456 and 34359738367 */
- a &= SLOT_4_2_0;
- b &= SLOT_4_2_0;
- b = b<<7;
- *v = a | b;
- return 5;
- }
- /* We can only reach this point when reading a corrupt database
- ** file. In that case we are not in any hurry. Use the (relatively
- ** slow) general-purpose sqlite3GetVarint() routine to extract the
- ** value. */
- {
- u64 v64;
- u8 n;
- p -= 4;
- n = sqlite3GetVarint(p, &v64);
- assert( n>5 && n<=9 );
- *v = (u32)v64;
- return n;
- }
- #endif
- }
- /*
- ** Return the number of bytes that will be needed to store the given
- ** 64-bit integer.
- */
- SQLITE_PRIVATE int sqlite3VarintLen(u64 v){
- int i = 0;
- do{
- i++;
- v >>= 7;
- }while( v!=0 && ALWAYS(i<9) );
- return i;
- }
- /*
- ** Read or write a four-byte big-endian integer value.
- */
- SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
- return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
- }
- SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
- p[0] = (u8)(v>>24);
- p[1] = (u8)(v>>16);
- p[2] = (u8)(v>>8);
- p[3] = (u8)v;
- }
- /*
- ** Translate a single byte of Hex into an integer.
- ** This routine only works if h really is a valid hexadecimal
- ** character: 0..9a..fA..F
- */
- SQLITE_PRIVATE u8 sqlite3HexToInt(int h){
- assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
- #ifdef SQLITE_ASCII
- h += 9*(1&(h>>6));
- #endif
- #ifdef SQLITE_EBCDIC
- h += 9*(1&~(h>>4));
- #endif
- return (u8)(h & 0xf);
- }
- #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
- /*
- ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
- ** value. Return a pointer to its binary value. Space to hold the
- ** binary value has been obtained from malloc and must be freed by
- ** the calling routine.
- */
- SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
- char *zBlob;
- int i;
- zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
- n--;
- if( zBlob ){
- for(i=0; i<n; i+=2){
- zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
- }
- zBlob[i/2] = 0;
- }
- return zBlob;
- }
- #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
- /*
- ** Log an error that is an API call on a connection pointer that should
- ** not have been used. The "type" of connection pointer is given as the
- ** argument. The zType is a word like "NULL" or "closed" or "invalid".
- */
- static void logBadConnection(const char *zType){
- sqlite3_log(SQLITE_MISUSE,
- "API call with %s database connection pointer",
- zType
- );
- }
- /*
- ** Check to make sure we have a valid db pointer. This test is not
- ** foolproof but it does provide some measure of protection against
- ** misuse of the interface such as passing in db pointers that are
- ** NULL or which have been previously closed. If this routine returns
- ** 1 it means that the db pointer is valid and 0 if it should not be
- ** dereferenced for any reason. The calling function should invoke
- ** SQLITE_MISUSE immediately.
- **
- ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
- ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
- ** open properly and is not fit for general use but which can be
- ** used as an argument to sqlite3_errmsg() or sqlite3_close().
- */
- SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){
- u32 magic;
- if( db==0 ){
- logBadConnection("NULL");
- return 0;
- }
- magic = db->magic;
- if( magic!=SQLITE_MAGIC_OPEN ){
- if( sqlite3SafetyCheckSickOrOk(db) ){
- testcase( sqlite3GlobalConfig.xLog!=0 );
- logBadConnection("unopened");
- }
- return 0;
- }else{
- return 1;
- }
- }
- SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
- u32 magic;
- magic = db->magic;
- if( magic!=SQLITE_MAGIC_SICK &&
- magic!=SQLITE_MAGIC_OPEN &&
- magic!=SQLITE_MAGIC_BUSY ){
- testcase( sqlite3GlobalConfig.xLog!=0 );
- logBadConnection("invalid");
- return 0;
- }else{
- return 1;
- }
- }
- /*
- ** Attempt to add, substract, or multiply the 64-bit signed value iB against
- ** the other 64-bit signed integer at *pA and store the result in *pA.
- ** Return 0 on success. Or if the operation would have resulted in an
- ** overflow, leave *pA unchanged and return 1.
- */
- SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){
- i64 iA = *pA;
- testcase( iA==0 ); testcase( iA==1 );
- testcase( iB==-1 ); testcase( iB==0 );
- if( iB>=0 ){
- testcase( iA>0 && LARGEST_INT64 - iA == iB );
- testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
- if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
- *pA += iB;
- }else{
- testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
- testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
- if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
- *pA += iB;
- }
- return 0;
- }
- SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){
- testcase( iB==SMALLEST_INT64+1 );
- if( iB==SMALLEST_INT64 ){
- testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
- if( (*pA)>=0 ) return 1;
- *pA -= iB;
- return 0;
- }else{
- return sqlite3AddInt64(pA, -iB);
- }
- }
- #define TWOPOWER32 (((i64)1)<<32)
- #define TWOPOWER31 (((i64)1)<<31)
- SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){
- i64 iA = *pA;
- i64 iA1, iA0, iB1, iB0, r;
- iA1 = iA/TWOPOWER32;
- iA0 = iA % TWOPOWER32;
- iB1 = iB/TWOPOWER32;
- iB0 = iB % TWOPOWER32;
- if( iA1*iB1 != 0 ) return 1;
- assert( iA1*iB0==0 || iA0*iB1==0 );
- r = iA1*iB0 + iA0*iB1;
- testcase( r==(-TWOPOWER31)-1 );
- testcase( r==(-TWOPOWER31) );
- testcase( r==TWOPOWER31 );
- testcase( r==TWOPOWER31-1 );
- if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1;
- r *= TWOPOWER32;
- if( sqlite3AddInt64(&r, iA0*iB0) ) return 1;
- *pA = r;
- return 0;
- }
- /*
- ** Compute the absolute value of a 32-bit signed integer, of possible. Or
- ** if the integer has a value of -2147483648, return +2147483647
- */
- SQLITE_PRIVATE int sqlite3AbsInt32(int x){
- if( x>=0 ) return x;
- if( x==(int)0x80000000 ) return 0x7fffffff;
- return -x;
- }
- #ifdef SQLITE_ENABLE_8_3_NAMES
- /*
- ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
- ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
- ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
- ** three characters, then shorten the suffix on z[] to be the last three
- ** characters of the original suffix.
- **
- ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
- ** do the suffix shortening regardless of URI parameter.
- **
- ** Examples:
- **
- ** test.db-journal => test.nal
- ** test.db-wal => test.wal
- ** test.db-shm => test.shm
- ** test.db-mj7f3319fa => test.9fa
- */
- SQLITE_PRIVATE void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
- #if SQLITE_ENABLE_8_3_NAMES<2
- if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
- #endif
- {
- int i, sz;
- sz = sqlite3Strlen30(z);
- for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
- if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
- }
- }
- #endif
- /************** End of util.c ************************************************/
- /************** Begin file hash.c ********************************************/
- /*
- ** 2001 September 22
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- *************************************************************************
- ** This is the implementation of generic hash-tables
- ** used in SQLite.
- */
- /* #include <assert.h> */
- /* Turn bulk memory into a hash table object by initializing the
- ** fields of the Hash structure.
- **
- ** "pNew" is a pointer to the hash table that is to be initialized.
- */
- SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
- assert( pNew!=0 );
- pNew->first = 0;
- pNew->count = 0;
- pNew->htsize = 0;
- pNew->ht = 0;
- }
- /* Remove all entries from a hash table. Reclaim all memory.
- ** Call this routine to delete a hash table or to reset a hash table
- ** to the empty state.
- */
- SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){
- HashElem *elem; /* For looping over all elements of the table */
- assert( pH!=0 );
- elem = pH->first;
- pH->first = 0;
- sqlite3_free(pH->ht);
- pH->ht = 0;
- pH->htsize = 0;
- while( elem ){
- HashElem *next_elem = elem->next;
- sqlite3_free(elem);
- elem = next_elem;
- }
- pH->count = 0;
- }
- /*
- ** The hashing function.
- */
- static unsigned int strHash(const char *z, int nKey){
- int h = 0;
- assert( nKey>=0 );
- while( nKey > 0 ){
- h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++];
- nKey--;
- }
- return h;
- }
- /* Link pNew element into the hash table pH. If pEntry!=0 then also
- ** insert pNew into the pEntry hash bucket.
- */
- static void insertElement(
- Hash *pH, /* The complete hash table */
- struct _ht *pEntry, /* The entry into which pNew is inserted */
- HashElem *pNew /* The element to be inserted */
- ){
- HashElem *pHead; /* First element already in pEntry */
- if( pEntry ){
- pHead = pEntry->count ? pEntry->chain : 0;
- pEntry->count++;
- pEntry->chain = pNew;
- }else{
- pHead = 0;
- }
- if( pHead ){
- pNew->next = pHead;
- pNew->prev = pHead->prev;
- if( pHead->prev ){ pHead->prev->next = pNew; }
- else { pH->first = pNew; }
- pHead->prev = pNew;
- }else{
- pNew->next = pH->first;
- if( pH->first ){ pH->first->prev = pNew; }
- pNew->prev = 0;
- pH->first = pNew;
- }
- }
- /* Resize the hash table so that it cantains "new_size" buckets.
- **
- ** The hash table might fail to resize if sqlite3_malloc() fails or
- ** if the new size is the same as the prior size.
- ** Return TRUE if the resize occurs and false if not.
- */
- static int rehash(Hash *pH, unsigned int new_size){
- struct _ht *new_ht; /* The new hash table */
- HashElem *elem, *next_elem; /* For looping over existing elements */
- #if SQLITE_MALLOC_SOFT_LIMIT>0
- if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
- new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
- }
- if( new_size==pH->htsize ) return 0;
- #endif
- /* The inability to allocates space for a larger hash table is
- ** a performance hit but it is not a fatal error. So mark the
- ** allocation as a benign.
- */
- sqlite3BeginBenignMalloc();
- new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) );
- sqlite3EndBenignMalloc();
- if( new_ht==0 ) return 0;
- sqlite3_free(pH->ht);
- pH->ht = new_ht;
- pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht);
- memset(new_ht, 0, new_size*sizeof(struct _ht));
- for(elem=pH->first, pH->first=0; elem; elem = next_elem){
- unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
- next_elem = elem->next;
- insertElement(pH, &new_ht[h], elem);
- }
- return 1;
- }
- /* This function (for internal use only) locates an element in an
- ** hash table that matches the given key. The hash for this key has
- ** already been computed and is passed as the 4th parameter.
- */
- static HashElem *findElementGivenHash(
- const Hash *pH, /* The pH to be searched */
- const char *pKey, /* The key we are searching for */
- int nKey, /* Bytes in key (not counting zero terminator) */
- unsigned int h /* The hash for this key. */
- ){
- HashElem *elem; /* Used to loop thru the element list */
- int count; /* Number of elements left to test */
- if( pH->ht ){
- struct _ht *pEntry = &pH->ht[h];
- elem = pEntry->chain;
- count = pEntry->count;
- }else{
- elem = pH->first;
- count = pH->count;
- }
- while( count-- && ALWAYS(elem) ){
- if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){
- return elem;
- }
- elem = elem->next;
- }
- return 0;
- }
- /* Remove a single entry from the hash table given a pointer to that
- ** element and a hash on the element's key.
- */
- static void removeElementGivenHash(
- Hash *pH, /* The pH containing "elem" */
- HashElem* elem, /* The element to be removed from the pH */
- unsigned int h /* Hash value for the element */
- ){
- struct _ht *pEntry;
- if( elem->prev ){
- elem->prev->next = elem->next;
- }else{
- pH->first = elem->next;
- }
- if( elem->next ){
- elem->next->prev = elem->prev;
- }
- if( pH->ht ){
- pEntry = &pH->ht[h];
- if( pEntry->chain==elem ){
- pEntry->chain = elem->next;
- }
- pEntry->count--;
- assert( pEntry->count>=0 );
- }
- sqlite3_free( elem );
- pH->count--;
- if( pH->count<=0 ){
- assert( pH->first==0 );
- assert( pH->count==0 );
- sqlite3HashClear(pH);
- }
- }
- /* Attempt to locate an element of the hash table pH with a key
- ** that matches pKey,nKey. Return the data for this element if it is
- ** found, or NULL if there is no match.
- */
- SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
- HashElem *elem; /* The element that matches key */
- unsigned int h; /* A hash on key */
- assert( pH!=0 );
- assert( pKey!=0 );
- assert( nKey>=0 );
- if( pH->ht ){
- h = strHash(pKey, nKey) % pH->htsize;
- }else{
- h = 0;
- }
- elem = findElementGivenHash(pH, pKey, nKey, h);
- return elem ? elem->data : 0;
- }
- /* Insert an element into the hash table pH. The key is pKey,nKey
- ** and the data is "data".
- **
- ** If no element exists with a matching key, then a new
- ** element is created and NULL is returned.
- **
- ** If another element already exists with the same key, then the
- ** new data replaces the old data and the old data is returned.
- ** The key is not copied in this instance. If a malloc fails, then
- ** the new data is returned and the hash table is unchanged.
- **
- ** If the "data" parameter to this function is NULL, then the
- ** element corresponding to "key" is removed from the hash table.
- */
- SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
- unsigned int h; /* the hash of the key modulo hash table size */
- HashElem *elem; /* Used to loop thru the element list */
- HashElem *new_elem; /* New element added to the pH */
- assert( pH!=0 );
- assert( pKey!=0 );
- assert( nKey>=0 );
- if( pH->htsize ){
- h = strHash(pKey, nKey) % pH->htsize;
- }else{
- h = 0;
- }
- elem = findElementGivenHash(pH,pKey,nKey,h);
- if( elem ){
- void *old_data = elem->data;
- if( data==0 ){
- removeElementGivenHash(pH,elem,h);
- }else{
- elem->data = data;
- elem->pKey = pKey;
- assert(nKey==elem->nKey);
- }
- return old_data;
- }
- if( data==0 ) return 0;
- new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) );
- if( new_elem==0 ) return data;
- new_elem->pKey = pKey;
- new_elem->nKey = nKey;
- new_elem->data = data;
- pH->count++;
- if( pH->count>=10 && pH->count > 2*pH->htsize ){
- if( rehash(pH, pH->count*2) ){
- assert( pH->htsize>0 );
- h = strHash(pKey, nKey) % pH->htsize;
- }
- }
- if( pH->ht ){
- insertElement(pH, &pH->ht[h], new_elem);
- }else{
- insertElement(pH, 0, new_elem);
- }
- return 0;
- }
- /************** End of hash.c ************************************************/
- /************** Begin file opcodes.c *****************************************/
- /* Automatically generated. Do not edit */
- /* See the mkopcodec.awk script for details. */
- #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
- SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
- static const char *const azName[] = { "?",
- /* 1 */ "Goto",
- /* 2 */ "Gosub",
- /* 3 */ "Return",
- /* 4 */ "Yield",
- /* 5 */ "HaltIfNull",
- /* 6 */ "Halt",
- /* 7 */ "Integer",
- /* 8 */ "Int64",
- /* 9 */ "String",
- /* 10 */ "Null",
- /* 11 */ "Blob",
- /* 12 */ "Variable",
- /* 13 */ "Move",
- /* 14 */ "Copy",
- /* 15 */ "SCopy",
- /* 16 */ "ResultRow",
- /* 17 */ "CollSeq",
- /* 18 */ "Function",
- /* 19 */ "Not",
- /* 20 */ "AddImm",
- /* 21 */ "MustBeInt",
- /* 22 */ "RealAffinity",
- /* 23 */ "Permutation",
- /* 24 */ "Compare",
- /* 25 */ "Jump",
- /* 26 */ "Once",
- /* 27 */ "If",
- /* 28 */ "IfNot",
- /* 29 */ "Column",
- /* 30 */ "Affinity",
- /* 31 */ "MakeRecord",
- /* 32 */ "Count",
- /* 33 */ "Savepoint",
- /* 34 */ "AutoCommit",
- /* 35 */ "Transaction",
- /* 36 */ "ReadCookie",
- /* 37 */ "SetCookie",
- /* 38 */ "VerifyCookie",
- /* 39 */ "OpenRead",
- /* 40 */ "OpenWrite",
- /* 41 */ "OpenAutoindex",
- /* 42 */ "OpenEphemeral",
- /* 43 */ "SorterOpen",
- /* 44 */ "OpenPseudo",
- /* 45 */ "Close",
- /* 46 */ "SeekLt",
- /* 47 */ "SeekLe",
- /* 48 */ "SeekGe",
- /* 49 */ "SeekGt",
- /* 50 */ "Seek",
- /* 51 */ "NotFound",
- /* 52 */ "Found",
- /* 53 */ "IsUnique",
- /* 54 */ "NotExists",
- /* 55 */ "Sequence",
- /* 56 */ "NewRowid",
- /* 57 */ "Insert",
- /* 58 */ "InsertInt",
- /* 59 */ "Delete",
- /* 60 */ "ResetCount",
- /* 61 */ "SorterCompare",
- /* 62 */ "SorterData",
- /* 63 */ "RowKey",
- /* 64 */ "RowData",
- /* 65 */ "Rowid",
- /* 66 */ "NullRow",
- /* 67 */ "Last",
- /* 68 */ "Or",
- /* 69 */ "And",
- /* 70 */ "SorterSort",
- /* 71 */ "Sort",
- /* 72 */ "Rewind",
- /* 73 */ "IsNull",
- /* 74 */ "NotNull",
- /* 75 */ "Ne",
- /* 76 */ "Eq",
- /* 77 */ "Gt",
- /* 78 */ "Le",
- /* 79 */ "Lt",
- /* 80 */ "Ge",
- /* 81 */ "SorterNext",
- /* 82 */ "BitAnd",
- /* 83 */ "BitOr",
- /* 84 */ "ShiftLeft",
- /* 85 */ "ShiftRight",
- /* 86 */ "Add",
- /* 87 */ "Subtract",
- /* 88 */ "Multiply",
- /* 89 */ "Divide",
- /* 90 */ "Remainder",
- /* 91 */ "Concat",
- /* 92 */ "Prev",
- /* 93 */ "BitNot",
- /* 94 */ "String8",
- /* 95 */ "Next",
- /* 96 */ "SorterInsert",
- /* 97 */ "IdxInsert",
- /* 98 */ "IdxDelete",
- /* 99 */ "IdxRowid",
- /* 100 */ "IdxLT",
- /* 101 */ "IdxGE",
- /* 102 */ "Destroy",
- /* 103 */ "Clear",
- /* 104 */ "CreateIndex",
- /* 105 */ "CreateTable",
- /* 106 */ "ParseSchema",
- /* 107 */ "LoadAnalysis",
- /* 108 */ "DropTable",
- /* 109 */ "DropIndex",
- /* 110 */ "DropTrigger",
- /* 111 */ "IntegrityCk",
- /* 112 */ "RowSetAdd",
- /* 113 */ "RowSetRead",
- /* 114 */ "RowSetTest",
- /* 115 */ "Program",
- /* 116 */ "Param",
- /* 117 */ "FkCounter",
- /* 118 */ "FkIfZero",
- /* 119 */ "MemMax",
- /* 120 */ "IfPos",
- /* 121 */ "IfNeg",
- /* 122 */ "IfZero",
- /* 123 */ "AggStep",
- /* 124 */ "AggFinal",
- /* 125 */ "Checkpoint",
- /* 126 */ "JournalMode",
- /* 127 */ "Vacuum",
- /* 128 */ "IncrVacuum",
- /* 129 */ "Expire",
- /* 130 */ "Real",
- /* 131 */ "TableLock",
- /* 132 */ "VBegin",
- /* 133 */ "VCreate",
- /* 134 */ "VDestroy",
- /* 135 */ "VOpen",
- /* 136 */ "VFilter",
- /* 137 */ "VColumn",
- /* 138 */ "VNext",
- /* 139 */ "VRename",
- /* 140 */ "VUpdate",
- /* 141 */ "ToText",
- /* 142 */ "ToBlob",
- /* 143 */ "ToNumeric",
- /* 144 */ "ToInt",
- /* 145 */ "ToReal",
- /* 146 */ "Pagecount",
- /* 147 */ "MaxPgcnt",
- /* 148 */ "Trace",
- /* 149 */ "Noop",
- /* 150 */ "Explain",
- };
- return azName[i];
- }
- #endif
- /************** End of opcodes.c *********************************************/
- /************** Begin file os_os2.c ******************************************/
- /*
- ** 2006 Feb 14
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains code that is specific to OS/2.
- */
- #if SQLITE_OS_OS2
- /*
- ** A Note About Memory Allocation:
- **
- ** This driver uses malloc()/free() directly rather than going through
- ** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
- ** are designed for use on embedded systems where memory is scarce and
- ** malloc failures happen frequently. OS/2 does not typically run on
- ** embedded systems, and when it does the developers normally have bigger
- ** problems to worry about than running out of memory. So there is not
- ** a compelling need to use the wrappers.
- **
- ** But there is a good reason to not use the wrappers. If we use the
- ** wrappers then we will get simulated malloc() failures within this
- ** driver. And that causes all kinds of problems for our tests. We
- ** could enhance SQLite to deal with simulated malloc failures within
- ** the OS driver, but the code to deal with those failure would not
- ** be exercised on Linux (which does not need to malloc() in the driver)
- ** and so we would have difficulty writing coverage tests for that
- ** code. Better to leave the code out, we think.
- **
- ** The point of this discussion is as follows: When creating a new
- ** OS layer for an embedded system, if you use this file as an example,
- ** avoid the use of malloc()/free(). Those routines work ok on OS/2
- ** desktops but not so well in embedded systems.
- */
- /*
- ** Macros used to determine whether or not to use threads.
- */
- #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE
- # define SQLITE_OS2_THREADS 1
- #endif
- /*
- ** Include code that is common to all os_*.c files
- */
- /************** Include os_common.h in the middle of os_os2.c ****************/
- /************** Begin file os_common.h ***************************************/
- /*
- ** 2004 May 22
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains macros and a little bit of code that is common to
- ** all of the platform-specific files (os_*.c) and is #included into those
- ** files.
- **
- ** This file should be #included by the os_*.c files only. It is not a
- ** general purpose header file.
- */
- #ifndef _OS_COMMON_H_
- #define _OS_COMMON_H_
- /*
- ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
- ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
- ** switch. The following code should catch this problem at compile-time.
- */
- #ifdef MEMORY_DEBUG
- # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead."
- #endif
- #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
- # ifndef SQLITE_DEBUG_OS_TRACE
- # define SQLITE_DEBUG_OS_TRACE 0
- # endif
- int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
- # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
- #else
- # define OSTRACE(X)
- #endif
- /*
- ** Macros for performance tracing. Normally turned off. Only works
- ** on i486 hardware.
- */
- #ifdef SQLITE_PERFORMANCE_TRACE
- /*
- ** hwtime.h contains inline assembler code for implementing
- ** high-performance timing routines.
- */
- /************** Include hwtime.h in the middle of os_common.h ****************/
- /************** Begin file hwtime.h ******************************************/
- /*
- ** 2008 May 27
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains inline asm code for retrieving "high-performance"
- ** counters for x86 class CPUs.
- */
- #ifndef _HWTIME_H_
- #define _HWTIME_H_
- /*
- ** The following routine only works on pentium-class (or newer) processors.
- ** It uses the RDTSC opcode to read the cycle count value out of the
- ** processor and returns that value. This can be used for high-res
- ** profiling.
- */
- #if (defined(__GNUC__) || defined(_MSC_VER)) && \
- (defined(i386) || defined(__i386__) || defined(_M_IX86))
- #if defined(__GNUC__)
- __inline__ sqlite_uint64 sqlite3Hwtime(void){
- unsigned int lo, hi;
- __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
- return (sqlite_uint64)hi << 32 | lo;
- }
- #elif defined(_MSC_VER)
- __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
- __asm {
- rdtsc
- ret ; return value at EDX:EAX
- }
- }
- #endif
- #elif (defined(__GNUC__) && defined(__x86_64__))
- __inline__ sqlite_uint64 sqlite3Hwtime(void){
- unsigned long val;
- __asm__ __volatile__ ("rdtsc" : "=A" (val));
- return val;
- }
-
- #elif (defined(__GNUC__) && defined(__ppc__))
- __inline__ sqlite_uint64 sqlite3Hwtime(void){
- unsigned long long retval;
- unsigned long junk;
- __asm__ __volatile__ ("\n\
- 1: mftbu %1\n\
- mftb %L0\n\
- mftbu %0\n\
- cmpw %0,%1\n\
- bne 1b"
- : "=r" (retval), "=r" (junk));
- return retval;
- }
- #else
- #error Need implementation of sqlite3Hwtime() for your platform.
- /*
- ** To compile without implementing sqlite3Hwtime() for your platform,
- ** you can remove the above #error and use the following
- ** stub function. You will lose timing support for many
- ** of the debugging and testing utilities, but it should at
- ** least compile and run.
- */
- SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
- #endif
- #endif /* !defined(_HWTIME_H_) */
- /************** End of hwtime.h **********************************************/
- /************** Continuing where we left off in os_common.h ******************/
- static sqlite_uint64 g_start;
- static sqlite_uint64 g_elapsed;
- #define TIMER_START g_start=sqlite3Hwtime()
- #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start
- #define TIMER_ELAPSED g_elapsed
- #else
- #define TIMER_START
- #define TIMER_END
- #define TIMER_ELAPSED ((sqlite_uint64)0)
- #endif
- /*
- ** If we compile with the SQLITE_TEST macro set, then the following block
- ** of code will give us the ability to simulate a disk I/O error. This
- ** is used for testing the I/O recovery logic.
- */
- #ifdef SQLITE_TEST
- SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */
- SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */
- SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */
- SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */
- SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */
- SQLITE_API int sqlite3_diskfull_pending = 0;
- SQLITE_API int sqlite3_diskfull = 0;
- #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
- #define SimulateIOError(CODE) \
- if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
- || sqlite3_io_error_pending-- == 1 ) \
- { local_ioerr(); CODE; }
- static void local_ioerr(){
- IOTRACE(("IOERR\n"));
- sqlite3_io_error_hit++;
- if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
- }
- #define SimulateDiskfullError(CODE) \
- if( sqlite3_diskfull_pending ){ \
- if( sqlite3_diskfull_pending == 1 ){ \
- local_ioerr(); \
- sqlite3_diskfull = 1; \
- sqlite3_io_error_hit = 1; \
- CODE; \
- }else{ \
- sqlite3_diskfull_pending--; \
- } \
- }
- #else
- #define SimulateIOErrorBenign(X)
- #define SimulateIOError(A)
- #define SimulateDiskfullError(A)
- #endif
- /*
- ** When testing, keep a count of the number of open files.
- */
- #ifdef SQLITE_TEST
- SQLITE_API int sqlite3_open_file_count = 0;
- #define OpenCounter(X) sqlite3_open_file_count+=(X)
- #else
- #define OpenCounter(X)
- #endif
- #endif /* !defined(_OS_COMMON_H_) */
- /************** End of os_common.h *******************************************/
- /************** Continuing where we left off in os_os2.c *********************/
- /* Forward references */
- typedef struct os2File os2File; /* The file structure */
- typedef struct os2ShmNode os2ShmNode; /* A shared descritive memory node */
- typedef struct os2ShmLink os2ShmLink; /* A connection to shared-memory */
- /*
- ** The os2File structure is subclass of sqlite3_file specific for the OS/2
- ** protability layer.
- */
- struct os2File {
- const sqlite3_io_methods *pMethod; /* Always the first entry */
- HFILE h; /* Handle for accessing the file */
- int flags; /* Flags provided to os2Open() */
- int locktype; /* Type of lock currently held on this file */
- int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */
- char *zFullPathCp; /* Full path name of this file */
- os2ShmLink *pShmLink; /* Instance of shared memory on this file */
- };
- #define LOCK_TIMEOUT 10L /* the default locking timeout */
- /*
- ** Missing from some versions of the OS/2 toolkit -
- ** used to allocate from high memory if possible
- */
- #ifndef OBJ_ANY
- # define OBJ_ANY 0x00000400
- #endif
- /*****************************************************************************
- ** The next group of routines implement the I/O methods specified
- ** by the sqlite3_io_methods object.
- ******************************************************************************/
- /*
- ** Close a file.
- */
- static int os2Close( sqlite3_file *id ){
- APIRET rc;
- os2File *pFile = (os2File*)id;
- assert( id!=0 );
- OSTRACE(( "CLOSE %d (%s)\n", pFile->h, pFile->zFullPathCp ));
- rc = DosClose( pFile->h );
- if( pFile->flags & SQLITE_OPEN_DELETEONCLOSE )
- DosForceDelete( (PSZ)pFile->zFullPathCp );
- free( pFile->zFullPathCp );
- pFile->zFullPathCp = NULL;
- pFile->locktype = NO_LOCK;
- pFile->h = (HFILE)-1;
- pFile->flags = 0;
- OpenCounter( -1 );
- return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
- }
- /*
- ** Read data from a file into a buffer. Return SQLITE_OK if all
- ** bytes were read successfully and SQLITE_IOERR if anything goes
- ** wrong.
- */
- static int os2Read(
- sqlite3_file *id, /* File to read from */
- void *pBuf, /* Write content into this buffer */
- int amt, /* Number of bytes to read */
- sqlite3_int64 offset /* Begin reading at this offset */
- ){
- ULONG fileLocation = 0L;
- ULONG got;
- os2File *pFile = (os2File*)id;
- assert( id!=0 );
- SimulateIOError( return SQLITE_IOERR_READ );
- OSTRACE(( "READ %d lock=%d\n", pFile->h, pFile->locktype ));
- if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
- return SQLITE_IOERR;
- }
- if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
- return SQLITE_IOERR_READ;
- }
- if( got == (ULONG)amt )
- return SQLITE_OK;
- else {
- /* Unread portions of the input buffer must be zero-filled */
- memset(&((char*)pBuf)[got], 0, amt-got);
- return SQLITE_IOERR_SHORT_READ;
- }
- }
- /*
- ** Write data from a buffer into a file. Return SQLITE_OK on success
- ** or some other error code on failure.
- */
- static int os2Write(
- sqlite3_file *id, /* File to write into */
- const void *pBuf, /* The bytes to be written */
- int amt, /* Number of bytes to write */
- sqlite3_int64 offset /* Offset into the file to begin writing at */
- ){
- ULONG fileLocation = 0L;
- APIRET rc = NO_ERROR;
- ULONG wrote;
- os2File *pFile = (os2File*)id;
- assert( id!=0 );
- SimulateIOError( return SQLITE_IOERR_WRITE );
- SimulateDiskfullError( return SQLITE_FULL );
- OSTRACE(( "WRITE %d lock=%d\n", pFile->h, pFile->locktype ));
- if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
- return SQLITE_IOERR;
- }
- assert( amt>0 );
- while( amt > 0 &&
- ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&
- wrote > 0
- ){
- amt -= wrote;
- pBuf = &((char*)pBuf)[wrote];
- }
- return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLITE_FULL : SQLITE_OK;
- }
- /*
- ** Truncate an open file to a specified size
- */
- static int os2Truncate( sqlite3_file *id, i64 nByte ){
- APIRET rc;
- os2File *pFile = (os2File*)id;
- assert( id!=0 );
- OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
- SimulateIOError( return SQLITE_IOERR_TRUNCATE );
- /* If the user has configured a chunk-size for this file, truncate the
- ** file so that it consists of an integer number of chunks (i.e. the
- ** actual file size after the operation may be larger than the requested
- ** size).
- */
- if( pFile->szChunk ){
- nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
- }
-
- rc = DosSetFileSize( pFile->h, nByte );
- return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR_TRUNCATE;
- }
- #ifdef SQLITE_TEST
- /*
- ** Count the number of fullsyncs and normal syncs. This is used to test
- ** that syncs and fullsyncs are occuring at the right times.
- */
- SQLITE_API int sqlite3_sync_count = 0;
- SQLITE_API int sqlite3_fullsync_count = 0;
- #endif
- /*
- ** Make sure all writes to a particular file are committed to disk.
- */
- static int os2Sync( sqlite3_file *id, int flags ){
- os2File *pFile = (os2File*)id;
- OSTRACE(( "SYNC %d lock=%d\n", pFile->h, pFile->locktype ));
- #ifdef SQLITE_TEST
- if( flags & SQLITE_SYNC_FULL){
- sqlite3_fullsync_count++;
- }
- sqlite3_sync_count++;
- #endif
- /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
- ** no-op
- */
- #ifdef SQLITE_NO_SYNC
- UNUSED_PARAMETER(pFile);
- return SQLITE_OK;
- #else
- return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
- #endif
- }
- /*
- ** Determine the current size of a file in bytes
- */
- static int os2FileSize( sqlite3_file *id, sqlite3_int64 *pSize ){
- APIRET rc = NO_ERROR;
- FILESTATUS3 fsts3FileInfo;
- memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
- assert( id!=0 );
- SimulateIOError( return SQLITE_IOERR_FSTAT );
- rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
- if( rc == NO_ERROR ){
- *pSize = fsts3FileInfo.cbFile;
- return SQLITE_OK;
- }else{
- return SQLITE_IOERR_FSTAT;
- }
- }
- /*
- ** Acquire a reader lock.
- */
- static int getReadLock( os2File *pFile ){
- FILELOCK LockArea,
- UnlockArea;
- APIRET res;
- memset(&LockArea, 0, sizeof(LockArea));
- memset(&UnlockArea, 0, sizeof(UnlockArea));
- LockArea.lOffset = SHARED_FIRST;
- LockArea.lRange = SHARED_SIZE;
- UnlockArea.lOffset = 0L;
- UnlockArea.lRange = 0L;
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
- OSTRACE(( "GETREADLOCK %d res=%d\n", pFile->h, res ));
- return res;
- }
- /*
- ** Undo a readlock
- */
- static int unlockReadLock( os2File *id ){
- FILELOCK LockArea,
- UnlockArea;
- APIRET res;
- memset(&LockArea, 0, sizeof(LockArea));
- memset(&UnlockArea, 0, sizeof(UnlockArea));
- LockArea.lOffset = 0L;
- LockArea.lRange = 0L;
- UnlockArea.lOffset = SHARED_FIRST;
- UnlockArea.lRange = SHARED_SIZE;
- res = DosSetFileLocks( id->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
- OSTRACE(( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res ));
- return res;
- }
- /*
- ** Lock the file with the lock specified by parameter locktype - one
- ** of the following:
- **
- ** (1) SHARED_LOCK
- ** (2) RESERVED_LOCK
- ** (3) PENDING_LOCK
- ** (4) EXCLUSIVE_LOCK
- **
- ** Sometimes when requesting one lock state, additional lock states
- ** are inserted in between. The locking might fail on one of the later
- ** transitions leaving the lock state different from what it started but
- ** still short of its goal. The following chart shows the allowed
- ** transitions and the inserted intermediate states:
- **
- ** UNLOCKED -> SHARED
- ** SHARED -> RESERVED
- ** SHARED -> (PENDING) -> EXCLUSIVE
- ** RESERVED -> (PENDING) -> EXCLUSIVE
- ** PENDING -> EXCLUSIVE
- **
- ** This routine will only increase a lock. The os2Unlock() routine
- ** erases all locks at once and returns us immediately to locking level 0.
- ** It is not possible to lower the locking level one step at a time. You
- ** must go straight to locking level 0.
- */
- static int os2Lock( sqlite3_file *id, int locktype ){
- int rc = SQLITE_OK; /* Return code from subroutines */
- APIRET res = NO_ERROR; /* Result of an OS/2 lock call */
- int newLocktype; /* Set pFile->locktype to this value before exiting */
- int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
- FILELOCK LockArea,
- UnlockArea;
- os2File *pFile = (os2File*)id;
- memset(&LockArea, 0, sizeof(LockArea));
- memset(&UnlockArea, 0, sizeof(UnlockArea));
- assert( pFile!=0 );
- OSTRACE(( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype ));
- /* If there is already a lock of this type or more restrictive on the
- ** os2File, do nothing. Don't use the end_lock: exit path, as
- ** sqlite3_mutex_enter() hasn't been called yet.
- */
- if( pFile->locktype>=locktype ){
- OSTRACE(( "LOCK %d %d ok (already held)\n", pFile->h, locktype ));
- return SQLITE_OK;
- }
- /* Make sure the locking sequence is correct
- */
- assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
- assert( locktype!=PENDING_LOCK );
- assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
- /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
- ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
- ** the PENDING_LOCK byte is temporary.
- */
- newLocktype = pFile->locktype;
- if( pFile->locktype==NO_LOCK
- || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
- ){
- LockArea.lOffset = PENDING_BYTE;
- LockArea.lRange = 1L;
- UnlockArea.lOffset = 0L;
- UnlockArea.lRange = 0L;
- /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 100L, 0L );
- if( res == NO_ERROR ){
- gotPendingLock = 1;
- OSTRACE(( "LOCK %d pending lock boolean set. res=%d\n", pFile->h, res ));
- }
- }
- /* Acquire a shared lock
- */
- if( locktype==SHARED_LOCK && res == NO_ERROR ){
- assert( pFile->locktype==NO_LOCK );
- res = getReadLock(pFile);
- if( res == NO_ERROR ){
- newLocktype = SHARED_LOCK;
- }
- OSTRACE(( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res ));
- }
- /* Acquire a RESERVED lock
- */
- if( locktype==RESERVED_LOCK && res == NO_ERROR ){
- assert( pFile->locktype==SHARED_LOCK );
- LockArea.lOffset = RESERVED_BYTE;
- LockArea.lRange = 1L;
- UnlockArea.lOffset = 0L;
- UnlockArea.lRange = 0L;
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- if( res == NO_ERROR ){
- newLocktype = RESERVED_LOCK;
- }
- OSTRACE(( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res ));
- }
- /* Acquire a PENDING lock
- */
- if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
- newLocktype = PENDING_LOCK;
- gotPendingLock = 0;
- OSTRACE(( "LOCK %d acquire pending lock. pending lock boolean unset.\n",
- pFile->h ));
- }
- /* Acquire an EXCLUSIVE lock
- */
- if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
- assert( pFile->locktype>=SHARED_LOCK );
- res = unlockReadLock(pFile);
- OSTRACE(( "unreadlock = %d\n", res ));
- LockArea.lOffset = SHARED_FIRST;
- LockArea.lRange = SHARED_SIZE;
- UnlockArea.lOffset = 0L;
- UnlockArea.lRange = 0L;
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- if( res == NO_ERROR ){
- newLocktype = EXCLUSIVE_LOCK;
- }else{
- OSTRACE(( "OS/2 error-code = %d\n", res ));
- getReadLock(pFile);
- }
- OSTRACE(( "LOCK %d acquire exclusive lock. res=%d\n", pFile->h, res ));
- }
- /* If we are holding a PENDING lock that ought to be released, then
- ** release it now.
- */
- if( gotPendingLock && locktype==SHARED_LOCK ){
- int r;
- LockArea.lOffset = 0L;
- LockArea.lRange = 0L;
- UnlockArea.lOffset = PENDING_BYTE;
- UnlockArea.lRange = 1L;
- r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- OSTRACE(( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r ));
- }
- /* Update the state of the lock has held in the file descriptor then
- ** return the appropriate result code.
- */
- if( res == NO_ERROR ){
- rc = SQLITE_OK;
- }else{
- OSTRACE(( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
- locktype, newLocktype ));
- rc = SQLITE_BUSY;
- }
- pFile->locktype = newLocktype;
- OSTRACE(( "LOCK %d now %d\n", pFile->h, pFile->locktype ));
- return rc;
- }
- /*
- ** This routine checks if there is a RESERVED lock held on the specified
- ** file by this or any other process. If such a lock is held, return
- ** non-zero, otherwise zero.
- */
- static int os2CheckReservedLock( sqlite3_file *id, int *pOut ){
- int r = 0;
- os2File *pFile = (os2File*)id;
- assert( pFile!=0 );
- if( pFile->locktype>=RESERVED_LOCK ){
- r = 1;
- OSTRACE(( "TEST WR-LOCK %d %d (local)\n", pFile->h, r ));
- }else{
- FILELOCK LockArea,
- UnlockArea;
- APIRET rc = NO_ERROR;
- memset(&LockArea, 0, sizeof(LockArea));
- memset(&UnlockArea, 0, sizeof(UnlockArea));
- LockArea.lOffset = RESERVED_BYTE;
- LockArea.lRange = 1L;
- UnlockArea.lOffset = 0L;
- UnlockArea.lRange = 0L;
- rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- OSTRACE(( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc ));
- if( rc == NO_ERROR ){
- APIRET rcu = NO_ERROR; /* return code for unlocking */
- LockArea.lOffset = 0L;
- LockArea.lRange = 0L;
- UnlockArea.lOffset = RESERVED_BYTE;
- UnlockArea.lRange = 1L;
- rcu = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- OSTRACE(( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, rcu ));
- }
- r = !(rc == NO_ERROR);
- OSTRACE(( "TEST WR-LOCK %d %d (remote)\n", pFile->h, r ));
- }
- *pOut = r;
- return SQLITE_OK;
- }
- /*
- ** Lower the locking level on file descriptor id to locktype. locktype
- ** must be either NO_LOCK or SHARED_LOCK.
- **
- ** If the locking level of the file descriptor is already at or below
- ** the requested locking level, this routine is a no-op.
- **
- ** It is not possible for this routine to fail if the second argument
- ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
- ** might return SQLITE_IOERR;
- */
- static int os2Unlock( sqlite3_file *id, int locktype ){
- int type;
- os2File *pFile = (os2File*)id;
- APIRET rc = SQLITE_OK;
- APIRET res = NO_ERROR;
- FILELOCK LockArea,
- UnlockArea;
- memset(&LockArea, 0, sizeof(LockArea));
- memset(&UnlockArea, 0, sizeof(UnlockArea));
- assert( pFile!=0 );
- assert( locktype<=SHARED_LOCK );
- OSTRACE(( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype ));
- type = pFile->locktype;
- if( type>=EXCLUSIVE_LOCK ){
- LockArea.lOffset = 0L;
- LockArea.lRange = 0L;
- UnlockArea.lOffset = SHARED_FIRST;
- UnlockArea.lRange = SHARED_SIZE;
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- OSTRACE(( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res ));
- if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
- /* This should never happen. We should always be able to
- ** reacquire the read lock */
- OSTRACE(( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype ));
- rc = SQLITE_IOERR_UNLOCK;
- }
- }
- if( type>=RESERVED_LOCK ){
- LockArea.lOffset = 0L;
- LockArea.lRange = 0L;
- UnlockArea.lOffset = RESERVED_BYTE;
- UnlockArea.lRange = 1L;
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- OSTRACE(( "UNLOCK %d reserved res=%d\n", pFile->h, res ));
- }
- if( locktype==NO_LOCK && type>=SHARED_LOCK ){
- res = unlockReadLock(pFile);
- OSTRACE(( "UNLOCK %d is %d want %d res=%d\n",
- pFile->h, type, locktype, res ));
- }
- if( type>=PENDING_LOCK ){
- LockArea.lOffset = 0L;
- LockArea.lRange = 0L;
- UnlockArea.lOffset = PENDING_BYTE;
- UnlockArea.lRange = 1L;
- res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
- OSTRACE(( "UNLOCK %d pending res=%d\n", pFile->h, res ));
- }
- pFile->locktype = locktype;
- OSTRACE(( "UNLOCK %d now %d\n", pFile->h, pFile->locktype ));
- return rc;
- }
- /*
- ** Control and query of the open file handle.
- */
- static int os2FileControl(sqlite3_file *id, int op, void *pArg){
- switch( op ){
- case SQLITE_FCNTL_LOCKSTATE: {
- *(int*)pArg = ((os2File*)id)->locktype;
- OSTRACE(( "FCNTL_LOCKSTATE %d lock=%d\n",
- ((os2File*)id)->h, ((os2File*)id)->locktype ));
- return SQLITE_OK;
- }
- case SQLITE_FCNTL_CHUNK_SIZE: {
- ((os2File*)id)->szChunk = *(int*)pArg;
- return SQLITE_OK;
- }
- case SQLITE_FCNTL_SIZE_HINT: {
- sqlite3_int64 sz = *(sqlite3_int64*)pArg;
- SimulateIOErrorBenign(1);
- os2Truncate(id, sz);
- SimulateIOErrorBenign(0);
- return SQLITE_OK;
- }
- case SQLITE_FCNTL_SYNC_OMITTED: {
- return SQLITE_OK;
- }
- }
- return SQLITE_NOTFOUND;
- }
- /*
- ** Return the sector size in bytes of the underlying block device for
- ** the specified file. This is almost always 512 bytes, but may be
- ** larger for some devices.
- **
- ** SQLite code assumes this function cannot fail. It also assumes that
- ** if two files are created in the same file-system directory (i.e.
- ** a database and its journal file) that the sector size will be the
- ** same for both.
- */
- static int os2SectorSize(sqlite3_file *id){
- UNUSED_PARAMETER(id);
- return SQLITE_DEFAULT_SECTOR_SIZE;
- }
- /*
- ** Return a vector of device characteristics.
- */
- static int os2DeviceCharacteristics(sqlite3_file *id){
- UNUSED_PARAMETER(id);
- return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
- }
- /*
- ** Character set conversion objects used by conversion routines.
- */
- static UconvObject ucUtf8 = NULL; /* convert between UTF-8 and UCS-2 */
- static UconvObject uclCp = NULL; /* convert between local codepage and UCS-2 */
- /*
- ** Helper function to initialize the conversion objects from and to UTF-8.
- */
- static void initUconvObjects( void ){
- if( UniCreateUconvObject( UTF_8, &ucUtf8 ) != ULS_SUCCESS )
- ucUtf8 = NULL;
- if ( UniCreateUconvObject( (UniChar *)L"@path=yes", &uclCp ) != ULS_SUCCESS )
- uclCp = NULL;
- }
- /*
- ** Helper function to free the conversion objects from and to UTF-8.
- */
- static void freeUconvObjects( void ){
- if ( ucUtf8 )
- UniFreeUconvObject( ucUtf8 );
- if ( uclCp )
- UniFreeUconvObject( uclCp );
- ucUtf8 = NULL;
- uclCp = NULL;
- }
- /*
- ** Helper function to convert UTF-8 filenames to local OS/2 codepage.
- ** The two-step process: first convert the incoming UTF-8 string
- ** into UCS-2 and then from UCS-2 to the current codepage.
- ** The returned char pointer has to be freed.
- */
- static char *convertUtf8PathToCp( const char *in ){
- UniChar tempPath[CCHMAXPATH];
- char *out = (char *)calloc( CCHMAXPATH, 1 );
- if( !out )
- return NULL;
- if( !ucUtf8 || !uclCp )
- initUconvObjects();
- /* determine string for the conversion of UTF-8 which is CP1208 */
- if( UniStrToUcs( ucUtf8, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
- return out; /* if conversion fails, return the empty string */
- /* conversion for current codepage which can be used for paths */
- UniStrFromUcs( uclCp, out, tempPath, CCHMAXPATH );
- return out;
- }
- /*
- ** Helper function to convert filenames from local codepage to UTF-8.
- ** The two-step process: first convert the incoming codepage-specific
- ** string into UCS-2 and then from UCS-2 to the codepage of UTF-8.
- ** The returned char pointer has to be freed.
- **
- ** This function is non-static to be able to use this in shell.c and
- ** similar applications that take command line arguments.
- */
- char *convertCpPathToUtf8( const char *in ){
- UniChar tempPath[CCHMAXPATH];
- char *out = (char *)calloc( CCHMAXPATH, 1 );
- if( !out )
- return NULL;
- if( !ucUtf8 || !uclCp )
- initUconvObjects();
- /* conversion for current codepage which can be used for paths */
- if( UniStrToUcs( uclCp, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
- return out; /* if conversion fails, return the empty string */
- /* determine string for the conversion of UTF-8 which is CP1208 */
- UniStrFromUcs( ucUtf8, out, tempPath, CCHMAXPATH );
- return out;
- }
- #ifndef SQLITE_OMIT_WAL
- /*
- ** Use main database file for interprocess locking. If un-defined
- ** a separate file is created for this purpose. The file will be
- ** used only to set file locks. There will be no data written to it.
- */
- #define SQLITE_OS2_NO_WAL_LOCK_FILE
- #if 0
- static void _ERR_TRACE( const char *fmt, ... ) {
- va_list ap;
- va_start(ap, fmt);
- vfprintf(stderr, fmt, ap);
- fflush(stderr);
- }
- #define ERR_TRACE(rc, msg) \
- if( (rc) != SQLITE_OK ) _ERR_TRACE msg;
- #else
- #define ERR_TRACE(rc, msg)
- #endif
- /*
- ** Helper functions to obtain and relinquish the global mutex. The
- ** global mutex is used to protect os2ShmNodeList.
- **
- ** Function os2ShmMutexHeld() is used to assert() that the global mutex
- ** is held when required. This function is only used as part of assert()
- ** statements. e.g.
- **
- ** os2ShmEnterMutex()
- ** assert( os2ShmMutexHeld() );
- ** os2ShmLeaveMutex()
- */
- static void os2ShmEnterMutex(void){
- sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- }
- static void os2ShmLeaveMutex(void){
- sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- }
- #ifdef SQLITE_DEBUG
- static int os2ShmMutexHeld(void) {
- return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- }
- int GetCurrentProcessId(void) {
- PPIB pib;
- DosGetInfoBlocks(NULL, &pib);
- return (int)pib->pib_ulpid;
- }
- #endif
- /*
- ** Object used to represent a the shared memory area for a single log file.
- ** When multiple threads all reference the same log-summary, each thread has
- ** its own os2File object, but they all point to a single instance of this
- ** object. In other words, each log-summary is opened only once per process.
- **
- ** os2ShmMutexHeld() must be true when creating or destroying
- ** this object or while reading or writing the following fields:
- **
- ** nRef
- ** pNext
- **
- ** The following fields are read-only after the object is created:
- **
- ** szRegion
- ** hLockFile
- ** shmBaseName
- **
- ** Either os2ShmNode.mutex must be held or os2ShmNode.nRef==0 and
- ** os2ShmMutexHeld() is true when reading or writing any other field
- ** in this structure.
- **
- */
- struct os2ShmNode {
- sqlite3_mutex *mutex; /* Mutex to access this object */
- os2ShmNode *pNext; /* Next in list of all os2ShmNode objects */
- int szRegion; /* Size of shared-memory regions */
- int nRegion; /* Size of array apRegion */
- void **apRegion; /* Array of pointers to shared-memory regions */
- int nRef; /* Number of os2ShmLink objects pointing to this */
- os2ShmLink *pFirst; /* First os2ShmLink object pointing to this */
- HFILE hLockFile; /* File used for inter-process memory locking */
- char shmBaseName[1]; /* Name of the memory object !!! must last !!! */
- };
- /*
- ** Structure used internally by this VFS to record the state of an
- ** open shared memory connection.
- **
- ** The following fields are initialized when this object is created and
- ** are read-only thereafter:
- **
- ** os2Shm.pShmNode
- ** os2Shm.id
- **
- ** All other fields are read/write. The os2Shm.pShmNode->mutex must be held
- ** while accessing any read/write fields.
- */
- struct os2ShmLink {
- os2ShmNode *pShmNode; /* The underlying os2ShmNode object */
- os2ShmLink *pNext; /* Next os2Shm with the same os2ShmNode */
- u32 sharedMask; /* Mask of shared locks held */
- u32 exclMask; /* Mask of exclusive locks held */
- #ifdef SQLITE_DEBUG
- u8 id; /* Id of this connection with its os2ShmNode */
- #endif
- };
- /*
- ** A global list of all os2ShmNode objects.
- **
- ** The os2ShmMutexHeld() must be true while reading or writing this list.
- */
- static os2ShmNode *os2ShmNodeList = NULL;
- /*
- ** Constants used for locking
- */
- #ifdef SQLITE_OS2_NO_WAL_LOCK_FILE
- #define OS2_SHM_BASE (PENDING_BYTE + 0x10000) /* first lock byte */
- #else
- #define OS2_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
- #endif
- #define OS2_SHM_DMS (OS2_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
- /*
- ** Apply advisory locks for all n bytes beginning at ofst.
- */
- #define _SHM_UNLCK 1 /* no lock */
- #define _SHM_RDLCK 2 /* shared lock, no wait */
- #define _SHM_WRLCK 3 /* exlusive lock, no wait */
- #define _SHM_WRLCK_WAIT 4 /* exclusive lock, wait */
- static int os2ShmSystemLock(
- os2ShmNode *pNode, /* Apply locks to this open shared-memory segment */
- int lockType, /* _SHM_UNLCK, _SHM_RDLCK, _SHM_WRLCK or _SHM_WRLCK_WAIT */
- int ofst, /* Offset to first byte to be locked/unlocked */
- int nByte /* Number of bytes to lock or unlock */
- ){
- APIRET rc;
- FILELOCK area;
- ULONG mode, timeout;
- /* Access to the os2ShmNode object is serialized by the caller */
- assert( sqlite3_mutex_held(pNode->mutex) || pNode->nRef==0 );
- mode = 1; /* shared lock */
- timeout = 0; /* no wait */
- area.lOffset = ofst;
- area.lRange = nByte;
- switch( lockType ) {
- case _SHM_WRLCK_WAIT:
- timeout = (ULONG)-1; /* wait forever */
- case _SHM_WRLCK:
- mode = 0; /* exclusive lock */
- case _SHM_RDLCK:
- rc = DosSetFileLocks(pNode->hLockFile,
- NULL, &area, timeout, mode);
- break;
- /* case _SHM_UNLCK: */
- default:
- rc = DosSetFileLocks(pNode->hLockFile,
- &area, NULL, 0, 0);
- break;
- }
-
- OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
- pNode->hLockFile,
- rc==SQLITE_OK ? "ok" : "failed",
- lockType==_SHM_UNLCK ? "Unlock" : "Lock",
- rc));
- ERR_TRACE(rc, ("os2ShmSystemLock: %d %s\n", rc, pNode->shmBaseName))
- return ( rc == 0 ) ? SQLITE_OK : SQLITE_BUSY;
- }
- /*
- ** Find an os2ShmNode in global list or allocate a new one, if not found.
- **
- ** This is not a VFS shared-memory method; it is a utility function called
- ** by VFS shared-memory methods.
- */
- static int os2OpenSharedMemory( os2File *fd, int szRegion ) {
- os2ShmLink *pLink;
- os2ShmNode *pNode;
- int cbShmName, rc = SQLITE_OK;
- char shmName[CCHMAXPATH + 30];
- #ifndef SQLITE_OS2_NO_WAL_LOCK_FILE
- ULONG action;
- #endif
-
- /* We need some additional space at the end to append the region number */
- cbShmName = sprintf(shmName, "\\SHAREMEM\\%s", fd->zFullPathCp );
- if( cbShmName >= CCHMAXPATH-8 )
- return SQLITE_IOERR_SHMOPEN;
- /* Replace colon in file name to form a valid shared memory name */
- shmName[10+1] = '!';
- /* Allocate link object (we free it later in case of failure) */
- pLink = sqlite3_malloc( sizeof(*pLink) );
- if( !pLink )
- return SQLITE_NOMEM;
- /* Access node list */
- os2ShmEnterMutex();
- /* Find node by it's shared memory base name */
- for( pNode = os2ShmNodeList;
- pNode && stricmp(shmName, pNode->shmBaseName) != 0;
- pNode = pNode->pNext ) ;
- /* Not found: allocate a new node */
- if( !pNode ) {
- pNode = sqlite3_malloc( sizeof(*pNode) + cbShmName );
- if( pNode ) {
- memset(pNode, 0, sizeof(*pNode) );
- pNode->szRegion = szRegion;
- pNode->hLockFile = (HFILE)-1;
- strcpy(pNode->shmBaseName, shmName);
- #ifdef SQLITE_OS2_NO_WAL_LOCK_FILE
- if( DosDupHandle(fd->h, &pNode->hLockFile) != 0 ) {
- #else
- sprintf(shmName, "%s-lck", fd->zFullPathCp);
- if( DosOpen((PSZ)shmName, &pNode->hLockFile, &action, 0, FILE_NORMAL,
- OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
- OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE |
- OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR,
- NULL) != 0 ) {
- #endif
- sqlite3_free(pNode);
- rc = SQLITE_IOERR;
- } else {
- pNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
- if( !pNode->mutex ) {
- sqlite3_free(pNode);
- rc = SQLITE_NOMEM;
- }
- }
- } else {
- rc = SQLITE_NOMEM;
- }
-
- if( rc == SQLITE_OK ) {
- pNode->pNext = os2ShmNodeList;
- os2ShmNodeList = pNode;
- } else {
- pNode = NULL;
- }
- } else if( pNode->szRegion != szRegion ) {
- rc = SQLITE_IOERR_SHMSIZE;
- pNode = NULL;
- }
- if( pNode ) {
- sqlite3_mutex_enter(pNode->mutex);
- memset(pLink, 0, sizeof(*pLink));
- pLink->pShmNode = pNode;
- pLink->pNext = pNode->pFirst;
- pNode->pFirst = pLink;
- pNode->nRef++;
- fd->pShmLink = pLink;
- sqlite3_mutex_leave(pNode->mutex);
-
- } else {
- /* Error occured. Free our link object. */
- sqlite3_free(pLink);
- }
- os2ShmLeaveMutex();
- ERR_TRACE(rc, ("os2OpenSharedMemory: %d %s\n", rc, fd->zFullPathCp))
-
- return rc;
- }
- /*
- ** Purge the os2ShmNodeList list of all entries with nRef==0.
- **
- ** This is not a VFS shared-memory method; it is a utility function called
- ** by VFS shared-memory methods.
- */
- static void os2PurgeShmNodes( int deleteFlag ) {
- os2ShmNode *pNode;
- os2ShmNode **ppNode;
- os2ShmEnterMutex();
-
- ppNode = &os2ShmNodeList;
- while( *ppNode ) {
- pNode = *ppNode;
- if( pNode->nRef == 0 ) {
- *ppNode = pNode->pNext;
-
- if( pNode->apRegion ) {
- /* Prevent other processes from resizing the shared memory */
- os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
- while( pNode->nRegion-- ) {
- #ifdef SQLITE_DEBUG
- int rc =
- #endif
- DosFreeMem(pNode->apRegion[pNode->nRegion]);
- OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
- (int)GetCurrentProcessId(), pNode->nRegion,
- rc == 0 ? "ok" : "failed"));
- }
- /* Allow other processes to resize the shared memory */
- os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
- sqlite3_free(pNode->apRegion);
- }
- DosClose(pNode->hLockFile);
-
- #ifndef SQLITE_OS2_NO_WAL_LOCK_FILE
- if( deleteFlag ) {
- char fileName[CCHMAXPATH];
- /* Skip "\\SHAREMEM\\" */
- sprintf(fileName, "%s-lck", pNode->shmBaseName + 10);
- /* restore colon */
- fileName[1] = ':';
-
- DosForceDelete(fileName);
- }
- #endif
- sqlite3_mutex_free(pNode->mutex);
- sqlite3_free(pNode);
-
- } else {
- ppNode = &pNode->pNext;
- }
- }
- os2ShmLeaveMutex();
- }
- /*
- ** This function is called to obtain a pointer to region iRegion of the
- ** shared-memory associated with the database file id. Shared-memory regions
- ** are numbered starting from zero. Each shared-memory region is szRegion
- ** bytes in size.
- **
- ** If an error occurs, an error code is returned and *pp is set to NULL.
- **
- ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
- ** region has not been allocated (by any client, including one running in a
- ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
- ** bExtend is non-zero and the requested shared-memory region has not yet
- ** been allocated, it is allocated by this function.
- **
- ** If the shared-memory region has already been allocated or is allocated by
- ** this call as described above, then it is mapped into this processes
- ** address space (if it is not already), *pp is set to point to the mapped
- ** memory and SQLITE_OK returned.
- */
- static int os2ShmMap(
- sqlite3_file *id, /* Handle open on database file */
- int iRegion, /* Region to retrieve */
- int szRegion, /* Size of regions */
- int bExtend, /* True to extend block if necessary */
- void volatile **pp /* OUT: Mapped memory */
- ){
- PVOID pvTemp;
- void **apRegion;
- os2ShmNode *pNode;
- int n, rc = SQLITE_OK;
- char shmName[CCHMAXPATH];
- os2File *pFile = (os2File*)id;
-
- *pp = NULL;
- if( !pFile->pShmLink )
- rc = os2OpenSharedMemory( pFile, szRegion );
-
- if( rc == SQLITE_OK ) {
- pNode = pFile->pShmLink->pShmNode ;
-
- sqlite3_mutex_enter(pNode->mutex);
-
- assert( szRegion==pNode->szRegion );
- /* Unmapped region ? */
- if( iRegion >= pNode->nRegion ) {
- /* Prevent other processes from resizing the shared memory */
- os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
- apRegion = sqlite3_realloc(
- pNode->apRegion, (iRegion + 1) * sizeof(apRegion[0]));
- if( apRegion ) {
- pNode->apRegion = apRegion;
- while( pNode->nRegion <= iRegion ) {
- sprintf(shmName, "%s-%u",
- pNode->shmBaseName, pNode->nRegion);
- if( DosGetNamedSharedMem(&pvTemp, (PSZ)shmName,
- PAG_READ | PAG_WRITE) != NO_ERROR ) {
- if( !bExtend )
- break;
- if( DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
- PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_ANY) != NO_ERROR &&
- DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
- PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR ) {
- rc = SQLITE_NOMEM;
- break;
- }
- }
- apRegion[pNode->nRegion++] = pvTemp;
- }
- /* zero out remaining entries */
- for( n = pNode->nRegion; n <= iRegion; n++ )
- pNode->apRegion[n] = NULL;
- /* Return this region (maybe zero) */
- *pp = pNode->apRegion[iRegion];
- } else {
- rc = SQLITE_NOMEM;
- }
- /* Allow other processes to resize the shared memory */
- os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
-
- } else {
- /* Region has been mapped previously */
- *pp = pNode->apRegion[iRegion];
- }
- sqlite3_mutex_leave(pNode->mutex);
- }
- ERR_TRACE(rc, ("os2ShmMap: %s iRgn = %d, szRgn = %d, bExt = %d : %d\n",
- pFile->zFullPathCp, iRegion, szRegion, bExtend, rc))
-
- return rc;
- }
- /*
- ** Close a connection to shared-memory. Delete the underlying
- ** storage if deleteFlag is true.
- **
- ** If there is no shared memory associated with the connection then this
- ** routine is a harmless no-op.
- */
- static int os2ShmUnmap(
- sqlite3_file *id, /* The underlying database file */
- int deleteFlag /* Delete shared-memory if true */
- ){
- os2File *pFile = (os2File*)id;
- os2ShmLink *pLink = pFile->pShmLink;
-
- if( pLink ) {
- int nRef = -1;
- os2ShmLink **ppLink;
- os2ShmNode *pNode = pLink->pShmNode;
- sqlite3_mutex_enter(pNode->mutex);
-
- for( ppLink = &pNode->pFirst;
- *ppLink && *ppLink != pLink;
- ppLink = &(*ppLink)->pNext ) ;
-
- assert(*ppLink);
- if( *ppLink ) {
- *ppLink = pLink->pNext;
- nRef = --pNode->nRef;
- } else {
- ERR_TRACE(1, ("os2ShmUnmap: link not found ! %s\n",
- pNode->shmBaseName))
- }
-
- pFile->pShmLink = NULL;
- sqlite3_free(pLink);
- sqlite3_mutex_leave(pNode->mutex);
-
- if( nRef == 0 )
- os2PurgeShmNodes( deleteFlag );
- }
- return SQLITE_OK;
- }
- /*
- ** Change the lock state for a shared-memory segment.
- **
- ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
- ** different here than in posix. In xShmLock(), one can go from unlocked
- ** to shared and back or from unlocked to exclusive and back. But one may
- ** not go from shared to exclusive or from exclusive to shared.
- */
- static int os2ShmLock(
- sqlite3_file *id, /* Database file holding the shared memory */
- int ofst, /* First lock to acquire or release */
- int n, /* Number of locks to acquire or release */
- int flags /* What to do with the lock */
- ){
- u32 mask; /* Mask of locks to take or release */
- int rc = SQLITE_OK; /* Result code */
- os2File *pFile = (os2File*)id;
- os2ShmLink *p = pFile->pShmLink; /* The shared memory being locked */
- os2ShmLink *pX; /* For looping over all siblings */
- os2ShmNode *pShmNode = p->pShmNode; /* Our node */
-
- assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
- assert( n>=1 );
- assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
- || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
- || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
- || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
- assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
- mask = (u32)((1U<<(ofst+n)) - (1U<<ofst));
- assert( n>1 || mask==(1<<ofst) );
- sqlite3_mutex_enter(pShmNode->mutex);
- if( flags & SQLITE_SHM_UNLOCK ){
- u32 allMask = 0; /* Mask of locks held by siblings */
- /* See if any siblings hold this same lock */
- for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
- if( pX==p ) continue;
- assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
- allMask |= pX->sharedMask;
- }
- /* Unlock the system-level locks */
- if( (mask & allMask)==0 ){
- rc = os2ShmSystemLock(pShmNode, _SHM_UNLCK, ofst+OS2_SHM_BASE, n);
- }else{
- rc = SQLITE_OK;
- }
- /* Undo the local locks */
- if( rc==SQLITE_OK ){
- p->exclMask &= ~mask;
- p->sharedMask &= ~mask;
- }
- }else if( flags & SQLITE_SHM_SHARED ){
- u32 allShared = 0; /* Union of locks held by connections other than "p" */
- /* Find out which shared locks are already held by sibling connections.
- ** If any sibling already holds an exclusive lock, go ahead and return
- ** SQLITE_BUSY.
- */
- for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
- if( (pX->exclMask & mask)!=0 ){
- rc = SQLITE_BUSY;
- break;
- }
- allShared |= pX->sharedMask;
- }
- /* Get shared locks at the system level, if necessary */
- if( rc==SQLITE_OK ){
- if( (allShared & mask)==0 ){
- rc = os2ShmSystemLock(pShmNode, _SHM_RDLCK, ofst+OS2_SHM_BASE, n);
- }else{
- rc = SQLITE_OK;
- }
- }
- /* Get the local shared locks */
- if( rc==SQLITE_OK ){
- p->sharedMask |= mask;
- }
- }else{
- /* Make sure no sibling connections hold locks that will block this
- ** lock. If any do, return SQLITE_BUSY right away.
- */
- for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
- if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
- rc = SQLITE_BUSY;
- break;
- }
- }
-
- /* Get the exclusive locks at the system level. Then if successful
- ** also mark the local connection as being locked.
- */
- if( rc==SQLITE_OK ){
- rc = os2ShmSystemLock(pShmNode, _SHM_WRLCK, ofst+OS2_SHM_BASE, n);
- if( rc==SQLITE_OK ){
- assert( (p->sharedMask & mask)==0 );
- p->exclMask |= mask;
- }
- }
- }
- sqlite3_mutex_leave(pShmNode->mutex);
-
- OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
- p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
- rc ? "failed" : "ok"));
- ERR_TRACE(rc, ("os2ShmLock: ofst = %d, n = %d, flags = 0x%x -> %d \n",
- ofst, n, flags, rc))
-
- return rc;
- }
- /*
- ** Implement a memory barrier or memory fence on shared memory.
- **
- ** All loads and stores begun before the barrier must complete before
- ** any load or store begun after the barrier.
- */
- static void os2ShmBarrier(
- sqlite3_file *id /* Database file holding the shared memory */
- ){
- UNUSED_PARAMETER(id);
- os2ShmEnterMutex();
- os2ShmLeaveMutex();
- }
- #else
- # define os2ShmMap 0
- # define os2ShmLock 0
- # define os2ShmBarrier 0
- # define os2ShmUnmap 0
- #endif /* #ifndef SQLITE_OMIT_WAL */
- /*
- ** This vector defines all the methods that can operate on an
- ** sqlite3_file for os2.
- */
- static const sqlite3_io_methods os2IoMethod = {
- 2, /* iVersion */
- os2Close, /* xClose */
- os2Read, /* xRead */
- os2Write, /* xWrite */
- os2Truncate, /* xTruncate */
- os2Sync, /* xSync */
- os2FileSize, /* xFileSize */
- os2Lock, /* xLock */
- os2Unlock, /* xUnlock */
- os2CheckReservedLock, /* xCheckReservedLock */
- os2FileControl, /* xFileControl */
- os2SectorSize, /* xSectorSize */
- os2DeviceCharacteristics, /* xDeviceCharacteristics */
- os2ShmMap, /* xShmMap */
- os2ShmLock, /* xShmLock */
- os2ShmBarrier, /* xShmBarrier */
- os2ShmUnmap /* xShmUnmap */
- };
- /***************************************************************************
- ** Here ends the I/O methods that form the sqlite3_io_methods object.
- **
- ** The next block of code implements the VFS methods.
- ****************************************************************************/
- /*
- ** Create a temporary file name in zBuf. zBuf must be big enough to
- ** hold at pVfs->mxPathname characters.
- */
- static int getTempname(int nBuf, char *zBuf ){
- static const char zChars[] =
- "abcdefghijklmnopqrstuvwxyz"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "0123456789";
- int i, j;
- PSZ zTempPathCp;
- char zTempPath[CCHMAXPATH];
- ULONG ulDriveNum, ulDriveMap;
-
- /* It's odd to simulate an io-error here, but really this is just
- ** using the io-error infrastructure to test that SQLite handles this
- ** function failing.
- */
- SimulateIOError( return SQLITE_IOERR );
- if( sqlite3_temp_directory ) {
- sqlite3_snprintf(CCHMAXPATH-30, zTempPath, "%s", sqlite3_temp_directory);
- } else if( DosScanEnv( (PSZ)"TEMP", &zTempPathCp ) == NO_ERROR ||
- DosScanEnv( (PSZ)"TMP", &zTempPathCp ) == NO_ERROR ||
- DosScanEnv( (PSZ)"TMPDIR", &zTempPathCp ) == NO_ERROR ) {
- char *zTempPathUTF = convertCpPathToUtf8( (char *)zTempPathCp );
- sqlite3_snprintf(CCHMAXPATH-30, zTempPath, "%s", zTempPathUTF);
- free( zTempPathUTF );
- } else if( DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ) == NO_ERROR ) {
- zTempPath[0] = (char)('A' + ulDriveNum - 1);
- zTempPath[1] = ':';
- zTempPath[2] = '\0';
- } else {
- zTempPath[0] = '\0';
- }
-
- /* Strip off a trailing slashes or backslashes, otherwise we would get *
- * multiple (back)slashes which causes DosOpen() to fail. *
- * Trailing spaces are not allowed, either. */
- j = sqlite3Strlen30(zTempPath);
- while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' ||
- zTempPath[j-1] == ' ' ) ){
- j--;
- }
- zTempPath[j] = '\0';
-
- /* We use 20 bytes to randomize the name */
- sqlite3_snprintf(nBuf-22, zBuf,
- "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
- j = sqlite3Strlen30(zBuf);
- sqlite3_randomness( 20, &zBuf[j] );
- for( i = 0; i < 20; i++, j++ ){
- zBuf[j] = zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
- }
- zBuf[j] = 0;
- OSTRACE(( "TEMP FILENAME: %s\n", zBuf ));
- return SQLITE_OK;
- }
- /*
- ** Turn a relative pathname into a full pathname. Write the full
- ** pathname into zFull[]. zFull[] will be at least pVfs->mxPathname
- ** bytes in size.
- */
- static int os2FullPathname(
- sqlite3_vfs *pVfs, /* Pointer to vfs object */
- const char *zRelative, /* Possibly relative input path */
- int nFull, /* Size of output buffer in bytes */
- char *zFull /* Output buffer */
- ){
- char *zRelativeCp = convertUtf8PathToCp( zRelative );
- char zFullCp[CCHMAXPATH] = "\0";
- char *zFullUTF;
- APIRET rc = DosQueryPathInfo( (PSZ)zRelativeCp, FIL_QUERYFULLNAME,
- zFullCp, CCHMAXPATH );
- free( zRelativeCp );
- zFullUTF = convertCpPathToUtf8( zFullCp );
- sqlite3_snprintf( nFull, zFull, zFullUTF );
- free( zFullUTF );
- return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
- }
- /*
- ** Open a file.
- */
- static int os2Open(
- sqlite3_vfs *pVfs, /* Not used */
- const char *zName, /* Name of the file (UTF-8) */
- sqlite3_file *id, /* Write the SQLite file handle here */
- int flags, /* Open mode flags */
- int *pOutFlags /* Status return flags */
- ){
- HFILE h;
- ULONG ulOpenFlags = 0;
- ULONG ulOpenMode = 0;
- ULONG ulAction = 0;
- ULONG rc;
- os2File *pFile = (os2File*)id;
- const char *zUtf8Name = zName;
- char *zNameCp;
- char zTmpname[CCHMAXPATH];
- int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
- int isCreate = (flags & SQLITE_OPEN_CREATE);
- int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
- #ifndef NDEBUG
- int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
- int isReadonly = (flags & SQLITE_OPEN_READONLY);
- int eType = (flags & 0xFFFFFF00);
- int isOpenJournal = (isCreate && (
- eType==SQLITE_OPEN_MASTER_JOURNAL
- || eType==SQLITE_OPEN_MAIN_JOURNAL
- || eType==SQLITE_OPEN_WAL
- ));
- #endif
- UNUSED_PARAMETER(pVfs);
- assert( id!=0 );
- /* Check the following statements are true:
- **
- ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
- ** (b) if CREATE is set, then READWRITE must also be set, and
- ** (c) if EXCLUSIVE is set, then CREATE must also be set.
- ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
- */
- assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
- assert(isCreate==0 || isReadWrite);
- assert(isExclusive==0 || isCreate);
- assert(isDelete==0 || isCreate);
- /* The main DB, main journal, WAL file and master journal are never
- ** automatically deleted. Nor are they ever temporary files. */
- assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
- assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
- assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
- assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
- /* Assert that the upper layer has set one of the "file-type" flags. */
- assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
- || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
- || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
- || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
- );
- memset( pFile, 0, sizeof(*pFile) );
- pFile->h = (HFILE)-1;
- /* If the second argument to this function is NULL, generate a
- ** temporary file name to use
- */
- if( !zUtf8Name ){
- assert(isDelete && !isOpenJournal);
- rc = getTempname(CCHMAXPATH, zTmpname);
- if( rc!=SQLITE_OK ){
- return rc;
- }
- zUtf8Name = zTmpname;
- }
- if( isReadWrite ){
- ulOpenMode |= OPEN_ACCESS_READWRITE;
- }else{
- ulOpenMode |= OPEN_ACCESS_READONLY;
- }
- /* Open in random access mode for possibly better speed. Allow full
- ** sharing because file locks will provide exclusive access when needed.
- ** The handle should not be inherited by child processes and we don't
- ** want popups from the critical error handler.
- */
- ulOpenMode |= OPEN_FLAGS_RANDOM | OPEN_SHARE_DENYNONE |
- OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR;
- /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
- ** created. SQLite doesn't use it to indicate "exclusive access"
- ** as it is usually understood.
- */
- if( isExclusive ){
- /* Creates a new file, only if it does not already exist. */
- /* If the file exists, it fails. */
- ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
- }else if( isCreate ){
- /* Open existing file, or create if it doesn't exist */
- ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
- }else{
- /* Opens a file, only if it exists. */
- ulOpenFlags |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
- }
- zNameCp = convertUtf8PathToCp( zUtf8Name );
- rc = DosOpen( (PSZ)zNameCp,
- &h,
- &ulAction,
- 0L,
- FILE_NORMAL,
- ulOpenFlags,
- ulOpenMode,
- (PEAOP2)NULL );
- free( zNameCp );
- if( rc != NO_ERROR ){
- OSTRACE(( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
- rc, zUtf8Name, ulAction, ulOpenFlags, ulOpenMode ));
- if( isReadWrite ){
- return os2Open( pVfs, zName, id,
- ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)),
- pOutFlags );
- }else{
- return SQLITE_CANTOPEN;
- }
- }
- if( pOutFlags ){
- *pOutFlags = isReadWrite ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
- }
- os2FullPathname( pVfs, zUtf8Name, sizeof( zTmpname ), zTmpname );
- pFile->zFullPathCp = convertUtf8PathToCp( zTmpname );
- pFile->pMethod = &os2IoMethod;
- pFile->flags = flags;
- pFile->h = h;
- OpenCounter(+1);
- OSTRACE(( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags ));
- return SQLITE_OK;
- }
- /*
- ** Delete the named file.
- */
- static int os2Delete(
- sqlite3_vfs *pVfs, /* Not used on os2 */
- const char *zFilename, /* Name of file to delete */
- int syncDir /* Not used on os2 */
- ){
- APIRET rc;
- char *zFilenameCp;
- SimulateIOError( return SQLITE_IOERR_DELETE );
- zFilenameCp = convertUtf8PathToCp( zFilename );
- rc = DosDelete( (PSZ)zFilenameCp );
- free( zFilenameCp );
- OSTRACE(( "DELETE \"%s\"\n", zFilename ));
- return (rc == NO_ERROR ||
- rc == ERROR_FILE_NOT_FOUND ||
- rc == ERROR_PATH_NOT_FOUND ) ? SQLITE_OK : SQLITE_IOERR_DELETE;
- }
- /*
- ** Check the existance and status of a file.
- */
- static int os2Access(
- sqlite3_vfs *pVfs, /* Not used on os2 */
- const char *zFilename, /* Name of file to check */
- int flags, /* Type of test to make on this file */
- int *pOut /* Write results here */
- ){
- APIRET rc;
- FILESTATUS3 fsts3ConfigInfo;
- char *zFilenameCp;
- UNUSED_PARAMETER(pVfs);
- SimulateIOError( return SQLITE_IOERR_ACCESS; );
-
- zFilenameCp = convertUtf8PathToCp( zFilename );
- rc = DosQueryPathInfo( (PSZ)zFilenameCp, FIL_STANDARD,
- &fsts3ConfigInfo, sizeof(FILESTATUS3) );
- free( zFilenameCp );
- OSTRACE(( "ACCESS fsts3ConfigInfo.attrFile=%d flags=%d rc=%d\n",
- fsts3ConfigInfo.attrFile, flags, rc ));
- switch( flags ){
- case SQLITE_ACCESS_EXISTS:
- /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
- ** as if it does not exist.
- */
- if( fsts3ConfigInfo.cbFile == 0 )
- rc = ERROR_FILE_NOT_FOUND;
- break;
- case SQLITE_ACCESS_READ:
- break;
- case SQLITE_ACCESS_READWRITE:
- if( fsts3ConfigInfo.attrFile & FILE_READONLY )
- rc = ERROR_ACCESS_DENIED;
- break;
- default:
- rc = ERROR_FILE_NOT_FOUND;
- assert( !"Invalid flags argument" );
- }
- *pOut = (rc == NO_ERROR);
- OSTRACE(( "ACCESS %s flags %d: rc=%d\n", zFilename, flags, *pOut ));
- return SQLITE_OK;
- }
- #ifndef SQLITE_OMIT_LOAD_EXTENSION
- /*
- ** Interfaces for opening a shared library, finding entry points
- ** within the shared library, and closing the shared library.
- */
- /*
- ** Interfaces for opening a shared library, finding entry points
- ** within the shared library, and closing the shared library.
- */
- static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
- HMODULE hmod;
- APIRET rc;
- char *zFilenameCp = convertUtf8PathToCp(zFilename);
- rc = DosLoadModule(NULL, 0, (PSZ)zFilenameCp, &hmod);
- free(zFilenameCp);
- return rc != NO_ERROR ? 0 : (void*)hmod;
- }
- /*
- ** A no-op since the error code is returned on the DosLoadModule call.
- ** os2Dlopen returns zero if DosLoadModule is not successful.
- */
- static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
- /* no-op */
- }
- static void (*os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
- PFN pfn;
- APIRET rc;
- rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)zSymbol, &pfn);
- if( rc != NO_ERROR ){
- /* if the symbol itself was not found, search again for the same
- * symbol with an extra underscore, that might be needed depending
- * on the calling convention */
- char _zSymbol[256] = "_";
- strncat(_zSymbol, zSymbol, 254);
- rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)_zSymbol, &pfn);
- }
- return rc != NO_ERROR ? 0 : (void(*)(void))pfn;
- }
- static void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
- DosFreeModule((HMODULE)pHandle);
- }
- #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
- #define os2DlOpen 0
- #define os2DlError 0
- #define os2DlSym 0
- #define os2DlClose 0
- #endif
- /*
- ** Write up to nBuf bytes of randomness into zBuf.
- */
- static int os2Randomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf ){
- int n = 0;
- #if defined(SQLITE_TEST)
- n = nBuf;
- memset(zBuf, 0, nBuf);
- #else
- int i;
- PPIB ppib;
- PTIB ptib;
- DATETIME dt;
- static unsigned c = 0;
- /* Ordered by variation probability */
- static ULONG svIdx[6] = { QSV_MS_COUNT, QSV_TIME_LOW,
- QSV_MAXPRMEM, QSV_MAXSHMEM,
- QSV_TOTAVAILMEM, QSV_TOTRESMEM };
- /* 8 bytes; timezone and weekday don't increase the randomness much */
- if( (int)sizeof(dt)-3 <= nBuf - n ){
- c += 0x0100;
- DosGetDateTime(&dt);
- dt.year = (USHORT)((dt.year - 1900) | c);
- memcpy(&zBuf[n], &dt, sizeof(dt)-3);
- n += sizeof(dt)-3;
- }
- /* 4 bytes; PIDs and TIDs are 16 bit internally, so combine them */
- if( (int)sizeof(ULONG) <= nBuf - n ){
- DosGetInfoBlocks(&ptib, &ppib);
- *(PULONG)&zBuf[n] = MAKELONG(ppib->pib_ulpid,
- ptib->tib_ptib2->tib2_ultid);
- n += sizeof(ULONG);
- }
- /* Up to 6 * 4 bytes; variables depend on the system state */
- for( i = 0; i < 6 && (int)sizeof(ULONG) <= nBuf - n; i++ ){
- DosQuerySysInfo(svIdx[i], svIdx[i],
- (PULONG)&zBuf[n], sizeof(ULONG));
- n += sizeof(ULONG);
- }
- #endif
- return n;
- }
- /*
- ** Sleep for a little while. Return the amount of time slept.
- ** The argument is the number of microseconds we want to sleep.
- ** The return value is the number of microseconds of sleep actually
- ** requested from the underlying operating system, a number which
- ** might be greater than or equal to the argument, but not less
- ** than the argument.
- */
- static int os2Sleep( sqlite3_vfs *pVfs, int microsec ){
- DosSleep( (microsec/1000) );
- return microsec;
- }
- /*
- ** The following variable, if set to a non-zero value, becomes the result
- ** returned from sqlite3OsCurrentTime(). This is used for testing.
- */
- #ifdef SQLITE_TEST
- SQLITE_API int sqlite3_current_time = 0;
- #endif
- /*
- ** Find the current time (in Universal Coordinated Time). Write into *piNow
- ** the current time and date as a Julian Day number times 86_400_000. In
- ** other words, write into *piNow the number of milliseconds since the Julian
- ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
- ** proleptic Gregorian calendar.
- **
- ** On success, return 0. Return 1 if the time and date cannot be found.
- */
- static int os2CurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
- #ifdef SQLITE_TEST
- static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
- #endif
- int year, month, datepart, timepart;
-
- DATETIME dt;
- DosGetDateTime( &dt );
- year = dt.year;
- month = dt.month;
- /* Calculations from http://www.astro.keele.ac.uk/~rno/Astronomy/hjd.html
- ** http://www.astro.keele.ac.uk/~rno/Astronomy/hjd-0.1.c
- ** Calculate the Julian days
- */
- datepart = (int)dt.day - 32076 +
- 1461*(year + 4800 + (month - 14)/12)/4 +
- 367*(month - 2 - (month - 14)/12*12)/12 -
- 3*((year + 4900 + (month - 14)/12)/100)/4;
- /* Time in milliseconds, hours to noon added */
- timepart = 12*3600*1000 + dt.hundredths*10 + dt.seconds*1000 +
- ((int)dt.minutes + dt.timezone)*60*1000 + dt.hours*3600*1000;
- *piNow = (sqlite3_int64)datepart*86400*1000 + timepart;
-
- #ifdef SQLITE_TEST
- if( sqlite3_current_time ){
- *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
- }
- #endif
- UNUSED_PARAMETER(pVfs);
- return 0;
- }
- /*
- ** Find the current time (in Universal Coordinated Time). Write the
- ** current time and date as a Julian Day number into *prNow and
- ** return 0. Return 1 if the time and date cannot be found.
- */
- static int os2CurrentTime( sqlite3_vfs *pVfs, double *prNow ){
- int rc;
- sqlite3_int64 i;
- rc = os2CurrentTimeInt64(pVfs, &i);
- if( !rc ){
- *prNow = i/86400000.0;
- }
- return rc;
- }
- /*
- ** The idea is that this function works like a combination of
- ** GetLastError() and FormatMessage() on windows (or errno and
- ** strerror_r() on unix). After an error is returned by an OS
- ** function, SQLite calls this function with zBuf pointing to
- ** a buffer of nBuf bytes. The OS layer should populate the
- ** buffer with a nul-terminated UTF-8 encoded error message
- ** describing the last IO error to have occurred within the calling
- ** thread.
- **
- ** If the error message is too large for the supplied buffer,
- ** it should be truncated. The return value of xGetLastError
- ** is zero if the error message fits in the buffer, or non-zero
- ** otherwise (if the message was truncated). If non-zero is returned,
- ** then it is not necessary to include the nul-terminator character
- ** in the output buffer.
- **
- ** Not supplying an error message will have no adverse effect
- ** on SQLite. It is fine to have an implementation that never
- ** returns an error message:
- **
- ** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
- ** assert(zBuf[0]=='\0');
- ** return 0;
- ** }
- **
- ** However if an error message is supplied, it will be incorporated
- ** by sqlite into the error message available to the user using
- ** sqlite3_errmsg(), possibly making IO errors easier to debug.
- */
- static int os2GetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
- assert(zBuf[0]=='\0');
- return 0;
- }
- /*
- ** Initialize and deinitialize the operating system interface.
- */
- SQLITE_API int sqlite3_os_init(void){
- static sqlite3_vfs os2Vfs = {
- 3, /* iVersion */
- sizeof(os2File), /* szOsFile */
- CCHMAXPATH, /* mxPathname */
- 0, /* pNext */
- "os2", /* zName */
- 0, /* pAppData */
- os2Open, /* xOpen */
- os2Delete, /* xDelete */
- os2Access, /* xAccess */
- os2FullPathname, /* xFullPathname */
- os2DlOpen, /* xDlOpen */
- os2DlError, /* xDlError */
- os2DlSym, /* xDlSym */
- os2DlClose, /* xDlClose */
- os2Randomness, /* xRandomness */
- os2Sleep, /* xSleep */
- os2CurrentTime, /* xCurrentTime */
- os2GetLastError, /* xGetLastError */
- os2CurrentTimeInt64, /* xCurrentTimeInt64 */
- 0, /* xSetSystemCall */
- 0, /* xGetSystemCall */
- 0 /* xNextSystemCall */
- };
- sqlite3_vfs_register(&os2Vfs, 1);
- initUconvObjects();
- /* sqlite3OSTrace = 1; */
- return SQLITE_OK;
- }
- SQLITE_API int sqlite3_os_end(void){
- freeUconvObjects();
- return SQLITE_OK;
- }
- #endif /* SQLITE_OS_OS2 */
- /************** End of os_os2.c **********************************************/
- /************** Begin file os_unix.c *****************************************/
- /*
- ** 2004 May 22
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains the VFS implementation for unix-like operating systems
- ** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.
- **
- ** There are actually several different VFS implementations in this file.
- ** The differences are in the way that file locking is done. The default
- ** implementation uses Posix Advisory Locks. Alternative implementations
- ** use flock(), dot-files, various proprietary locking schemas, or simply
- ** skip locking all together.
- **
- ** This source file is organized into divisions where the logic for various
- ** subfunctions is contained within the appropriate division. PLEASE
- ** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
- ** in the correct division and should be clearly labeled.
- **
- ** The layout of divisions is as follows:
- **
- ** * General-purpose declarations and utility functions.
- ** * Unique file ID logic used by VxWorks.
- ** * Various locking primitive implementations (all except proxy locking):
- ** + for Posix Advisory Locks
- ** + for no-op locks
- ** + for dot-file locks
- ** + for flock() locking
- ** + for named semaphore locks (VxWorks only)
- ** + for AFP filesystem locks (MacOSX only)
- ** * sqlite3_file methods not associated with locking.
- ** * Definitions of sqlite3_io_methods objects for all locking
- ** methods plus "finder" functions for each locking method.
- ** * sqlite3_vfs method implementations.
- ** * Locking primitives for the proxy uber-locking-method. (MacOSX only)
- ** * Definitions of sqlite3_vfs objects for all locking methods
- ** plus implementations of sqlite3_os_init() and sqlite3_os_end().
- */
- #if SQLITE_OS_UNIX /* This file is used on unix only */
- /*
- ** There are various methods for file locking used for concurrency
- ** control:
- **
- ** 1. POSIX locking (the default),
- ** 2. No locking,
- ** 3. Dot-file locking,
- ** 4. flock() locking,
- ** 5. AFP locking (OSX only),
- ** 6. Named POSIX semaphores (VXWorks only),
- ** 7. proxy locking. (OSX only)
- **
- ** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE
- ** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic
- ** selection of the appropriate locking style based on the filesystem
- ** where the database is located.
- */
- #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
- # if defined(__APPLE__)
- # define SQLITE_ENABLE_LOCKING_STYLE 1
- # else
- # define SQLITE_ENABLE_LOCKING_STYLE 0
- # endif
- #endif
- /*
- ** Define the OS_VXWORKS pre-processor macro to 1 if building on
- ** vxworks, or 0 otherwise.
- */
- #ifndef OS_VXWORKS
- # if defined(__RTP__) || defined(_WRS_KERNEL)
- # define OS_VXWORKS 1
- # else
- # define OS_VXWORKS 0
- # endif
- #endif
- /*
- ** These #defines should enable >2GB file support on Posix if the
- ** underlying operating system supports it. If the OS lacks
- ** large file support, these should be no-ops.
- **
- ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
- ** on the compiler command line. This is necessary if you are compiling
- ** on a recent machine (ex: RedHat 7.2) but you want your code to work
- ** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2
- ** without this option, LFS is enable. But LFS does not exist in the kernel
- ** in RedHat 6.0, so the code won't work. Hence, for maximum binary
- ** portability you should omit LFS.
- **
- ** The previous paragraph was written in 2005. (This paragraph is written
- ** on 2008-11-28.) These days, all Linux kernels support large files, so
- ** you should probably leave LFS enabled. But some embedded platforms might
- ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
- */
- #ifndef SQLITE_DISABLE_LFS
- # define _LARGE_FILE 1
- # ifndef _FILE_OFFSET_BITS
- # define _FILE_OFFSET_BITS 64
- # endif
- # define _LARGEFILE_SOURCE 1
- #endif
- /*
- ** standard include files.
- */
- #include <sys/types.h>
- #include <sys/stat.h>
- #include <fcntl.h>
- #include <unistd.h>
- /* #include <time.h> */
- #include <sys/time.h>
- #include <errno.h>
- #ifndef SQLITE_OMIT_WAL
- #include <sys/mman.h>
- #endif
- #if SQLITE_ENABLE_LOCKING_STYLE
- # include <sys/ioctl.h>
- # if OS_VXWORKS
- # include <semaphore.h>
- # include <limits.h>
- # else
- # include <sys/file.h>
- # include <sys/param.h>
- # endif
- #endif /* SQLITE_ENABLE_LOCKING_STYLE */
- #if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
- # include <sys/mount.h>
- #endif
- #ifdef HAVE_UTIME
- # include <utime.h>
- #endif
- /*
- ** Allowed values of unixFile.fsFlags
- */
- #define SQLITE_FSFLAGS_IS_MSDOS 0x1
- /*
- ** If we are to be thread-safe, include the pthreads header and define
- ** the SQLITE_UNIX_THREADS macro.
- */
- #if SQLITE_THREADSAFE
- /* # include <pthread.h> */
- # define SQLITE_UNIX_THREADS 1
- #endif
- /*
- ** Default permissions when creating a new file
- */
- #ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
- # define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
- #endif
- /*
- ** Default permissions when creating auto proxy dir
- */
- #ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
- # define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755
- #endif
- /*
- ** Maximum supported path-length.
- */
- #define MAX_PATHNAME 512
- /*
- ** Only set the lastErrno if the error code is a real error and not
- ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
- */
- #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
- /* Forward references */
- typedef struct unixShm unixShm; /* Connection shared memory */
- typedef struct unixShmNode unixShmNode; /* Shared memory instance */
- typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
- typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */
- /*
- ** Sometimes, after a file handle is closed by SQLite, the file descriptor
- ** cannot be closed immediately. In these cases, instances of the following
- ** structure are used to store the file descriptor while waiting for an
- ** opportunity to either close or reuse it.
- */
- struct UnixUnusedFd {
- int fd; /* File descriptor to close */
- int flags; /* Flags this file descriptor was opened with */
- UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
- };
- /*
- ** The unixFile structure is subclass of sqlite3_file specific to the unix
- ** VFS implementations.
- */
- typedef struct unixFile unixFile;
- struct unixFile {
- sqlite3_io_methods const *pMethod; /* Always the first entry */
- sqlite3_vfs *pVfs; /* The VFS that created this unixFile */
- unixInodeInfo *pInode; /* Info about locks on this inode */
- int h; /* The file descriptor */
- unsigned char eFileLock; /* The type of lock held on this fd */
- unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
- int lastErrno; /* The unix errno from last I/O error */
- void *lockingContext; /* Locking style specific state */
- UnixUnusedFd *pUnused; /* Pre-allocated UnixUnusedFd */
- const char *zPath; /* Name of the file */
- unixShm *pShm; /* Shared memory segment information */
- int szChunk; /* Configured by FCNTL_CHUNK_SIZE */
- #if SQLITE_ENABLE_LOCKING_STYLE
- int openFlags; /* The flags specified at open() */
- #endif
- #if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
- unsigned fsFlags; /* cached details from statfs() */
- #endif
- #if OS_VXWORKS
- struct vxworksFileId *pId; /* Unique file ID */
- #endif
- #ifndef NDEBUG
- /* The next group of variables are used to track whether or not the
- ** transaction counter in bytes 24-27 of database files are updated
- ** whenever any part of the database changes. An assertion fault will
- ** occur if a file is updated without also updating the transaction
- ** counter. This test is made to avoid new problems similar to the
- ** one described by ticket #3584.
- */
- unsigned char transCntrChng; /* True if the transaction counter changed */
- unsigned char dbUpdate; /* True if any part of database file changed */
- unsigned char inNormalWrite; /* True if in a normal write operation */
- #endif
- #ifdef SQLITE_TEST
- /* In test mode, increase the size of this structure a bit so that
- ** it is larger than the struct CrashFile defined in test6.c.
- */
- char aPadding[32];
- #endif
- };
- /*
- ** Allowed values for the unixFile.ctrlFlags bitmask:
- */
- #define UNIXFILE_EXCL 0x01 /* Connections from one process only */
- #define UNIXFILE_RDONLY 0x02 /* Connection is read only */
- #define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
- #ifndef SQLITE_DISABLE_DIRSYNC
- # define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */
- #else
- # define UNIXFILE_DIRSYNC 0x00
- #endif
- #define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
- #define UNIXFILE_DELETE 0x20 /* Delete on close */
- #define UNIXFILE_URI 0x40 /* Filename might have query parameters */
- #define UNIXFILE_NOLOCK 0x80 /* Do no file locking */
- /*
- ** Include code that is common to all os_*.c files
- */
- /************** Include os_common.h in the middle of os_unix.c ***************/
- /************** Begin file os_common.h ***************************************/
- /*
- ** 2004 May 22
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains macros and a little bit of code that is common to
- ** all of the platform-specific files (os_*.c) and is #included into those
- ** files.
- **
- ** This file should be #included by the os_*.c files only. It is not a
- ** general purpose header file.
- */
- #ifndef _OS_COMMON_H_
- #define _OS_COMMON_H_
- /*
- ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
- ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
- ** switch. The following code should catch this problem at compile-time.
- */
- #ifdef MEMORY_DEBUG
- # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead."
- #endif
- #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
- # ifndef SQLITE_DEBUG_OS_TRACE
- # define SQLITE_DEBUG_OS_TRACE 0
- # endif
- int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
- # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
- #else
- # define OSTRACE(X)
- #endif
- /*
- ** Macros for performance tracing. Normally turned off. Only works
- ** on i486 hardware.
- */
- #ifdef SQLITE_PERFORMANCE_TRACE
- /*
- ** hwtime.h contains inline assembler code for implementing
- ** high-performance timing routines.
- */
- /************** Include hwtime.h in the middle of os_common.h ****************/
- /************** Begin file hwtime.h ******************************************/
- /*
- ** 2008 May 27
- **
- ** The author disclaims copyright to this source code. In place of
- ** a legal notice, here is a blessing:
- **
- ** May you do good and not evil.
- ** May you find forgiveness for yourself and forgive others.
- ** May you share freely, never taking more than you give.
- **
- ******************************************************************************
- **
- ** This file contains inline asm code for retrieving "high-performance"
- ** counters for x86 class CPUs.
- */
- #ifndef _HWTIME_H_
- #define _HWTIME_H_
- /*
- ** The following routine only works on pentium-class (or newer) processors.
- ** It uses the RDTSC opcode to read the cycle count value out of the
- ** processor and returns that value. This can be used for high-res
- ** profiling.
- */
- #if (defined(__GNUC__) || defined(_MSC_VER)) && \
- (defined(i386) || defined(__i386__) || defined(_M_IX86))
- #if defined(__GNUC__)
- __inline__ sqlite_uint64 sqlite3Hwtime(void){
- unsigned int lo, hi;
- __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
- return (sqlite_uint64)hi << 32 | lo;
- }
- #elif defined(_MSC_VER)
- __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
- __asm {
- rdtsc
- ret ; return value at EDX:EAX
- }
- }
- #endif
- #elif (defined(__GNUC__) && defined(__x86_64__))
- __inline__ sqlite_uint64 sqlite3Hwtime(void){
- unsigned long val;
- __asm__ __volatile__ ("rdtsc" : "=A" (val));
- return val;
- }
-
- #elif (defined(__GNUC__) && defined(__ppc__))
- __inline__ sqlite_uint64 sqlite3Hwtime(void){
- unsigned long long retval;
- unsigned long junk;
- __asm__ __volatile__ ("\n\
- 1: mftbu %1\n\
- mftb %L0\n\
- mftbu %0\n\
- cmpw %0,%1\n\
- bne 1b"
- : "=r" (retval), "=r" (junk));
- return retval;
- }
- #else
- #error Need implementation of sqlite3Hwtime() for your platform.
- /*
- ** To compile without implementing sqlite3Hwtime() for your platform,
- ** you can remove the above #error and use the following
- ** stub function. You will lose timing support for many
- ** of the debugging and testing utilities, but it should at
- ** least compile and run.
- */
- SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
- #endif
- #endif /* !defined(_HWTIME_H_) */
- /************** End of hwtime.h **********************************************/
- /************** Continuing where we left off in os_common.h ******************/
- static sqlite_uint64 g_start;
- static sqlite_uint64 g_elapsed;
- #define TIMER_START g_start=sqlite3Hwtime()
- #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start
- #define TIMER_ELAPSED g_elapsed
- #else
- #define TIMER_START
- #define TIMER_END
- #define TIMER_ELAPSED ((sqlite_uint64)0)
- #endif
- /*
- ** If we compile with the SQLITE_TEST macro set, then the following block
- ** of code will give us the ability to simulate a disk I/O error. This
- ** is used for testing the I/O recovery logic.
- */
- #ifdef SQLITE_TEST
- SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */
- SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */
- SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */
- SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */
- SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */
- SQLITE_API int sqlite3_diskfull_pending = 0;
- SQLITE_API int sqlite3_diskfull = 0;
- #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
- #define SimulateIOError(CODE) \
- if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
- || sqlite3_io_error_pending-- == 1 ) \
- { local_ioerr(); CODE; }
- static void local_ioerr(){
- IOTRACE(("IOERR\n"));
- sqlite3_io_error_hit++;
- if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
- }
- #define SimulateDiskfullError(CODE) \
- if( sqlite3_diskfull_pending ){ \
- if( sqlite3_diskfull_pending == 1 ){ \
- local_ioerr(); \
- sqlite3_diskfull = 1; \
- sqlite3_io_error_hit = 1; \
- CODE; \
- }else{ \
- sqlite3_diskfull_pending--; \
- } \
- }
- #else
- #define SimulateIOErrorBenign(X)
- #define SimulateIOError(A)
- #define SimulateDiskfullError(A)
- #endif
- /*
- ** When testing, keep a count of the number of open files.
- */
- #ifdef SQLITE_TEST
- SQLITE_API int sqlite3_open_file_count = 0;
- #define OpenCounter(X) sqlite3_open_file_count+=(X)
- #else
- #define OpenCounter(X)
- #endif
- #endif /* !defined(_OS_COMMON_H_) */
- /************** End of os_common.h *******************************************/
- /************** Continuing where we left off in os_unix.c ********************/
- /*
- ** Define various macros that are missing from some systems.
- */
- #ifndef O_LARGEFILE
- # define O_LARGEFILE 0
- #endif
- #ifdef SQLITE_DISABLE_LFS
- # undef O_LARGEFILE
- # define O_LARGEFILE 0
- #endif
- #ifndef O_NOFOLLOW
- # define O_NOFOLLOW 0
- #endif
- #ifndef O_BINARY
- # define O_BINARY 0
- #endif
- /*
- ** The threadid macro resolves to the thread-id or to 0. Used for
- ** testing and debugging only.
- */
- #if SQLITE_THREADSAFE
- #define threadid pthread_self()
- #else
- #define threadid 0
- #endif
- /*
- ** Different Unix systems declare open() in different ways. Same use
- ** open(const char*,int,mode_t). Others use open(const char*,int,...).
- ** The difference is important when using a pointer to the function.
- **
- ** The safest way to deal with the problem is to always use this wrapper
- ** which always has the same well-defined interface.
- */
- static int posixOpen(const char *zFile, int flags, int mode){
- return open(zFile, flags, mode);
- }
- /* Forward reference */
- static int openDirectory(const char*, int*);
- /*
- ** Many system calls are accessed through pointer-to-functions so that
- ** they may be overridden at runtime to facilitate fault injection during
- ** testing and sandboxing. The following array holds the names and pointers
- ** to all overrideable system calls.
- */
- static struct unix_syscall {
- const char *zName; /* Name of the sytem call */
- sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
- sqlite3_syscall_ptr pDefault; /* Default value */
- } aSyscall[] = {
- { "open", (sqlite3_syscall_ptr)posixOpen, 0 },
- #define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent)
- { "close", (sqlite3_syscall_ptr)close, 0 },
- #define osClose ((int(*)(int))aSyscall[1].pCurrent)
- { "access", (sqlite3_syscall_ptr)access, 0 },
- #define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent)
- { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 },
- #define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent)
- { "stat", (sqlite3_syscall_ptr)stat, 0 },
- #define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)
- /*
- ** The DJGPP compiler environment looks mostly like Unix, but it
- ** lacks the fcntl() system call. So redefine fcntl() to be something
- ** that always succeeds. This means that locking does not occur under
- ** DJGPP. But it is DOS - what did you expect?
- */
- #ifdef __DJGPP__
- { "fstat", 0, 0 },
- #define osFstat(a,b,c) 0
- #else
- { "fstat", (sqlite3_syscall_ptr)fstat, 0 },
- #define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent)
- #endif
- { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 },
- #define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)
- { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 },
- #define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)
- { "read", (sqlite3_syscall_ptr)read, 0 },
- #define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
- #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
- { "pread", (sqlite3_syscall_ptr)pread, 0 },
- #else
- { "pread", (sqlite3_syscall_ptr)0, 0 },
- #endif
- #define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
- #if defined(USE_PREAD64)
- { "pread64", (sqlite3_syscall_ptr)pread64, 0 },
- #else
- { "pread64", (sqlite3_syscall_ptr)0, 0 },
- #endif
- #define osPread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
- { "write", (sqlite3_syscall_ptr)write, 0 },
- #define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
- #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
- { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 },
- #else
- { "pwrite", (sqlite3_syscall_ptr)0, 0 },
- #endif
- #define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\
- aSyscall[12].pCurrent)
- #if defined(USE_PREAD64)
- { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 },
- #else
- { "pwrite64", (sqlite3_syscall_ptr)0, 0 },
- #endif
- #define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\
- aSyscall[13].pCurrent)
- #if SQLITE_ENABLE_LOCKING_STYLE
- { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 },
- #else
- { "fchmod", (sqlite3_syscall_ptr)0, 0 },
- #endif
- #define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)
- #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
- { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 },
- #else
- { "fallocate", (sqlite3_syscall_ptr)0, 0 },
- #endif
- #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
- { "unlink", (sqlite3_syscall_ptr)unlink, 0 },
- #define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)
- { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
- #define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
- { "mkdir", (sqlite3_syscall_ptr)mkdir, 0 },
- #define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent)
- { "rmdir", (sqlite3_syscall_ptr)rmdir, 0 },
- #define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent)
- }; /* End of the overrideable system calls */
- /*
- ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
- ** "unix" VFSes. Return SQLITE_OK opon successfully updating the
- ** system call pointer, or SQLITE_NOTFOUND if there is no configurable
- ** system call named zName.
- */
- static int unixSetSystemCall(
- sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
- const char *zName, /* Name of system call to override */
- sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
- ){
- unsigned int i;
- int rc = SQLITE_NOTFOUND;
- UNUSED_PARAMETER(pNotUsed);
- if( zName==0 ){
- /* If no zName is given, restore all system calls to their default
- ** settings and return NULL
- */
- rc = SQLITE_OK;
- for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
- if( aSyscall[i].pDefault ){
- aSyscall[i].pCurrent = aSyscall[i].pDefault;
- }
- }
- }else{
- /* If zName is specified, operate on only the one system call
- ** specified.
- */
- for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
- if( strcmp(zName, aSyscall[i].zName)==0 ){
- if( aSyscall[i].pDefault==0 ){
- aSyscall[i].pDefault = aSyscall[i].pCurrent;
- }
- rc = SQLITE_OK;
- if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
- aSyscall[i].pCurrent = pNewFunc;
- break;
- }
- }
- }
- return rc;
- }
- /*
- ** Return the value of a system call. Return NULL if zName is not a
- ** recognized system call name. NULL is also returned if the system call
- ** is currently undefined.
- */
- static sqlite3_syscall_ptr unixGetSystemCall(
- sqlite3_vfs *pNotUsed,
- const char *zName
- ){
- unsigned int i;
- UNUSED_PARAMETER(pNotUsed);
- for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
- if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
- }
- return 0;
- }
- /*
- ** Return the name of the first system call after zName. If zName==NULL
- ** then return the name of the first system call. Return NULL if zName
- ** is the last system call or if zName is not the name of a valid
- ** system call.
- */
- static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
- int i = -1;
- UNUSED_PARAMETER(p);
- if( zName ){
- for(i=0; i<ArraySize(aSyscall)-1; i++){
- if( strcmp(zName, aSyscall[i].zName)==0 ) break;
- }
- }
- for(i++; i<ArraySize(aSyscall); i++){
- if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
- }
- return 0;
- }
- /*
- ** Retry open() calls that fail due to EINTR
- */
- static int robust_open(const char *z, int f, int m){
- int rc;
- do{ rc = osOpen(z,f,m); }while( rc<0 && errno==EINTR );
- return rc;
- }
- /*
- ** Helper functions to obtain and relinquish the global mutex. The
- ** global mutex is used to protect the unixInodeInfo and
- ** vxworksFileId objects used by this file, all of which may be
- ** shared by multiple threads.
- **
- ** Function unixMutexHeld() is used to assert() that the global mutex
- ** is held when required. This function is only used as part of assert()
- ** statements. e.g.
- **
- ** unixEnterMutex()
- ** assert( unixMutexHeld() );
- ** unixEnterLeave()
- */
- static void unixEnterMutex(void){
- sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- }
- static void unixLeaveMutex(void){
- sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- }
- #ifdef SQLITE_DEBUG
- static int unixMutexHeld(void) {
- return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
- }
- #endif
- #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
- /*
- ** Helper function for printing out trace information from debugging
- ** binaries. This returns the string represetation of the supplied
- ** integer lock-type.
- */
- static const char *azFileLock(int eFileLock){
- switch( eFileLock ){
- case NO_LOCK: return "NONE";
- case SHARED_LOCK: return "SHARED";
- case RESERVED_LOCK: return "RESERVED";
- case PENDING_LOCK: return "PENDING";
- case EXCLUSIVE_LOCK: return "EXCLUSIVE";
- }
- return "ERROR";
- }
- #endif
- #ifdef SQLITE_LOCK_TRACE
- /*
- ** Print out information about all locking operations.
- **
- ** This routine is used for troubleshooting locks on multithreaded
- ** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE
- ** command-line option on the compiler. This code is normally
- ** turned off.
- */
- static int lockTrace(int fd, int op, struct flock *p){
- char *zOpName, *zType;
- int s;
- int savedErrno;
- if( op==F_GETLK ){
- zOpName = "GETLK";
- }else if( op==F_SETLK ){
- zOpName = "SETLK";
- }else{
- s = osFcntl(fd, op, p);
- sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
- return s;
- }
- if( p->l_type==F_RDLCK ){
- zType = "RDLCK";
- }else if( p->l_type==F_WRLCK ){
- zType = "WRLCK";
- }else if( p->l_type==F_UNLCK ){
- zType = "UNLCK";
- }else{
- assert( 0 );
- }
- assert( p->l_whence==SEEK_SET );
- s = osFcntl(fd, op, p);
- savedErrno = errno;
- sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
- threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
- (int)p->l_pid, s);
- if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
- struct flock l2;
- l2 = *p;
- osFcntl(fd, F_GETLK, &l2);
- if( l2.l_type==F_RDLCK ){
- zType = "RDLCK";
- }else if( l2.l_type==F_WRLCK ){
- zType = "WRLCK";
- }else if( l2.l_type==F_UNLCK ){
- zType = "UNLCK";
- }else{
- assert( 0 );
- }
- sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
- zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
- }
- errno = savedErrno;
- return s;
- }
- #undef osFcntl
- #define osFcntl lockTrace
- #endif /* SQLITE_LOCK_TRACE */
- /*
- ** Retry ftruncate() calls that fail due to EINTR
- */
- static int robust_ftruncate(int h, sqlite3_int64 sz){
- int rc;
- do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR );
- return rc;
- }
- /*
- ** This routine translates a standard POSIX errno code into something
- ** useful to the clients of the sqlite3 functions. Specifically, it is
- ** intended to translate a variety of "try again" errors into SQLITE_BUSY
- ** and a variety of "please close the file descriptor NOW" errors into
- ** SQLITE_IOERR
- **
- ** Errors during initialization of locks, or file system support for locks,
- ** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
- */
- static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
- switch (posixError) {
- #if 0
- /* At one point this code was not commented out. In theory, this branch
- ** should never be hit, as this function should only be called after
- ** a locking-related function (i.e. fcntl()) has returned non-zero with
- ** the value of errno as the first argument. Since a system call has failed,
- ** errno should be non-zero.
- **
- ** Despite this, if errno really is zero, we still don't want to return
- ** SQLITE_OK. The system call failed, and *some* SQLite error should be
- ** propagated back to the caller. Commenting this branch out means errno==0
- ** will be handled by the "default:" case below.
- */
- case 0:
- return SQLITE_OK;
- #endif
- case EAGAIN:
- case ETIMEDOUT:
- case EBUSY:
- case EINTR:
- case ENOLCK:
- /* random NFS retry error, unless during file system support
- * introspection, in which it actually means what it says */
- return SQLITE_BUSY;
-
- case EACCES:
- /* EACCES is like EAGAIN during locking operations, but not any other time*/
- if( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
- (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
- (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
- (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ){
- return SQLITE_BUSY;
- }
- /* else fall through */
- case EPERM:
- return SQLITE_PERM;
-
- /* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And
- ** this module never makes such a call. And the code in SQLite itself
- ** asserts that SQLITE_IOERR_BLOCKED is never returned. For these reasons
- ** this case is also commented out. If the system does set errno to EDEADLK,
- ** the default SQLITE_IOERR_XXX code will be returned. */
- #if 0
- case EDEADLK:
- return SQLITE_IOERR_BLOCKED;
- #endif
-
- #if EOPNOTSUPP!=ENOTSUP
- case EOPNOTSUPP:
- /* something went terribly awry, unless during file system support
- * introspection, in which it actually means what it says */
- #endif
- #ifdef ENOTSUP
- case ENOTSUP:
- /* invalid fd, unless during file system support introspection, in which
- * it actually means what it says */
- #endif
- case EIO:
- case EBADF:
- case EINVAL:
- case ENOTCONN:
- case ENODEV:
- case ENXIO:
- case ENOENT:
- #ifdef ESTALE /* ESTALE is not defined on Interix systems */
- case ESTALE:
- #endif
- case ENOSYS:
- /* these should force the client to close the file and reconnect */
-
- default:
- return sqliteIOErr;
- }
- }
- /******************************************************************************
- ****************** Begin Unique File ID Utility Used By VxWorks ***************
- **
- ** On most versions of unix, we can get a unique ID for a file by concatenating
- ** the device number and the inode number. But this does not work on VxWorks.
- ** On VxWorks, a unique file id must be based on the canonical filename.
- **
- ** A pointer to an instance of the following structure can be used as a
- ** unique file ID in VxWorks. Each instance of this structure contains
- ** a copy of the canonical filename. There is also a reference count.
- ** The structure is reclaimed when the number of pointers to it drops to
- ** zero.
- **
- ** There are never very many files open at one time and lookups are not
- ** a performance-critical path, so it is sufficient to put these
- ** structures on a linked list.
- */
- struct vxworksFileId {
- struct vxworksFileId *pNext; /* Next in a list of them all */
- int nRef; /* Number of references to this one */
- int nName; /* Length of the zCanonicalName[] string */
- char *zCanonicalName; /* Canonical filename */
- };
- #if OS_VXWORKS
- /*
- ** All unique filenames are held on a linked list headed by this
- ** variable:
- */
- static struct vxworksFileId *vxworksFileList = 0;
- /*
- ** Simplify a filename into its canonical form
- ** by making the following changes:
- **
- ** * removing any trailing and duplicate /
- ** * convert /./ into just /
- ** * convert /A/../ where A is any simple name into just /
- **
- ** Changes are made in-place. Return the new name length.
- **
- ** The original filename is in z[0..n-1]. Return the number of
- ** characters in the simplified name.
- */
- static int vxworksSimplifyName(char *z, int n){
- int i, j;
- while( n>1 && z[n-1]=='/' ){ n--; }
- for(i=j=0; i<n; i++){
- if( z[i]=='/' ){
- if( z[i+1]=='/' ) continue;
- if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
- i += 1;
- continue;
- }
- if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
- while( j>0 && z[j-1]!='/' ){ j--; }
- if( j>0 ){ j--; }
- i += 2;
- continue;
- }
- }
- z[j++] = z[i];
- }
- z[j] = 0;
- return j;
- }
- /*
- ** Find a unique file ID for the given absolute pathname. Return
- ** a pointer to the vxworksFileId object. This pointer is the unique
- ** file ID.
- **
- ** The nRef field of the vxworksFileId object is incremented before
- ** the object is returned. A new vxworksFileId object is created
- ** and added to the global list if necessary.
- **
- ** If a memory allocation error occurs, return NULL.
- */
- static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){
- struct vxworksFileId *pNew; /* search key and new file ID */
- struct vxworksFileId *pCandidate; /* For looping over existing file IDs */
- int n; /* Length of zAbsoluteName string */
- assert( zAbsoluteName[0]=='/' );
- n = (int)strlen(zAbsoluteName);
- pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
- if( pNew==0 ) return 0;
- pNew->zCanonicalName = (char*)&pNew[1];
- memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
- n = vxworksSimplifyName(pNew->zCanonicalName, n);
- /* Search for an existing entry that matching the canonical name.
- ** If found, increment the reference count and return a pointer to
- ** the existing file ID.
- */
- unixEnterMutex();
- for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
- if( pCandidate->nName==n
- && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
- ){
- sqlite3_free(pNew);
- pCandidate->nRef++;
- unixLeaveMutex();
- return pCandidate;
- }
- }
- /* No match was found. We will make a new file ID */
- pNew->nRef = 1;
- pNew->nName = n;
- pNew->pNext = vxworksFileList;
- vxworksFileList = pNew;
- unixLeaveMutex();
- return pNew;
- }
- /*
- ** Decrement the reference count on a vxworksFileId object. Free
- ** the object when the reference count reaches zero.
- */
- static void vxworksReleaseFileId(struct vxworksFileId *pId){
- unixEnterMutex();
- assert( pId->nRef>0 );
- pId->nRef--;
- if( pId->nRef==0 ){
- struct vxworksFileId **pp;
- for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
- assert( *pp==pId );
- *pp = pId->pNext;
- sqlite3_free(pId);
- }
- unixLeaveMutex();
- }
- #endif /* OS_VXWORKS */
- /*************** End of Unique File ID Utility Used By VxWorks ****************
- ******************************************************************************/
- /******************************************************************************
- *************************** Posix Advisory Locking ****************************
- **
- ** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996)
- ** section 6.5.2.2 lines 483 through 490 specify that when a process
- ** sets or clears a lock, that operation overrides any prior locks set
- ** by the same process. It does not explicitly say so, but this implies
- ** that it overrides locks set by the same process using a different
- ** file descriptor. Consider this test case:
- **
- ** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
- ** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
- **
- ** Suppose ./file1 and ./file2 are really the same file (because
- ** one is a hard or symbolic link to the other) then if you set
- ** an exclusive lock on fd1, then try to get an exclusive lock
- ** on fd2, it works. I would have expected the second lock to
- ** fail since there was already a lock on the file due to fd1.
- ** But not so. Since both locks came from the same process, the
- ** second overrides the first, even though they were on different
- ** file descriptors opened on different file names.
- **
- ** This means that we cannot use POSIX locks to synchronize file access
- ** among competing threads of the same process. POSIX locks will work fine
- ** to synchronize access for threads in separate processes, but not
- ** threads within the same process.
- **
- ** To work around the problem, SQLite has to manage file locks internally
- ** on its own. Whenever a new database is opened, we have to find the
- ** specific inode of the database file (the inode is determined by the
- ** st_dev and st_ino fields of the stat structure that fstat() fills in)
- ** and check for locks already existing on that inode. When locks are
- ** created or removed, we have to look at our own internal record of the
- ** locks to see if another thread has previously set a lock on that same
- ** inode.
- **
- ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
- ** For VxWorks, we have to use the alternative unique ID system based on
- ** canonical filename and implemented in the previous division.)
- **
- ** The sqlite3_file structure for POSIX is no longer just an integer file
- ** descriptor. It is now a structure that holds the integer file
- ** descriptor and a pointer to a structure that describes the internal
- ** locks on the corresponding inode. There is one locking structure
- ** per inode, so if the same inode is opened twice, both unixFile structures
- ** point to the same locking structure. The locking structure keeps
- ** a reference count (so we will know when to delete it) and a "cnt"
- ** field that tells us its internal lock status. cnt==0 means the
- ** file is unlocked. cnt==-1 means the file has an exclusive lock.
- ** cnt>0 means there are cnt shared locks on the file.
- **
- ** Any attempt to lock or unlock a file first checks the locking
- ** structure. The fcntl() system call is only invoked to set a
- ** POSIX lock if the internal lock structure transitions between
- ** a locked and an unlocked state.
- **
- ** But wait: there are yet more problems with POSIX advisory locks.
- **
- ** If you close a file descriptor that points to a file that has locks,
- ** all locks on that file that are owned by the current process are
- ** released. To work around this problem, each unixInodeInfo object
- ** maintains a count of the number of pending locks on tha inode.
- ** When an attempt is made to close an unixFile, if there are
- ** other unixFile open on the same inode that are holding locks, the call
- ** to close() the file descriptor is deferred until all of the locks clear.
- ** The unixInodeInfo structure keeps a list of file descriptors that need to
- ** be closed and that list is walked (and cleared) when the last lock
- ** clears.
- **
- ** Yet another problem: LinuxThreads do not play well with posix locks.
- **
- ** Many older versions of linux use the LinuxThreads library which is
- ** not posix compliant. Under LinuxThreads, a lock created by thread
- ** A cannot be modified or overridden by a different thread B.
- ** Only thread A can modify the lock. Locking behavior is correct
- ** if the appliation uses the newer Native Posix Thread Library (NPTL)
- ** on linux - with NPTL a lock created by thread A can override locks
- ** in thread B. But there is no way to know at compile-time which
- ** threading library is being used. So there is no way to know at
- ** compile-time whether or not thread A can override locks on thread B.
- ** One has to do a run-time check to discover the behavior of the
- ** current process.
- **
- ** SQLite used to support LinuxThreads. But support for LinuxThreads
- ** was dropped beginning with version 3.7.0. SQLite will still work with
- ** LinuxThreads provided that (1) there is no more than one connection
- ** per database file in the same process and (2) database connections
- ** do not move across threads.
- */
- /*
- ** An instance of the following structure serves as the key used
- ** to locate a particular unixInodeInfo object.
- */
- struct unixFileId {
- dev_t dev; /* Device number */
- #if OS_VXWORKS
- struct vxworksFileId *pId; /* Unique file ID for vxworks. */
- #else
- ino_t ino; /* Inode number */
- #endif
- };
- /*
- ** An instance of the following structure is allocated for each open
- ** inode. Or, on LinuxThreads, there is one of these structures for
- ** each inode opened by each thread.
- **
- ** A single inode can have multiple file descriptors, so each unixFile
- ** structure contains a pointer to an instance of this object and this
- ** object keeps a count of the number of unixFile pointing to it.
- */
- struct unixInodeInfo {
- struct unixFileId fileId; /* The lookup key */
- int nShared; /* Number of SHARED locks held */
- unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
- unsigned char bProcessLock; /* An exclusive process lock is held */
- int nRef; /* Number of pointers to this structure */
- unixShmNode *pShmNode; /* Shared memory associated with this inode */
- int nLock; /* Number of outstanding file locks */
- UnixUnusedFd *pUnused; /* Unused file descriptors to close */
- unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
- unixInodeInfo *pPrev; /* .... doubly linked */
- #if SQLITE_ENABLE_LOCKING_STYLE
- unsigned long long sharedByte; /* for AFP simulated shared lock */
- #endif
- #if OS_VXWORKS
- sem_t *pSem; /* Named POSIX semaphore */
- char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */
- #endif
- };
- /*
- ** A lists of all unixInodeInfo objects.
- */
- static unixInodeInfo *inodeList = 0;
- /*
- **
- ** This function - unixLogError_x(), is only ever called via the macro
- ** unixLogError().
- **
- ** It is invoked after an error occurs in an OS function and errno has been
- ** set. It logs a message using sqlite3_log() containing the current value of
- ** errno and, if possible, the human-readable equivalent from strerror() or
- ** strerror_r().
- **
- ** The first argument passed to the macro should be the error code that
- ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
- ** The two subsequent arguments should be the name of the OS function that
- ** failed (e.g. "unlink", "open") and the the associated file-system path,
- ** if any.
- */
- #define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__)
- static int unixLogErrorAtLine(
- int errcode, /* SQLite error code */
- const char *zFunc, /* Name of OS function that failed */
- const char *zPath, /* File path associated with error */
- int iLine /* Source line number where error occurred */
- ){
- char *zErr; /* Message from strerror() or equivalent */
- int iErrno = errno; /* Saved syscall error number */
- /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
- ** the strerror() function to obtain the human-readable error message
- ** equivalent to errno. Otherwise, use strerror_r().
- */
- #if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R)
- char aErr[80];
- memset(aErr, 0, sizeof(aErr));
- zErr = aErr;
- /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
- ** assume that the system provides the the GNU version of strerror_r() that
- ** returns a pointer to a buffer containing the error message. That pointer
- ** may point to aErr[], or it may point to some static storage somewhere.
- ** Otherwise, assume that the system provides the POSIX version of
- ** strerror_r(), which always writes an error message into aErr[].
- **
- ** If the code incorrectly assumes that it is the POSIX version that is
- ** available, the error message will often be an empty string. Not a
- ** huge problem. Incorrectly concluding that the GNU version is available
- ** could lead to a segfault though.
- */
- #if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
- zErr =
- # endif
- strerror_r(iErrno, aErr, sizeof(aErr)-1);
- #elif SQLITE_THREADSAFE
- /* This is a threadsafe build, but strerror_r() is not available. */
- zErr = "";
- #else
- /* Non-threadsafe build, use strerror(). */
- zErr = strerror(iErrno);
- #endif
- assert( errcode!=SQLITE_OK );
- if( zPath==0 ) zPath = "";
- sqlite3_log(errcode,
- "os_unix.c:%d: (%d) %s(%s) - %s",
- iLine, iErrno, zFunc, zPath, zErr
- );
- return errcode;
- }
- /*
- ** Close a file descriptor.
- **
- ** We assume that close() almost always works, since it is only in a
- ** very sick application or on a very sick platform that it might fail.
- ** If it does fail, simply leak the file descriptor, but do log the
- ** error.
- **
- ** Note that it is not safe to retry close() after EINTR since the
- ** file descriptor might have already been reused by another thread.
- ** So we don't even try to recover from an EINTR. Just log the error
- ** and move on.
- */
- static void robust_close(unixFile *pFile, int h, int lineno){
- if( osClose(h) ){
- unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close",
- pFile ? pFile->zPath : 0, lineno);
- }
- }
- /*
- ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
- */
- static void closePendingFds(unixFile *pFile){
- unixInodeInfo *pInode = pFile->pInode;
- UnixUnusedFd *p;
- UnixUnusedFd *pNext;
- for(p=pInode->pUnused; p; p=pNext){
- pNext = p->pNext;
- robust_close(pFile, p->fd, __LINE__);
- sqlite3_free(p);
- }
- pInode->pUnused = 0;
- }
- /*
- ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
- **
- ** The mutex entered using the unixEnterMutex() function must be held
- ** when this function is called.
- */
- static void releaseInodeInfo(unixFile *pFile){
- unixInodeInfo *pInode = pFile->pInode;
- assert( unixMutexHeld() );
- if( ALWAYS(pInode) ){
- pInode->nRef--;
- if( pInode->nRef==0 ){
- assert( pInode->pShmNode==0 );
- closePendingFds(pFile);
- if( pInode->pPrev ){
- assert( pInode->pPrev->pNext==pInode );
- pInode->pPrev->pNext = pInode->pNext;
- }else{
- assert( inodeList==pInode );
- inodeList = pInode->pNext;
- }
- if( pInode->pNext ){
- assert( pInode->pNext->pPrev==pInode );
- pInode->pNext->pPrev = pInode->pPrev;
- }
- sqlite3_free(pInode);
- }
- }
- }
- /*
- ** Given a file descriptor, locate the unixInodeInfo object that
- ** describes that file descriptor. Create a new one if necessary. The
- ** return value might be uninitialized if an error occurs.
- **
- ** The mutex entered using the unixEnterMutex() function must be held
- ** when this function is called.
- **
- ** Return an appropriate error code.
- */
- static int findInodeInfo(
- unixFile *pFile, /* Unix file with file desc used in the key */
- unixInodeInfo **ppInode /* Return the unixInodeInfo object here */
- ){
- int rc; /* System call return code */
- int fd; /* The file descriptor for pFile */
- struct unixFileId fileId; /* Lookup key for the unixInodeInfo */
- struct stat statbuf; /* Low-level file information */
- unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */
- assert( unixMutexHeld() );
- /* Get low-level information about the file that we can used to
- ** create a unique name for the file.
- */
- fd = pFile->h;
- rc = osFstat(fd, &statbuf);
- if( rc!=0 ){
- pFile->lastErrno = errno;
- #ifdef EOVERFLOW
- if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
- #endif
- return SQLITE_IOERR;
- }
- #ifdef __APPLE__
- /* On OS X on an msdos filesystem, the inode number is reported
- ** incorrectly for zero-size files. See ticket #3260. To work
- ** around this problem (we consider it a bug in OS X, not SQLite)
- ** we always increase the file size to 1 by writing a single byte
- ** prior to accessing the inode number. The one byte written is
- ** an ASCII 'S' character which also happens to be the first byte
- ** in the header of every SQLite database. In this way, if there
- ** is a race condition such that another thread has already populated
- ** the first page of the database, no damage is done.
- */
- if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
- do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
- if( rc!=1 ){
- pFile->lastErrno = errno;
- return SQLITE_IOERR;
- }
- rc = osFstat(fd, &statbuf);
- if( rc!=0 ){
- pFile->lastErrno = errno;
- return SQLITE_IOERR;
- }
- }
- #endif
- memset(&fileId, 0, sizeof(fileId));
- fileId.dev = statbuf.st_dev;
- #if OS_VXWORKS
- fileId.pId = pFile->pId;
- #else
- fileId.ino = statbuf.st_ino;
- #endif
- pInode = inodeList;
- while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
- pInode = pInode->pNext;
- }
- if( pInode==0 ){
- pInode = sqlite3_malloc( sizeof(*pInode) );
- if( pInode==0 ){
- return SQLITE_NOMEM;
- }
- memset(pInode, 0, sizeof(*pInode));
- memcpy(&pInode->fileId, &fileId, sizeof(fileId));
- pInode->nRef = 1;
- pInode->pNext = inodeList;
- pInode->pPrev = 0;
- if( inodeList ) inodeList->pPrev = pInode;
- inodeList = pInode;
- }else{
- pInode->nRef++;
- }
- *ppInode = pInode;
- return SQLITE_OK;
- }
- /*
- ** This routine checks if there is a RESERVED lock held on the specified
- ** file by this or any other process. If such a lock is held, set *pResOut
- ** to a non-zero value otherwise *pResOut is set to zero. The return value
- ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
- */
- static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
- int rc = SQLITE_OK;
- int reserved = 0;
- unixFile *pFile = (unixFile*)id;
- SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
- assert( pFile );
- unixEnterMutex(); /* Because pFile->pInode is shared across threads */
- /* Check if a thread in this process holds such a lock */
- if( pFile->pInode->eFileLock>SHARED_LOCK ){
- reserved = 1;
- }
- /* Otherwise see if some other process holds it.
- */
- #ifndef __DJGPP__
- if( !reserved && !pFile->pInode->bProcessLock ){
- struct flock lock;
- lock.l_whence = SEEK_SET;
- lock.l_start = RESERVED_BYTE;
- lock.l_len = 1;
- lock.l_type = F_WRLCK;
- if( osFcntl(pFile->h, F_GETLK, &lock) ){
- rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
- pFile->lastErrno = errno;
- } else if( lock.l_type!=F_UNLCK ){
- reserved = 1;
- }
- }
- #endif
-
- unixLeaveMutex();
- OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
- *pResOut = reserved;
- return rc;
- }
- /*
- ** Attempt to set a system-lock on the file pFile. The lock is
- ** described by pLock.
- **
- ** If the pFile was opened read/write from unix-excl, then the only lock
- ** ever obtained is an exclusive lock, and it is obtained exactly once
- ** the first time any lock is attempted. All subsequent system locking
- ** operations become no-ops. Locking operations still happen internally,
- ** in order to coordinate access between separate database connections
- ** within this process, but all of that is handled in memory and the
- ** operating system does not participate.
- **
- ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
- ** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
- ** and is read-only.
- **
- ** Zero is returned if the call completes successfully, or -1 if a call
- ** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
- */
- static int unixFileLock(unixFile *pFile, struct flock *pLock){
- int rc;
- unixInodeInfo *pInode = pFile->pInode;
- assert( unixMutexHeld() );
- assert( pInode!=0 );
- if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock)
- && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0)
- ){
- if( pInode->bProcessLock==0 ){
- struct flock lock;
- assert( pInode->nLock==0 );
- lock.l_whence = SEEK_SET;
- lock.l_start = SHARED_FIRST;
- lock.l_len = SHARED_SIZE;
- lock.l_type = F_WRLCK;
- rc = osFcntl(pFile->h, F_SETLK, &lock);
- if( rc<0 ) return rc;
- pInode->bProcessLock = 1;
- pInode->nLock++;
- }else{
- rc = 0;
- }
- }else{
- rc = osFcntl(pFile->h, F_SETLK, pLock);
- }
- return rc;
- }
- /*
- ** Lock the file with the lock specified by parameter eFileLock - one
- ** of the following:
- **
- ** (1) SHARED_LOCK
- ** (2) RESERVED_LOCK
- ** (3) PENDING_LOCK
- ** (4) EXCLUSIVE_LOCK
- **
- ** Sometimes when requesting one lock state, additional lock states
- ** are inserted in between. The locking might fail on one of the later
- ** transitions leaving the lock state different from what it started but
- ** still short of its goal. The following chart shows the allowed
- ** transitions and the inserted intermediate states:
- **
- ** UNLOCKED -> SHARED
- ** SHARED -> RESERVED
- ** SHARED -> (PENDING) -> EXCLUSIVE
- ** RESERVED -> (PENDING) -> EXCLUSIVE
- ** PENDING -> EXCLUSIVE
- **
- ** This routine will only increase a lock. Use the sqlite3OsUnlock()
- ** routine to lower a locking level.
- */
- static int unixLock(sqlite3_file *id, int eFileLock){
- /* The following describes the implementation of the various locks and
- ** lock transitions in terms of the POSIX advisory shared and exclusive
- ** lock primitives (called read-locks and write-locks below, to avoid
- ** confusion with SQLite lock names). The algorithms are complicated
- ** slightly in order to be compatible with windows systems simultaneously
- ** accessing the same database file, in case that is ever required.
- **
- ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
- ** byte', each single bytes at well known offsets, and the 'shared byte
- ** range', a range of 510 bytes at a well known offset.
- **
- ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
- ** byte'. If this is successful, a random byte from the 'shared byte
- ** range' is read-locked and the lock