/db/sqlite3/src/sqlite3.c
C | 10892 lines | 2863 code | 471 blank | 7558 comment | 37 complexity | f34bca82efdadb1451d829710755bce9 MD5 | raw file
Possible License(s): GPL-2.0, JSON, 0BSD, LGPL-3.0, AGPL-1.0, MIT, MPL-2.0-no-copyleft-exception, BSD-3-Clause, LGPL-2.1, Apache-2.0
Large files files are truncated, but you can click here to view the full file
- /******************************************************************************
- ** This file is an amalgamation of many separate C source files from SQLite
- ** version 3.7.11. 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.11"
- #define SQLITE_VERSION_NUMBER 3007011
- #define SQLITE_SOURCE_ID "2012-03-20 11:35:50 00bb9c9ce4f465e6ac321ced2a9d0062dc364669"
- /*
- ** 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))
- #define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (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 w…
Large files files are truncated, but you can click here to view the full file