Bug 630539 - Upgrade to SQLite 3.7.5

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

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

*/

#define SQLITE_VERSION        "3.7.4"

#define SQLITE_VERSION_NUMBER 3007004

#define SQLITE_SOURCE_ID      "2010-12-07 20:14:09 a586a4deeb25330037a49df295b36aaf624d0f45"

#define SQLITE_VERSION        "3.7.5"

#define SQLITE_VERSION_NUMBER 3007005

#define SQLITE_SOURCE_ID      "2011-01-28 17:03:50 ed759d5a9edb3bba5f48f243df47be29e3fe8cd7"

/*

** CAPI3REF: Run-Time Library Version Numbers

#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   /* NOT USED. Table or record not found */

#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 */

** 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.

** 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

** for the nominated database. Allocating database file space in large

** chunks (say 1MB at a time), may reduce file-system fragmentation and

** improve performance on some systems.

**

** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer

** to the [sqlite3_file] object associated with a particular database

** connection.  See the [sqlite3_file_control()] documentation for

** additional information.

**

** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by

** SQLite and sent to all VFSes in place of a call to the xSync method

** when the database connection has [PRAGMA synchronous] set to OFF.)^

** Some specialized VFSes need this signal in order to operate correctly

** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most 

** VFSes do not need this signal and should silently ignore this opcode.

** Applications should not call [sqlite3_file_control()] with this

** opcode as doing so may disrupt the operation of the specilized VFSes

** that do require it.  

*/

#define SQLITE_FCNTL_LOCKSTATE        1

#define SQLITE_GET_LOCKPROXYFILE      2

#define SQLITE_FCNTL_SIZE_HINT        5

#define SQLITE_FCNTL_CHUNK_SIZE       6

#define SQLITE_FCNTL_FILE_POINTER     7

#define SQLITE_FCNTL_SYNC_OMITTED     8

/*

** NULL pointer if [sqlite3_malloc()] is unable to allocate enough

** memory to hold the resulting string.

**

** ^(In sqlite3_snprintf() routine is similar to "snprintf()" from

** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from

** the standard C library.  The result is written into the

** buffer supplied as the second parameter whose size is given by

** the first parameter. Note that the order of the

** the zero terminator.  So the longest string that can be completely

** written will be n-1 characters.

**

** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().

**

** These routines all implement some additional formatting

** options that are useful for constructing SQL statements.

** All of the usual printf() formatting options apply.  In addition, there

SQLITE_API char *sqlite3_mprintf(const char*,...);

SQLITE_API char *sqlite3_vmprintf(const char*, va_list);

SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);

SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);

/*

** CAPI3REF: Memory Allocation Subsystem

** case the database must already exist, otherwise an error is returned.</dd>)^

**

** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>

** <dd>The database is opened for reading and writing, and is creates it if

** <dd>The database is opened for reading and writing, and is created if

** it does not already exist. This is the behavior that is always used for

** sqlite3_open() and sqlite3_open16().</dd>)^

** </dl>

** CAPI3REF: Determine If An SQL Statement Writes The Database

**

** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if 

** the [prepared statement] X is [SELECT] statement and false (zero) if

** X is an [INSERT], [UPDATE], [DELETE], CREATE, DROP, [ANALYZE],

** [ALTER], or [REINDEX] statement.

** If X is a NULL pointer or any other kind of statement, including but

** not limited to [ATTACH], [DETACH], [COMMIT], [ROLLBACK], [RELEASE],

** [SAVEPOINT], [PRAGMA], or [VACUUM] the result of sqlite3_stmt_readonly(X) is

** undefined.

** and only if the [prepared statement] X makes no direct changes to

** the content of the database file.

**

** Note that [application-defined SQL functions] or

** [virtual tables] might change the database indirectly as a side effect.  

** ^(For example, if an application defines a function "eval()" that 

** calls [sqlite3_exec()], then the following SQL statement would

** change the database file through side-effects:

**

** <blockquote><pre>

**    SELECT eval('DELETE FROM t1') FROM t2;

** </pre></blockquote>

**

** But because the [SELECT] statement does not change the database file

** directly, sqlite3_stmt_readonly() would still return true.)^

**

** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],

** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true,

** since the statements themselves do not actually modify the database but

** rather they control the timing of when other statements modify the 

** database.  ^The [ATTACH] and [DETACH] statements also cause

** sqlite3_stmt_readonly() to return true since, while those statements

** change the configuration of a database connection, they do not make 

** changes to the content of the database files on disk.

*/

SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

** be the case that the same database connection is being used by two or

** more threads at the same moment in time.

**

** For all versions of SQLite up to and including 3.6.23.1, it was required

** after sqlite3_step() returned anything other than [SQLITE_ROW] that

** [sqlite3_reset()] be called before any subsequent invocation of

** sqlite3_step().  Failure to invoke [sqlite3_reset()] in this way would

** result in an [SQLITE_MISUSE] return from sqlite3_step().  But after

** version 3.6.23.1, sqlite3_step() began calling [sqlite3_reset()] 

** automatically in this circumstance rather than returning [SQLITE_MISUSE].  

** For all versions of SQLite up to and including 3.6.23.1, a call to

** [sqlite3_reset()] was required after sqlite3_step() returned anything

** other than [SQLITE_ROW] before any subsequent invocation of

** sqlite3_step().  Failure to reset the prepared statement using 

** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from

** sqlite3_step().  But after version 3.6.23.1, sqlite3_step() began

** calling [sqlite3_reset()] automatically in this circumstance rather

** than returning [SQLITE_MISUSE].  This is not considered a compatibility

** break because any application that ever receives an SQLITE_MISUSE error

** is broken by definition.  The [SQLITE_OMIT_AUTORESET] compile-time option

** can be used to restore the legacy behavior.

**

** <b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step()

** API always returns a generic error code, [SQLITE_ERROR], following any

** ^(The fifth parameter is an arbitrary pointer.  The implementation of the

** function can gain access to this pointer using [sqlite3_user_data()].)^

**

** ^The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are

** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are

** pointers to C-language functions that implement the SQL function or

** aggregate. ^A scalar SQL function requires an implementation of the xFunc

** callback only; NULL pointers must be passed as the xStep and xFinal

** SQL function or aggregate, pass NULL poiners for all three function

** callbacks.

**

** ^(If the tenth parameter to sqlite3_create_function_v2() is not NULL,

** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,

** then it is destructor for the application data pointer. 

** The destructor is invoked when the function is deleted, either by being

** overloaded or when the database connection closes.)^

** The xFunc (for scalar functions) or xStep (for aggregates) parameters

** to [sqlite3_create_function()] and [sqlite3_create_function16()]

** define callbacks that implement the SQL functions and aggregates.

** The 4th parameter to these callbacks is an array of pointers to

** The 3rd parameter to these callbacks is an array of pointers to

** [protected sqlite3_value] objects.  There is one [sqlite3_value] object for

** each parameter to the SQL function.  These routines are used to

** extract values from the [sqlite3_value] objects.

#define SQLITE_MUTEX_STATIC_OPEN      4  /* sqlite3BtreeOpen() */

#define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */

#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */

#define SQLITE_MUTEX_STATIC_LRU2      7  /* lru page list */

#define SQLITE_MUTEX_STATIC_LRU2      7  /* NOT USED */

#define SQLITE_MUTEX_STATIC_PMEM      7  /* sqlite3PageMalloc() */

/*

** CAPI3REF: Retrieve the mutex for a database connection

** The value written into the *pCurrent parameter is undefined.</dd>)^

**

** ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>

** <dd>This parameter records the number of separate memory allocations.</dd>)^

** <dd>This parameter records the number of separate memory allocations

** currently checked out.</dd>)^

**

** ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>

** <dd>This parameter returns the number of pages used out of the

** <dd>This parameter returns the number of lookaside memory slots currently

** checked out.</dd>)^

**

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>

** <dd>This parameter returns the number malloc attempts that were 

** satisfied using lookaside memory. Only the high-water value is meaningful;

** the current value is always zero.

** checked out.</dd>)^

**

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>

** <dd>This parameter returns the number malloc attempts that might have

** been satisfied using lookaside memory but failed due to the amount of

** memory requested being larger than the lookaside slot size.

** Only the high-water value is meaningful;

** the current value is always zero.

** checked out.</dd>)^

**

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>

** <dd>This parameter returns the number malloc attempts that might have

** been satisfied using lookaside memory but failed due to all lookaside

** memory already being in use.

** Only the high-water value is meaningful;

** the current value is always zero.

** checked out.</dd>)^

**

** ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>

** <dd>This parameter returns the approximate number of of bytes of heap

** memory used by all pager caches associated with the database connection.)^

#define SQLITE_DBSTATUS_CACHE_USED           1

#define SQLITE_DBSTATUS_SCHEMA_USED          2

#define SQLITE_DBSTATUS_STMT_USED            3

#define SQLITE_DBSTATUS_MAX                3   /* Largest defined DBSTATUS */

#define SQLITE_DBSTATUS_LOOKASIDE_HIT        4

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE  5

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL  6

#define SQLITE_DBSTATUS_MAX                  6   /* Largest defined DBSTATUS */

/*

** first parameter, szPage, is the size in bytes of the pages that must

** be allocated by the cache.  ^szPage will not be a power of two.  ^szPage

** will the page size of the database file that is to be cached plus an

** increment (here called "R") of about 100 or 200.  SQLite will use the

** increment (here called "R") of less than 250.  SQLite will use the

** extra R bytes on each page to store metadata about the underlying

** database page on disk.  The value of R depends

** on the SQLite version, the target platform, and how SQLite was compiled.

** ^R is constant for a particular build of SQLite.  ^The second argument to

** ^(R is constant for a particular build of SQLite. Except, there are two

** distinct values of R when SQLite is compiled with the proprietary

** ZIPVFS extension.)^  ^The second argument to

** xCreate(), bPurgeable, is true if the cache being created will

** be used to cache database pages of a file stored on disk, or

** false if it is used for an in-memory database. The cache implementation

** If the requested page is already in the page cache, then the page cache

** implementation must return a pointer to the page buffer with its content

** intact.  If the requested page is not already in the cache, then the

** behavior of the cache implementation should use the value of the createFlag

** cache implementation should use the value of the createFlag

** parameter to help it determined what action to take:

**

** <table border=1 width=85% align=center>

**

** See Also: [Using the SQLite Online Backup API]

**

** ^Exclusive access is required to the destination database for the 

** duration of the operation. ^However the source database is only

** read-locked while it is actually being read; it is not locked

** continuously for the entire backup operation. ^Thus, the backup may be

** performed on a live source database without preventing other users from

** ^SQLite holds a write transaction open on the destination database file

** for the duration of the backup operation.

** ^The source database is read-locked only while it is being read;

** it is not locked continuously for the entire backup operation.

** ^Thus, the backup may be performed on a live source database without

** preventing other database connections from

** reading or writing to the source database while the backup is underway.

** 

** ^(To perform a backup operation: 

** sqlite3_backup_init(D,N,S,M) identify the [database connection]

** and database name of the source database, respectively.

** ^The source and destination [database connections] (parameters S and D)

** must be different or else sqlite3_backup_init(D,N,S,M) will file with

** must be different or else sqlite3_backup_init(D,N,S,M) will fail with

** an error.

**

** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is

** returned and an error code and error message are store3d in the

** returned and an error code and error message are stored in the

** destination [database connection] D.

** ^The error code and message for the failed call to sqlite3_backup_init()

** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or

** the source and destination databases specified by [sqlite3_backup] object B.

** ^If N is negative, all remaining source pages are copied. 

** ^If sqlite3_backup_step(B,N) successfully copies N pages and there

** are still more pages to be copied, then the function resturns [SQLITE_OK].

** are still more pages to be copied, then the function returns [SQLITE_OK].

** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages

** from source to destination, then it returns [SQLITE_DONE].

** ^If an error occurs while running sqlite3_backup_step(B,N),

** <li> the destination database was opened read-only, or

** <li> the destination database is using write-ahead-log journaling

** and the destination and source page sizes differ, or

** <li> The destination database is an in-memory database and the

** <li> the destination database is an in-memory database and the

** destination and source page sizes differ.

** </ol>)^

**

** from SQL.

**

** ^Every new [database connection] defaults to having the auto-checkpoint

** enabled with a threshold of 1000 pages.  The use of this interface

** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT]

** pages.  The use of this interface

** is only necessary if the default setting is found to be suboptimal

** for a particular application.

*/