1 /******************************************************************************

     2 ** This file is an amalgamation of many separate C source files from SQLite

     3 ** version 3.6.19.  By combining all the individual C code files into this 

     4 ** single large file, the entire code can be compiled as a one translation

     5 ** unit.  This allows many compilers to do optimizations that would not be

     6 ** possible if the files were compiled separately.  Performance improvements

     7 ** of 5% are more are commonly seen when SQLite is compiled as a single

     8 ** translation unit.

     9 **

    10 ** This file is all you need to compile SQLite.  To use SQLite in other

    11 ** programs, you need this file and the "sqlite3.h" header file that defines

    12 ** the programming interface to the SQLite library.  (If you do not have 

    13 ** the "sqlite3.h" header file at hand, you will find a copy embedded within

    14 ** the text of this file.  Search for "Begin file sqlite3.h" to find the start

    15 ** of the embedded sqlite3.h header file.) Additional code files may be needed

    16 ** if you want a wrapper to interface SQLite with your choice of programming

    17 ** language. The code for the "sqlite3" command-line shell is also in a

    18 ** separate file. This file contains only code for the core SQLite library.

    19 **

    20 ** This amalgamation was generated on 2009-10-14 11:35:02 UTC.

    21 */

    22 #define SQLITE_CORE 1

    23 #define SQLITE_AMALGAMATION 1

    24 #ifndef SQLITE_PRIVATE

    25 # define SQLITE_PRIVATE static

    26 #endif

    27 #ifndef SQLITE_API

    28 # define SQLITE_API

    29 #endif

    30 /************** Begin file sqliteInt.h ***************************************/

    31 /*

    32 ** 2001 September 15

    33 **

    34 ** The author disclaims copyright to this source code.  In place of

    35 ** a legal notice, here is a blessing:

    36 **

    37 **    May you do good and not evil.

    38 **    May you find forgiveness for yourself and forgive others.

    39 **    May you share freely, never taking more than you give.

    40 **

    41 *************************************************************************

    42 ** Internal interface definitions for SQLite.

    43 **

    44 */

    45 #ifndef _SQLITEINT_H_

    46 #define _SQLITEINT_H_

    47 

    48 /*

    49 ** These #defines should enable >2GB file support on POSIX if the

    50 ** underlying operating system supports it.  If the OS lacks

    51 ** large file support, or if the OS is windows, these should be no-ops.

    52 **

    53 ** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any

    54 ** system #includes.  Hence, this block of code must be the very first

    55 ** code in all source files.

    56 **

    57 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch

    58 ** on the compiler command line.  This is necessary if you are compiling

    59 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work

    60 ** on an older machine (ex: Red Hat 6.0).  If you compile on Red Hat 7.2

    61 ** without this option, LFS is enable.  But LFS does not exist in the kernel

    62 ** in Red Hat 6.0, so the code won't work.  Hence, for maximum binary

    63 ** portability you should omit LFS.

    64 **

    65 ** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.

    66 */

    67 #ifndef SQLITE_DISABLE_LFS

    68 # define _LARGE_FILE       1

    69 # ifndef _FILE_OFFSET_BITS

    70 #   define _FILE_OFFSET_BITS 64

    71 # endif

    72 # define _LARGEFILE_SOURCE 1

    73 #endif

    74 

    75 /*

    76 ** Include the configuration header output by 'configure' if we're using the

    77 ** autoconf-based build

    78 */

    79 #ifdef _HAVE_SQLITE_CONFIG_H

    80 #include "config.h"

    81 #endif

    82 

    83 /************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/

    84 /************** Begin file sqliteLimit.h *************************************/

    85 /*

    86 ** 2007 May 7

    87 **

    88 ** The author disclaims copyright to this source code.  In place of

    89 ** a legal notice, here is a blessing:

    90 **

    91 **    May you do good and not evil.

    92 **    May you find forgiveness for yourself and forgive others.

    93 **    May you share freely, never taking more than you give.

    94 **

    95 *************************************************************************

    96 ** 

    97 ** This file defines various limits of what SQLite can process.

    98 **

    99 ** @(#) $Id: sqliteLimit.h,v 1.10 2009/01/10 16:15:09 danielk1977 Exp $

   100 */

   101 

   102 /*

   103 ** The maximum length of a TEXT or BLOB in bytes.   This also

   104 ** limits the size of a row in a table or index.

   105 **

   106 ** The hard limit is the ability of a 32-bit signed integer

   107 ** to count the size: 2^31-1 or 2147483647.

   108 */

   109 #ifndef SQLITE_MAX_LENGTH

   110 # define SQLITE_MAX_LENGTH 1000000000

   111 #endif

   112 

   113 /*

   114 ** This is the maximum number of

   115 **

   116 **    * Columns in a table

   117 **    * Columns in an index

   118 **    * Columns in a view

   119 **    * Terms in the SET clause of an UPDATE statement

   120 **    * Terms in the result set of a SELECT statement

   121 **    * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.

   122 **    * Terms in the VALUES clause of an INSERT statement

   123 **

   124 ** The hard upper limit here is 32676.  Most database people will

   125 ** tell you that in a well-normalized database, you usually should

   126 ** not have more than a dozen or so columns in any table.  And if

   127 ** that is the case, there is no point in having more than a few

   128 ** dozen values in any of the other situations described above.

   129 */

   130 #ifndef SQLITE_MAX_COLUMN

   131 # define SQLITE_MAX_COLUMN 2000

   132 #endif

   133 

   134 /*

   135 ** The maximum length of a single SQL statement in bytes.

   136 **

   137 ** It used to be the case that setting this value to zero would

   138 ** turn the limit off.  That is no longer true.  It is not possible

   139 ** to turn this limit off.

   140 */

   141 #ifndef SQLITE_MAX_SQL_LENGTH

   142 # define SQLITE_MAX_SQL_LENGTH 1000000000

   143 #endif

   144 

   145 /*

   146 ** The maximum depth of an expression tree. This is limited to 

   147 ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 

   148 ** want to place more severe limits on the complexity of an 

   149 ** expression.

   150 **

   151 ** A value of 0 used to mean that the limit was not enforced.

   152 ** But that is no longer true.  The limit is now strictly enforced

   153 ** at all times.

   154 */

   155 #ifndef SQLITE_MAX_EXPR_DEPTH

   156 # define SQLITE_MAX_EXPR_DEPTH 1000

   157 #endif

   158 

   159 /*

   160 ** The maximum number of terms in a compound SELECT statement.

   161 ** The code generator for compound SELECT statements does one

   162 ** level of recursion for each term.  A stack overflow can result

   163 ** if the number of terms is too large.  In practice, most SQL

   164 ** never has more than 3 or 4 terms.  Use a value of 0 to disable

   165 ** any limit on the number of terms in a compount SELECT.

   166 */

   167 #ifndef SQLITE_MAX_COMPOUND_SELECT

   168 # define SQLITE_MAX_COMPOUND_SELECT 500

   169 #endif

   170 

   171 /*

   172 ** The maximum number of opcodes in a VDBE program.

   173 ** Not currently enforced.

   174 */

   175 #ifndef SQLITE_MAX_VDBE_OP

   176 # define SQLITE_MAX_VDBE_OP 25000

   177 #endif

   178 

   179 /*

   180 ** The maximum number of arguments to an SQL function.

   181 */

   182 #ifndef SQLITE_MAX_FUNCTION_ARG

   183 # define SQLITE_MAX_FUNCTION_ARG 127

   184 #endif

   185 

   186 /*

   187 ** The maximum number of in-memory pages to use for the main database

   188 ** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE

   189 */

   190 #ifndef SQLITE_DEFAULT_CACHE_SIZE

   191 # define SQLITE_DEFAULT_CACHE_SIZE  2000

   192 #endif

   193 #ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE

   194 # define SQLITE_DEFAULT_TEMP_CACHE_SIZE  500

   195 #endif

   196 

   197 /*

   198 ** The maximum number of attached databases.  This must be between 0

   199 ** and 30.  The upper bound on 30 is because a 32-bit integer bitmap

   200 ** is used internally to track attached databases.

   201 */

   202 #ifndef SQLITE_MAX_ATTACHED

   203 # define SQLITE_MAX_ATTACHED 10

   204 #endif

   205 

   206 

   207 /*

   208 ** The maximum value of a ?nnn wildcard that the parser will accept.

   209 */

   210 #ifndef SQLITE_MAX_VARIABLE_NUMBER

   211 # define SQLITE_MAX_VARIABLE_NUMBER 999

   212 #endif

   213 

   214 /* Maximum page size.  The upper bound on this value is 32768.  This a limit

   215 ** imposed by the necessity of storing the value in a 2-byte unsigned integer

   216 ** and the fact that the page size must be a power of 2.

   217 **

   218 ** If this limit is changed, then the compiled library is technically

   219 ** incompatible with an SQLite library compiled with a different limit. If

   220 ** a process operating on a database with a page-size of 65536 bytes 

   221 ** crashes, then an instance of SQLite compiled with the default page-size 

   222 ** limit will not be able to rollback the aborted transaction. This could

   223 ** lead to database corruption.

   224 */

   225 #ifndef SQLITE_MAX_PAGE_SIZE

   226 # define SQLITE_MAX_PAGE_SIZE 32768

   227 #endif

   228 

   229 

   230 /*

   231 ** The default size of a database page.

   232 */

   233 #ifndef SQLITE_DEFAULT_PAGE_SIZE

   234 # define SQLITE_DEFAULT_PAGE_SIZE 1024

   235 #endif

   236 #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE

   237 # undef SQLITE_DEFAULT_PAGE_SIZE

   238 # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE

   239 #endif

   240 

   241 /*

   242 ** Ordinarily, if no value is explicitly provided, SQLite creates databases

   243 ** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain

   244 ** device characteristics (sector-size and atomic write() support),

   245 ** SQLite may choose a larger value. This constant is the maximum value

   246 ** SQLite will choose on its own.

   247 */

   248 #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE

   249 # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192

   250 #endif

   251 #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE

   252 # undef SQLITE_MAX_DEFAULT_PAGE_SIZE

   253 # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE

   254 #endif

   255 

   256 

   257 /*

   258 ** Maximum number of pages in one database file.

   259 **

   260 ** This is really just the default value for the max_page_count pragma.

   261 ** This value can be lowered (or raised) at run-time using that the

   262 ** max_page_count macro.

   263 */

   264 #ifndef SQLITE_MAX_PAGE_COUNT

   265 # define SQLITE_MAX_PAGE_COUNT 1073741823

   266 #endif

   267 

   268 /*

   269 ** Maximum length (in bytes) of the pattern in a LIKE or GLOB

   270 ** operator.

   271 */

   272 #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH

   273 # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000

   274 #endif

   275 

   276 /*

   277 ** Maximum depth of recursion for triggers.

   278 **

   279 ** A value of 1 means that a trigger program will not be able to itself

   280 ** fire any triggers. A value of 0 means that no trigger programs at all 

   281 ** may be executed.

   282 */

   283 #ifndef SQLITE_MAX_TRIGGER_DEPTH

   284 #if defined(SQLITE_SMALL_STACK)

   285 # define SQLITE_MAX_TRIGGER_DEPTH 10

   286 #else

   287 # define SQLITE_MAX_TRIGGER_DEPTH 1000

   288 #endif

   289 #endif

   290 

   291 /************** End of sqliteLimit.h *****************************************/

   292 /************** Continuing where we left off in sqliteInt.h ******************/

   293 

   294 /* Disable nuisance warnings on Borland compilers */

   295 #if defined(__BORLANDC__)

   296 #pragma warn -rch /* unreachable code */

   297 #pragma warn -ccc /* Condition is always true or false */

   298 #pragma warn -aus /* Assigned value is never used */

   299 #pragma warn -csu /* Comparing signed and unsigned */

   300 #pragma warn -spa /* Suspicious pointer arithmetic */

   301 #endif

   302 

   303 /* Needed for various definitions... */

   304 #ifndef _GNU_SOURCE

   305 # define _GNU_SOURCE

   306 #endif

   307 

   308 /*

   309 ** Include standard header files as necessary

   310 */

   311 #ifdef HAVE_STDINT_H

   312 #include <stdint.h>

   313 #endif

   314 #ifdef HAVE_INTTYPES_H

   315 #include <inttypes.h>

   316 #endif

   317 

   318 #define SQLITE_INDEX_SAMPLES 10

   319 

   320 /*

   321 ** This macro is used to "hide" some ugliness in casting an int

   322 ** value to a ptr value under the MSVC 64-bit compiler.   Casting

   323 ** non 64-bit values to ptr types results in a "hard" error with 

   324 ** the MSVC 64-bit compiler which this attempts to avoid.  

   325 **

   326 ** A simple compiler pragma or casting sequence could not be found

   327 ** to correct this in all situations, so this macro was introduced.

   328 **

   329 ** It could be argued that the intptr_t type could be used in this

   330 ** case, but that type is not available on all compilers, or 

   331 ** requires the #include of specific headers which differs between

   332 ** platforms.

   333 **

   334 ** Ticket #3860:  The llvm-gcc-4.2 compiler from Apple chokes on

   335 ** the ((void*)&((char*)0)[X]) construct.  But MSVC chokes on ((void*)(X)).

   336 ** So we have to define the macros in different ways depending on the

   337 ** compiler.

   338 */

   339 #if defined(__GNUC__)

   340 # if defined(HAVE_STDINT_H)

   341 #   define SQLITE_INT_TO_PTR(X)  ((void*)(intptr_t)(X))

   342 #   define SQLITE_PTR_TO_INT(X)  ((int)(intptr_t)(X))

   343 # else

   344 #   define SQLITE_INT_TO_PTR(X)  ((void*)(X))

   345 #   define SQLITE_PTR_TO_INT(X)  ((int)(X))

   346 # endif

   347 #else

   348 # define SQLITE_INT_TO_PTR(X)   ((void*)&((char*)0)[X])

   349 # define SQLITE_PTR_TO_INT(X)   ((int)(((char*)X)-(char*)0))

   350 #endif

   351 

   352 

   353 /*

   354 ** The SQLITE_THREADSAFE macro must be defined as either 0 or 1.

   355 ** Older versions of SQLite used an optional THREADSAFE macro.

   356 ** We support that for legacy

   357 */

   358 #if !defined(SQLITE_THREADSAFE)

   359 #if defined(THREADSAFE)

   360 # define SQLITE_THREADSAFE THREADSAFE

   361 #else

   362 # define SQLITE_THREADSAFE 1

   363 #endif

   364 #endif

   365 

   366 /*

   367 ** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.

   368 ** It determines whether or not the features related to 

   369 ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can

   370 ** be overridden at runtime using the sqlite3_config() API.

   371 */

   372 #if !defined(SQLITE_DEFAULT_MEMSTATUS)

   373 # define SQLITE_DEFAULT_MEMSTATUS 1

   374 #endif

   375 

   376 /*

   377 ** Exactly one of the following macros must be defined in order to

   378 ** specify which memory allocation subsystem to use.

   379 **

   380 **     SQLITE_SYSTEM_MALLOC          // Use normal system malloc()

   381 **     SQLITE_MEMDEBUG               // Debugging version of system malloc()

   382 **     SQLITE_MEMORY_SIZE            // internal allocator #1

   383 **     SQLITE_MMAP_HEAP_SIZE         // internal mmap() allocator

   384 **     SQLITE_POW2_MEMORY_SIZE       // internal power-of-two allocator

   385 **

   386 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as

   387 ** the default.

   388 */

   389 #if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)+\

   390     defined(SQLITE_MEMORY_SIZE)+defined(SQLITE_MMAP_HEAP_SIZE)+\

   391     defined(SQLITE_POW2_MEMORY_SIZE)>1

   392 # error "At most one of the following compile-time configuration options\

   393  is allows: SQLITE_SYSTEM_MALLOC, SQLITE_MEMDEBUG, SQLITE_MEMORY_SIZE,\

   394  SQLITE_MMAP_HEAP_SIZE, SQLITE_POW2_MEMORY_SIZE"

   395 #endif

   396 #if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)+\

   397     defined(SQLITE_MEMORY_SIZE)+defined(SQLITE_MMAP_HEAP_SIZE)+\

   398     defined(SQLITE_POW2_MEMORY_SIZE)==0

   399 # define SQLITE_SYSTEM_MALLOC 1

   400 #endif

   401 

   402 /*

   403 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the

   404 ** sizes of memory allocations below this value where possible.

   405 */

   406 #if !defined(SQLITE_MALLOC_SOFT_LIMIT)

   407 # define SQLITE_MALLOC_SOFT_LIMIT 1024

   408 #endif

   409 

   410 /*

   411 ** We need to define _XOPEN_SOURCE as follows in order to enable

   412 ** recursive mutexes on most Unix systems.  But Mac OS X is different.

   413 ** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,

   414 ** so it is omitted there.  See ticket #2673.

   415 **

   416 ** Later we learn that _XOPEN_SOURCE is poorly or incorrectly

   417 ** implemented on some systems.  So we avoid defining it at all

   418 ** if it is already defined or if it is unneeded because we are

   419 ** not doing a threadsafe build.  Ticket #2681.

   420 **

   421 ** See also ticket #2741.

   422 */

   423 #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE && !defined(VXWORKS)

   424 #  define _XOPEN_SOURCE 500  /* Needed to enable pthread recursive mutexes */

   425 #endif

   426 

   427 /*

   428 ** The TCL headers are only needed when compiling the TCL bindings.

   429 */

   430 #if defined(SQLITE_TCL) || defined(TCLSH)

   431 # include <tcl.h>

   432 #endif

   433 

   434 /*

   435 ** Many people are failing to set -DNDEBUG=1 when compiling SQLite.

   436 ** Setting NDEBUG makes the code smaller and run faster.  So the following

   437 ** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1

   438 ** option is set.  Thus NDEBUG becomes an opt-in rather than an opt-out

   439 ** feature.

   440 */

   441 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 

   442 # define NDEBUG 1

   443 #endif

   444 

   445 /*

   446 ** The testcase() macro is used to aid in coverage testing.  When 

   447 ** doing coverage testing, the condition inside the argument to

   448 ** testcase() must be evaluated both true and false in order to

   449 ** get full branch coverage.  The testcase() macro is inserted

   450 ** to help ensure adequate test coverage in places where simple

   451 ** condition/decision coverage is inadequate.  For example, testcase()

   452 ** can be used to make sure boundary values are tested.  For

   453 ** bitmask tests, testcase() can be used to make sure each bit

   454 ** is significant and used at least once.  On switch statements

   455 ** where multiple cases go to the same block of code, testcase()

   456 ** can insure that all cases are evaluated.

   457 **

   458 */

   459 #ifdef SQLITE_COVERAGE_TEST

   460 SQLITE_PRIVATE   void sqlite3Coverage(int);

   461 # define testcase(X)  if( X ){ sqlite3Coverage(__LINE__); }

   462 #else

   463 # define testcase(X)

   464 #endif

   465 

   466 /*

   467 ** The TESTONLY macro is used to enclose variable declarations or

   468 ** other bits of code that are needed to support the arguments

   469 ** within testcase() and assert() macros.

   470 */

   471 #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)

   472 # define TESTONLY(X)  X

   473 #else

   474 # define TESTONLY(X)

   475 #endif

   476 

   477 /*

   478 ** Sometimes we need a small amount of code such as a variable initialization

   479 ** to setup for a later assert() statement.  We do not want this code to

   480 ** appear when assert() is disabled.  The following macro is therefore

   481 ** used to contain that setup code.  The "VVA" acronym stands for

   482 ** "Verification, Validation, and Accreditation".  In other words, the

   483 ** code within VVA_ONLY() will only run during verification processes.

   484 */

   485 #ifndef NDEBUG

   486 # define VVA_ONLY(X)  X

   487 #else

   488 # define VVA_ONLY(X)

   489 #endif

   490 

   491 /*

   492 ** The ALWAYS and NEVER macros surround boolean expressions which 

   493 ** are intended to always be true or false, respectively.  Such

   494 ** expressions could be omitted from the code completely.  But they

   495 ** are included in a few cases in order to enhance the resilience

   496 ** of SQLite to unexpected behavior - to make the code "self-healing"

   497 ** or "ductile" rather than being "brittle" and crashing at the first

   498 ** hint of unplanned behavior.

   499 **

   500 ** In other words, ALWAYS and NEVER are added for defensive code.

   501 **

   502 ** When doing coverage testing ALWAYS and NEVER are hard-coded to

   503 ** be true and false so that the unreachable code then specify will

   504 ** not be counted as untested code.

   505 */

   506 #if defined(SQLITE_COVERAGE_TEST)

   507 # define ALWAYS(X)      (1)

   508 # define NEVER(X)       (0)

   509 #elif !defined(NDEBUG)

   510 # define ALWAYS(X)      ((X)?1:(assert(0),0))

   511 # define NEVER(X)       ((X)?(assert(0),1):0)

   512 #else

   513 # define ALWAYS(X)      (X)

   514 # define NEVER(X)       (X)

   515 #endif

   516 

   517 /*

   518 ** The macro unlikely() is a hint that surrounds a boolean

   519 ** expression that is usually false.  Macro likely() surrounds

   520 ** a boolean expression that is usually true.  GCC is able to

   521 ** use these hints to generate better code, sometimes.

   522 */

   523 #if defined(__GNUC__) && 0

   524 # define likely(X)    __builtin_expect((X),1)

   525 # define unlikely(X)  __builtin_expect((X),0)

   526 #else

   527 # define likely(X)    !!(X)

   528 # define unlikely(X)  !!(X)

   529 #endif

   530 

   531 /************** Include sqlite3.h in the middle of sqliteInt.h ***************/

   532 /************** Begin file sqlite3.h *****************************************/

   533 /*

   534 ** 2001 September 15

   535 **

   536 ** The author disclaims copyright to this source code.  In place of

   537 ** a legal notice, here is a blessing:

   538 **

   539 **    May you do good and not evil.

   540 **    May you find forgiveness for yourself and forgive others.

   541 **    May you share freely, never taking more than you give.

   542 **

   543 *************************************************************************

   544 ** This header file defines the interface that the SQLite library

   545 ** presents to client programs.  If a C-function, structure, datatype,

   546 ** or constant definition does not appear in this file, then it is

   547 ** not a published API of SQLite, is subject to change without

   548 ** notice, and should not be referenced by programs that use SQLite.

   549 **

   550 ** Some of the definitions that are in this file are marked as

   551 ** "experimental".  Experimental interfaces are normally new

   552 ** features recently added to SQLite.  We do not anticipate changes

   553 ** to experimental interfaces but reserve the right to make minor changes

   554 ** if experience from use "in the wild" suggest such changes are prudent.

   555 **

   556 ** The official C-language API documentation for SQLite is derived

   557 ** from comments in this file.  This file is the authoritative source

   558 ** on how SQLite interfaces are suppose to operate.

   559 **

   560 ** The name of this file under configuration management is "sqlite.h.in".

   561 ** The makefile makes some minor changes to this file (such as inserting

   562 ** the version number) and changes its name to "sqlite3.h" as

   563 ** part of the build process.

   564 */

   565 #ifndef _SQLITE3_H_

   566 #define _SQLITE3_H_

   567 

   568 #ifdef VXWORKS

   569 # define SQLITE_HOMEGROWN_RECURSIVE_MUTEX

   570 # define NO_GETTOD

   571 # include <ioLib.h>

   572 #endif

   573 

   574 #include <stdarg.h>     /* Needed for the definition of va_list */

   575 

   576 /*

   577 ** Make sure we can call this stuff from C++.

   578 */

   579 #if 0

   580 extern "C" {

   581 #endif

   582 

   583 

   584 /*

   585 ** Add the ability to override 'extern'

   586 */

   587 #ifndef SQLITE_EXTERN

   588 # define SQLITE_EXTERN extern

   589 #endif

   590 

   591 #ifndef SQLITE_API

   592 # define SQLITE_API

   593 #endif

   594 

   595 

   596 /*

   597 ** These no-op macros are used in front of interfaces to mark those

   598 ** interfaces as either deprecated or experimental.  New applications

   599 ** should not use deprecated interfaces - they are support for backwards

   600 ** compatibility only.  Application writers should be aware that

   601 ** experimental interfaces are subject to change in point releases.

   602 **

   603 ** These macros used to resolve to various kinds of compiler magic that

   604 ** would generate warning messages when they were used.  But that

   605 ** compiler magic ended up generating such a flurry of bug reports

   606 ** that we have taken it all out and gone back to using simple

   607 ** noop macros.

   608 */

   609 #define SQLITE_DEPRECATED

   610 #define SQLITE_EXPERIMENTAL

   611 

   612 /*

   613 ** Ensure these symbols were not defined by some previous header file.

   614 */

   615 #ifdef SQLITE_VERSION

   616 # undef SQLITE_VERSION

   617 #endif

   618 #ifdef SQLITE_VERSION_NUMBER

   619 # undef SQLITE_VERSION_NUMBER

   620 #endif

   621 

   622 /*

   623 ** CAPI3REF: Compile-Time Library Version Numbers {H10010} <S60100>

   624 **

   625 ** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in

   626 ** the sqlite3.h file specify the version of SQLite with which

   627 ** that header file is associated.

   628 **

   629 ** The "version" of SQLite is a string of the form "W.X.Y" or "W.X.Y.Z".

   630 ** The W value is major version number and is always 3 in SQLite3.

   631 ** The W value only changes when backwards compatibility is

   632 ** broken and we intend to never break backwards compatibility.

   633 ** The X value is the minor version number and only changes when

   634 ** there are major feature enhancements that are forwards compatible

   635 ** but not backwards compatible.

   636 ** The Y value is the release number and is incremented with

   637 ** each release but resets back to 0 whenever X is incremented.

   638 ** The Z value only appears on branch releases.

   639 **

   640 ** The SQLITE_VERSION_NUMBER is an integer that is computed as

   641 ** follows:

   642 **

   643 ** <blockquote><pre>

   644 ** SQLITE_VERSION_NUMBER = W*1000000 + X*1000 + Y

   645 ** </pre></blockquote>

   646 **

   647 ** Since version 3.6.18, SQLite source code has been stored in the

   648 ** <a href="http://www.fossil-scm.org/">fossil configuration management

   649 ** system</a>.  The SQLITE_SOURCE_ID

   650 ** macro is a string which identifies a particular check-in of SQLite

   651 ** within its configuration management system.  The string contains the

   652 ** date and time of the check-in (UTC) and an SHA1 hash of the entire

   653 ** source tree.

   654 **

   655 ** See also: [sqlite3_libversion()],

   656 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],

   657 ** [sqlite_version()] and [sqlite_source_id()].

   658 **

   659 ** Requirements: [H10011] [H10014]

   660 */

   661 #define SQLITE_VERSION        "3.6.19"

   662 #define SQLITE_VERSION_NUMBER 3006019

   663 #define SQLITE_SOURCE_ID      "2009-10-14 11:33:55 c1d499afc50d54b376945b4efb65c56c787a073d"

   664 

   665 /*

   666 ** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>

   667 ** KEYWORDS: sqlite3_version

   668 **

   669 ** These interfaces provide the same information as the [SQLITE_VERSION],

   670 ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] #defines in the header,

   671 ** but are associated with the library instead of the header file.  Cautious

   672 ** programmers might include assert() statements in their application to

   673 ** verify that values returned by these interfaces match the macros in

   674 ** the header, and thus insure that the application is

   675 ** compiled with matching library and header files.

   676 **

   677 ** <blockquote><pre>

   678 ** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );

   679 ** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );

   680 ** assert( strcmp(sqlite3_libversion,SQLITE_VERSION)==0 );

   681 ** </pre></blockquote>

   682 **

   683 ** The sqlite3_libversion() function returns the same information as is

   684 ** in the sqlite3_version[] string constant.  The function is provided

   685 ** for use in DLLs since DLL users usually do not have direct access to string

   686 ** constants within the DLL.  Similarly, the sqlite3_sourceid() function

   687 ** returns the same information as is in the [SQLITE_SOURCE_ID] #define of

   688 ** the header file.

   689 **

   690 ** See also: [sqlite_version()] and [sqlite_source_id()].

   691 **

   692 ** Requirements: [H10021] [H10022] [H10023]

   693 */

   694 SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;

   695 SQLITE_API const char *sqlite3_libversion(void);

   696 SQLITE_API const char *sqlite3_sourceid(void);

   697 SQLITE_API int sqlite3_libversion_number(void);

   698 

   699 /*

   700 ** CAPI3REF: Test To See If The Library Is Threadsafe {H10100} <S60100>

   701 **

   702 ** SQLite can be compiled with or without mutexes.  When

   703 ** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes

   704 ** are enabled and SQLite is threadsafe.  When the

   705 ** [SQLITE_THREADSAFE] macro is 0, 

   706 ** the mutexes are omitted.  Without the mutexes, it is not safe

   707 ** to use SQLite concurrently from more than one thread.

   708 **

   709 ** Enabling mutexes incurs a measurable performance penalty.

   710 ** So if speed is of utmost importance, it makes sense to disable

   711 ** the mutexes.  But for maximum safety, mutexes should be enabled.

   712 ** The default behavior is for mutexes to be enabled.

   713 **

   714 ** This interface can be used by an application to make sure that the

   715 ** version of SQLite that it is linking against was compiled with

   716 ** the desired setting of the [SQLITE_THREADSAFE] macro.

   717 **

   718 ** This interface only reports on the compile-time mutex setting

   719 ** of the [SQLITE_THREADSAFE] flag.  If SQLite is compiled with

   720 ** SQLITE_THREADSAFE=1 then mutexes are enabled by default but

   721 ** can be fully or partially disabled using a call to [sqlite3_config()]

   722 ** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],

   723 ** or [SQLITE_CONFIG_MUTEX].  The return value of this function shows

   724 ** only the default compile-time setting, not any run-time changes

   725 ** to that setting.

   726 **

   727 ** See the [threading mode] documentation for additional information.

   728 **

   729 ** Requirements: [H10101] [H10102]

   730 */

   731 SQLITE_API int sqlite3_threadsafe(void);

   732 

   733 /*

   734 ** CAPI3REF: Database Connection Handle {H12000} <S40200>

   735 ** KEYWORDS: {database connection} {database connections}

   736 **

   737 ** Each open SQLite database is represented by a pointer to an instance of

   738 ** the opaque structure named "sqlite3".  It is useful to think of an sqlite3

   739 ** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and

   740 ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]

   741 ** is its destructor.  There are many other interfaces (such as

   742 ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and

   743 ** [sqlite3_busy_timeout()] to name but three) that are methods on an

   744 ** sqlite3 object.

   745 */

   746 typedef struct sqlite3 sqlite3;

   747 

   748 /*

   749 ** CAPI3REF: 64-Bit Integer Types {H10200} <S10110>

   750 ** KEYWORDS: sqlite_int64 sqlite_uint64

   751 **

   752 ** Because there is no cross-platform way to specify 64-bit integer types

   753 ** SQLite includes typedefs for 64-bit signed and unsigned integers.

   754 **

   755 ** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.

   756 ** The sqlite_int64 and sqlite_uint64 types are supported for backwards

   757 ** compatibility only.

   758 **

   759 ** Requirements: [H10201] [H10202]

   760 */

   761 #ifdef SQLITE_INT64_TYPE

   762   typedef SQLITE_INT64_TYPE sqlite_int64;

   763   typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;

   764 #elif defined(_MSC_VER) || defined(__BORLANDC__)

   765   typedef __int64 sqlite_int64;

   766   typedef unsigned __int64 sqlite_uint64;

   767 #else

   768   typedef long long int sqlite_int64;

   769   typedef unsigned long long int sqlite_uint64;

   770 #endif

   771 typedef sqlite_int64 sqlite3_int64;

   772 typedef sqlite_uint64 sqlite3_uint64;

   773 

   774 /*

   775 ** If compiling for a processor that lacks floating point support,

   776 ** substitute integer for floating-point.

   777 */

   778 #ifdef SQLITE_OMIT_FLOATING_POINT

   779 # define double sqlite3_int64

   780 #endif

   781 

   782 /*

   783 ** CAPI3REF: Closing A Database Connection {H12010} <S30100><S40200>

   784 **

   785 ** This routine is the destructor for the [sqlite3] object.

   786 **

   787 ** Applications should [sqlite3_finalize | finalize] all [prepared statements]

   788 ** and [sqlite3_blob_close | close] all [BLOB handles] associated with

   789 ** the [sqlite3] object prior to attempting to close the object.

   790 ** The [sqlite3_next_stmt()] interface can be used to locate all

   791 ** [prepared statements] associated with a [database connection] if desired.

   792 ** Typical code might look like this:

   793 **

   794 ** <blockquote><pre>

   795 ** sqlite3_stmt *pStmt;

   796 ** while( (pStmt = sqlite3_next_stmt(db, 0))!=0 ){

   797 **     sqlite3_finalize(pStmt);

   798 ** }

   799 ** </pre></blockquote>

   800 **

   801 ** If [sqlite3_close()] is invoked while a transaction is open,

   802 ** the transaction is automatically rolled back.

   803 **

   804 ** The C parameter to [sqlite3_close(C)] must be either a NULL

   805 ** pointer or an [sqlite3] object pointer obtained

   806 ** from [sqlite3_open()], [sqlite3_open16()], or

   807 ** [sqlite3_open_v2()], and not previously closed.

   808 **

   809 ** Requirements:

   810 ** [H12011] [H12012] [H12013] [H12014] [H12015] [H12019]

   811 */

   812 SQLITE_API int sqlite3_close(sqlite3 *);

   813 

   814 /*

   815 ** The type for a callback function.

   816 ** This is legacy and deprecated.  It is included for historical

   817 ** compatibility and is not documented.

   818 */

   819 typedef int (*sqlite3_callback)(void*,int,char**, char**);

   820 

   821 /*

   822 ** CAPI3REF: One-Step Query Execution Interface {H12100} <S10000>

   823 **

   824 ** The sqlite3_exec() interface is a convenient way of running one or more

   825 ** SQL statements without having to write a lot of C code.  The UTF-8 encoded

   826 ** SQL statements are passed in as the second parameter to sqlite3_exec().

   827 ** The statements are evaluated one by one until either an error or

   828 ** an interrupt is encountered, or until they are all done.  The 3rd parameter

   829 ** is an optional callback that is invoked once for each row of any query

   830 ** results produced by the SQL statements.  The 5th parameter tells where

   831 ** to write any error messages.

   832 **

   833 ** The error message passed back through the 5th parameter is held

   834 ** in memory obtained from [sqlite3_malloc()].  To avoid a memory leak,

   835 ** the calling application should call [sqlite3_free()] on any error

   836 ** message returned through the 5th parameter when it has finished using

   837 ** the error message.

   838 **

   839 ** If the SQL statement in the 2nd parameter is NULL or an empty string

   840 ** or a string containing only whitespace and comments, then no SQL

   841 ** statements are evaluated and the database is not changed.

   842 **

   843 ** The sqlite3_exec() interface is implemented in terms of

   844 ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].

   845 ** The sqlite3_exec() routine does nothing to the database that cannot be done

   846 ** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].

   847 **

   848 ** The first parameter to [sqlite3_exec()] must be an valid and open

   849 ** [database connection].

   850 **

   851 ** The database connection must not be closed while

   852 ** [sqlite3_exec()] is running.

   853 **

   854 ** The calling function should use [sqlite3_free()] to free

   855 ** the memory that *errmsg is left pointing at once the error

   856 ** message is no longer needed.

   857 **

   858 ** The SQL statement text in the 2nd parameter to [sqlite3_exec()]

   859 ** must remain unchanged while [sqlite3_exec()] is running.

   860 **

   861 ** Requirements:

   862 ** [H12101] [H12102] [H12104] [H12105] [H12107] [H12110] [H12113] [H12116]

   863 ** [H12119] [H12122] [H12125] [H12131] [H12134] [H12137] [H12138]

   864 */

   865 SQLITE_API int sqlite3_exec(

   866   sqlite3*,                                  /* An open database */

   867   const char *sql,                           /* SQL to be evaluated */

   868   int (*callback)(void*,int,char**,char**),  /* Callback function */

   869   void *,                                    /* 1st argument to callback */

   870   char **errmsg                              /* Error msg written here */

   871 );

   872 

   873 /*

   874 ** CAPI3REF: Result Codes {H10210} <S10700>

   875 ** KEYWORDS: SQLITE_OK {error code} {error codes}

   876 ** KEYWORDS: {result code} {result codes}

   877 **

   878 ** Many SQLite functions return an integer result code from the set shown

   879 ** here in order to indicates success or failure.

   880 **

   881 ** New error codes may be added in future versions of SQLite.

   882 **

   883 ** See also: [SQLITE_IOERR_READ | extended result codes]

   884 */

   885 #define SQLITE_OK           0   /* Successful result */

   886 /* beginning-of-error-codes */

   887 #define SQLITE_ERROR        1   /* SQL error or missing database */

   888 #define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */

   889 #define SQLITE_PERM         3   /* Access permission denied */

   890 #define SQLITE_ABORT        4   /* Callback routine requested an abort */

   891 #define SQLITE_BUSY         5   /* The database file is locked */

   892 #define SQLITE_LOCKED       6   /* A table in the database is locked */

   893 #define SQLITE_NOMEM        7   /* A malloc() failed */

   894 #define SQLITE_READONLY     8   /* Attempt to write a readonly database */

   895 #define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/

   896 #define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */

   897 #define SQLITE_CORRUPT     11   /* The database disk image is malformed */

   898 #define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */

   899 #define SQLITE_FULL        13   /* Insertion failed because database is full */

   900 #define SQLITE_CANTOPEN    14   /* Unable to open the database file */

   901 #define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */

   902 #define SQLITE_EMPTY       16   /* Database is empty */

   903 #define SQLITE_SCHEMA      17   /* The database schema changed */

   904 #define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */

   905 #define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */

   906 #define SQLITE_MISMATCH    20   /* Data type mismatch */

   907 #define SQLITE_MISUSE      21   /* Library used incorrectly */

   908 #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */

   909 #define SQLITE_AUTH        23   /* Authorization denied */

   910 #define SQLITE_FORMAT      24   /* Auxiliary database format error */

   911 #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */

   912 #define SQLITE_NOTADB      26   /* File opened that is not a database file */

   913 #define SQLITE_ROW         100  /* sqlite3_step() has another row ready */

   914 #define SQLITE_DONE        101  /* sqlite3_step() has finished executing */

   915 /* end-of-error-codes */

   916 

   917 /*

   918 ** CAPI3REF: Extended Result Codes {H10220} <S10700>

   919 ** KEYWORDS: {extended error code} {extended error codes}

   920 ** KEYWORDS: {extended result code} {extended result codes}

   921 **

   922 ** In its default configuration, SQLite API routines return one of 26 integer

   923 ** [SQLITE_OK | result codes].  However, experience has shown that many of

   924 ** these result codes are too coarse-grained.  They do not provide as

   925 ** much information about problems as programmers might like.  In an effort to

   926 ** address this, newer versions of SQLite (version 3.3.8 and later) include

   927 ** support for additional result codes that provide more detailed information

   928 ** about errors. The extended result codes are enabled or disabled

   929 ** on a per database connection basis using the

   930 ** [sqlite3_extended_result_codes()] API.

   931 **

   932 ** Some of the available extended result codes are listed here.

   933 ** One may expect the number of extended result codes will be expand

   934 ** over time.  Software that uses extended result codes should expect

   935 ** to see new result codes in future releases of SQLite.

   936 **

   937 ** The SQLITE_OK result code will never be extended.  It will always

   938 ** be exactly zero.

   939 */

   940 #define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))

   941 #define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))

   942 #define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))

   943 #define SQLITE_IOERR_FSYNC             (SQLITE_IOERR | (4<<8))

   944 #define SQLITE_IOERR_DIR_FSYNC         (SQLITE_IOERR | (5<<8))

   945 #define SQLITE_IOERR_TRUNCATE          (SQLITE_IOERR | (6<<8))

   946 #define SQLITE_IOERR_FSTAT             (SQLITE_IOERR | (7<<8))

   947 #define SQLITE_IOERR_UNLOCK            (SQLITE_IOERR | (8<<8))

   948 #define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))

   949 #define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))

   950 #define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))

   951 #define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))

   952 #define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))

   953 #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))

   954 #define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))

   955 #define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))

   956 #define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))

   957 #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED | (1<<8) )

   958 

   959 /*

   960 ** CAPI3REF: Flags For File Open Operations {H10230} <H11120> <H12700>

   961 **

   962 ** These bit values are intended for use in the

   963 ** 3rd parameter to the [sqlite3_open_v2()] interface and

   964 ** in the 4th parameter to the xOpen method of the

   965 ** [sqlite3_vfs] object.

   966 */

   967 #define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */

   968 #define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */

   969 #define SQLITE_OPEN_CREATE           0x00000004  /* Ok for sqlite3_open_v2() */

   970 #define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */

   971 #define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */

   972 #define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */

   973 #define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */

   974 #define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */

   975 #define SQLITE_OPEN_MAIN_JOURNAL     0x00000800  /* VFS only */

   976 #define SQLITE_OPEN_TEMP_JOURNAL     0x00001000  /* VFS only */

   977 #define SQLITE_OPEN_SUBJOURNAL       0x00002000  /* VFS only */

   978 #define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */

   979 #define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */

   980 #define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */

   981 #define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */

   982 #define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */

   983 

   984 /*

   985 ** CAPI3REF: Device Characteristics {H10240} <H11120>

   986 **

   987 ** The xDeviceCapabilities method of the [sqlite3_io_methods]

   988 ** object returns an integer which is a vector of the these

   989 ** bit values expressing I/O characteristics of the mass storage

   990 ** device that holds the file that the [sqlite3_io_methods]

   991 ** refers to.

   992 **

   993 ** The SQLITE_IOCAP_ATOMIC property means that all writes of

   994 ** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values

   995 ** mean that writes of blocks that are nnn bytes in size and

   996 ** are aligned to an address which is an integer multiple of

   997 ** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means

   998 ** that when data is appended to a file, the data is appended

   999 ** first then the size of the file is extended, never the other

  1000 ** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that

  1001 ** information is written to disk in the same order as calls

  1002 ** to xWrite().

  1003 */

  1004 #define SQLITE_IOCAP_ATOMIC          0x00000001

  1005 #define SQLITE_IOCAP_ATOMIC512       0x00000002

  1006 #define SQLITE_IOCAP_ATOMIC1K        0x00000004

  1007 #define SQLITE_IOCAP_ATOMIC2K        0x00000008

  1008 #define SQLITE_IOCAP_ATOMIC4K        0x00000010

  1009 #define SQLITE_IOCAP_ATOMIC8K        0x00000020

  1010 #define SQLITE_IOCAP_ATOMIC16K       0x00000040

  1011 #define SQLITE_IOCAP_ATOMIC32K       0x00000080

  1012 #define SQLITE_IOCAP_ATOMIC64K       0x00000100

  1013 #define SQLITE_IOCAP_SAFE_APPEND     0x00000200

  1014 #define SQLITE_IOCAP_SEQUENTIAL      0x00000400

  1015 

  1016 /*

  1017 ** CAPI3REF: File Locking Levels {H10250} <H11120> <H11310>

  1018 **

  1019 ** SQLite uses one of these integer values as the second

  1020 ** argument to calls it makes to the xLock() and xUnlock() methods

  1021 ** of an [sqlite3_io_methods] object.

  1022 */

  1023 #define SQLITE_LOCK_NONE          0

  1024 #define SQLITE_LOCK_SHARED        1

  1025 #define SQLITE_LOCK_RESERVED      2

  1026 #define SQLITE_LOCK_PENDING       3

  1027 #define SQLITE_LOCK_EXCLUSIVE     4

  1028 

  1029 /*

  1030 ** CAPI3REF: Synchronization Type Flags {H10260} <H11120>

  1031 **

  1032 ** When SQLite invokes the xSync() method of an

  1033 ** [sqlite3_io_methods] object it uses a combination of

  1034 ** these integer values as the second argument.

  1035 **

  1036 ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the

  1037 ** sync operation only needs to flush data to mass storage.  Inode

  1038 ** information need not be flushed. If the lower four bits of the flag

  1039 ** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.

  1040 ** If the lower four bits equal SQLITE_SYNC_FULL, that means

  1041 ** to use Mac OS X style fullsync instead of fsync().

  1042 */

  1043 #define SQLITE_SYNC_NORMAL        0x00002

  1044 #define SQLITE_SYNC_FULL          0x00003

  1045 #define SQLITE_SYNC_DATAONLY      0x00010

  1046 

  1047 /*

  1048 ** CAPI3REF: OS Interface Open File Handle {H11110} <S20110>

  1049 **

  1050 ** An [sqlite3_file] object represents an open file in the 

  1051 ** [sqlite3_vfs | OS interface layer].  Individual OS interface

  1052 ** implementations will

  1053 ** want to subclass this object by appending additional fields

  1054 ** for their own use.  The pMethods entry is a pointer to an

  1055 ** [sqlite3_io_methods] object that defines methods for performing

  1056 ** I/O operations on the open file.

  1057 */

  1058 typedef struct sqlite3_file sqlite3_file;

  1059 struct sqlite3_file {

  1060   const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */

  1061 };

  1062 

  1063 /*

  1064 ** CAPI3REF: OS Interface File Virtual Methods Object {H11120} <S20110>

  1065 **

  1066 ** Every file opened by the [sqlite3_vfs] xOpen method populates an

  1067 ** [sqlite3_file] object (or, more commonly, a subclass of the

  1068 ** [sqlite3_file] object) with a pointer to an instance of this object.

  1069 ** This object defines the methods used to perform various operations

  1070 ** against the open file represented by the [sqlite3_file] object.

  1071 **

  1072 ** If the xOpen method sets the sqlite3_file.pMethods element 

  1073 ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method

  1074 ** may be invoked even if the xOpen reported that it failed.  The

  1075 ** only way to prevent a call to xClose following a failed xOpen

  1076 ** is for the xOpen to set the sqlite3_file.pMethods element to NULL.

  1077 **

  1078 ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or

  1079 ** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().

  1080 ** The second choice is a Mac OS X style fullsync.  The [SQLITE_SYNC_DATAONLY]

  1081 ** flag may be ORed in to indicate that only the data of the file

  1082 ** and not its inode needs to be synced.

  1083 **

  1084 ** The integer values to xLock() and xUnlock() are one of

  1085 ** <ul>

  1086 ** <li> [SQLITE_LOCK_NONE],

  1087 ** <li> [SQLITE_LOCK_SHARED],

  1088 ** <li> [SQLITE_LOCK_RESERVED],

  1089 ** <li> [SQLITE_LOCK_PENDING], or

  1090 ** <li> [SQLITE_LOCK_EXCLUSIVE].

  1091 ** </ul>

  1092 ** xLock() increases the lock. xUnlock() decreases the lock.

  1093 ** The xCheckReservedLock() method checks whether any database connection,

  1094 ** either in this process or in some other process, is holding a RESERVED,

  1095 ** PENDING, or EXCLUSIVE lock on the file.  It returns true

  1096 ** if such a lock exists and false otherwise.

  1097 **

  1098 ** The xFileControl() method is a generic interface that allows custom

  1099 ** VFS implementations to directly control an open file using the

  1100 ** [sqlite3_file_control()] interface.  The second "op" argument is an

  1101 ** integer opcode.  The third argument is a generic pointer intended to

  1102 ** point to a structure that may contain arguments or space in which to

  1103 ** write return values.  Potential uses for xFileControl() might be

  1104 ** functions to enable blocking locks with timeouts, to change the

  1105 ** locking strategy (for example to use dot-file locks), to inquire

  1106 ** about the status of a lock, or to break stale locks.  The SQLite

  1107 ** core reserves all opcodes less than 100 for its own use.

  1108 ** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.

  1109 ** Applications that define a custom xFileControl method should use opcodes

  1110 ** greater than 100 to avoid conflicts.

  1111 **

  1112 ** The xSectorSize() method returns the sector size of the

  1113 ** device that underlies the file.  The sector size is the

  1114 ** minimum write that can be performed without disturbing

  1115 ** other bytes in the file.  The xDeviceCharacteristics()

  1116 ** method returns a bit vector describing behaviors of the

  1117 ** underlying device:

  1118 **

  1119 ** <ul>

  1120 ** <li> [SQLITE_IOCAP_ATOMIC]

  1121 ** <li> [SQLITE_IOCAP_ATOMIC512]

  1122 ** <li> [SQLITE_IOCAP_ATOMIC1K]

  1123 ** <li> [SQLITE_IOCAP_ATOMIC2K]

  1124 ** <li> [SQLITE_IOCAP_ATOMIC4K]

  1125 ** <li> [SQLITE_IOCAP_ATOMIC8K]

  1126 ** <li> [SQLITE_IOCAP_ATOMIC16K]

  1127 ** <li> [SQLITE_IOCAP_ATOMIC32K]

  1128 ** <li> [SQLITE_IOCAP_ATOMIC64K]

  1129 ** <li> [SQLITE_IOCAP_SAFE_APPEND]

  1130 ** <li> [SQLITE_IOCAP_SEQUENTIAL]

  1131 ** </ul>

  1132 **

  1133 ** The SQLITE_IOCAP_ATOMIC property means that all writes of

  1134 ** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values

  1135 ** mean that writes of blocks that are nnn bytes in size and