Bug 1328161 - Upgrade to SQLite 3.16.2. r=mak

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

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

*/

#define SQLITE_VERSION        "3.15.2"

#define SQLITE_VERSION_NUMBER 3015002

#define SQLITE_SOURCE_ID      "2016-11-28 19:13:37 bbd85d235f7037c6a033a9690534391ffeacecc8"

#define SQLITE_VERSION        "3.16.2"

#define SQLITE_VERSION_NUMBER 3016002

#define SQLITE_SOURCE_ID      "2017-01-06 16:32:41 a65a62893ca8319e89e48b8a38cf8a59c69a8209"

/*

** CAPI3REF: Run-Time Library Version Numbers

** KEYWORDS: sqlite3_version, sqlite3_sourceid

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

#define SQLITE_FCNTL_VFS_POINTER            27

#define SQLITE_FCNTL_JOURNAL_POINTER        28

#define SQLITE_FCNTL_WIN32_GET_HANDLE       29

#define SQLITE_FCNTL_PDB                    30

/* deprecated names */

#define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE

** until after the database connection closes.

** </dd>

**

** <dt>SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE</dt>

** <dd> Usually, when a database in wal mode is closed or detached from a 

** database handle, SQLite checks if this will mean that there are now no 

** connections at all to the database. If so, it performs a checkpoint 

** operation before closing the connection. This option may be used to

** override this behaviour. The first parameter passed to this operation

** is an integer - non-zero to disable checkpoints-on-close, or zero (the

** default) to enable them. The second parameter is a pointer to an integer

** into which is written 0 or 1 to indicate whether checkpoints-on-close

** have been disabled - 0 if they are not disabled, 1 if they are.

** </dd>

**

** </dl>

*/

#define SQLITE_DBCONFIG_MAINDBNAME            1000 /* const char* */

#define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003 /* int int* */

#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */

#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */

#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006 /* int int* */

/*

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

** ^The sqlite3_stmt_readonly() interface returns true for [BEGIN] since

** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and

** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so

** sqlite3_stmt_readonly() returns false for those commands.

*/

SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

** METHOD: sqlite3_stmt

**

** ^Return the number of columns in the result set returned by the

** [prepared statement]. ^This routine returns 0 if pStmt is an SQL

** statement that does not return data (for example an [UPDATE]).

** [prepared statement]. ^If this routine returns 0, that means the 

** [prepared statement] returns no data (for example an [UPDATE]).

** ^However, just because this routine returns a positive number does not

** mean that one or more rows of data will be returned.  ^A SELECT statement

** will always have a positive sqlite3_column_count() but depending on the

** WHERE clause constraints and the table content, it might return no rows.

**

** See also: [sqlite3_data_count()]

*/

**

** See also:  [sqlite3_update_hook()]

*/

SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_preupdate_hook(

#if defined(SQLITE_ENABLE_PREUPDATE_HOOK)

SQLITE_API void *sqlite3_preupdate_hook(

  sqlite3 *db,

  void(*xPreUpdate)(

    void *pCtx,                   /* Copy of third arg to preupdate_hook() */

  ),

  void*

);

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_preupdate_count(sqlite3 *);

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_preupdate_depth(sqlite3 *);

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);

SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);

SQLITE_API int sqlite3_preupdate_count(sqlite3 *);

SQLITE_API int sqlite3_preupdate_depth(sqlite3 *);

SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);

#endif

/*

** CAPI3REF: Low-level system error code

/*

** CAPI3REF: Database Snapshot

** KEYWORDS: {snapshot}

** KEYWORDS: {snapshot} {sqlite3_snapshot}

** EXPERIMENTAL

**

** An instance of the snapshot object records the state of a [WAL mode]

** to an historical snapshot (if possible).  The destructor for 

** sqlite3_snapshot objects is [sqlite3_snapshot_free()].

*/

typedef struct sqlite3_snapshot sqlite3_snapshot;

typedef struct sqlite3_snapshot {

  unsigned char hidden[48];

} sqlite3_snapshot;

/*

** CAPI3REF: Record A Database Snapshot

** schema S in database connection D.  ^On success, the

** [sqlite3_snapshot_get(D,S,P)] interface writes a pointer to the newly

** created [sqlite3_snapshot] object into *P and returns SQLITE_OK.

** ^If schema S of [database connection] D is not a [WAL mode] database

** that is in a read transaction, then [sqlite3_snapshot_get(D,S,P)]

** leaves the *P value unchanged and returns an appropriate [error code].

** If there is not already a read-transaction open on schema S when

** this function is called, one is opened automatically. 

**

** The following must be true for this function to succeed. If any of

** the following statements are false when sqlite3_snapshot_get() is

** called, SQLITE_ERROR is returned. The final value of *P is undefined

** in this case. 

**

** <ul>

**   <li> The database handle must be in [autocommit mode].

**

**   <li> Schema S of [database connection] D must be a [WAL mode] database.

**

**   <li> There must not be a write transaction open on schema S of database

**        connection D.

**

**   <li> One or more transactions must have been written to the current wal

**        file since it was created on disk (by any connection). This means

**        that a snapshot cannot be taken on a wal mode database with no wal 

**        file immediately after it is first opened. At least one transaction

**        must be written to it first.

** </ul>

**

** This function may also return SQLITE_NOMEM.  If it is called with the

** database handle in autocommit mode but fails for some other reason, 

** whether or not a read transaction is opened on schema S is undefined.

**

** The [sqlite3_snapshot] object returned from a successful call to

** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()]

  sqlite3_snapshot *p2

);

/*

** CAPI3REF: Recover snapshots from a wal file

** EXPERIMENTAL

**

** If all connections disconnect from a database file but do not perform

** a checkpoint, the existing wal file is opened along with the database

** file the next time the database is opened. At this point it is only

** possible to successfully call sqlite3_snapshot_open() to open the most

** recent snapshot of the database (the one at the head of the wal file),

** even though the wal file may contain other valid snapshots for which

** clients have sqlite3_snapshot handles.

**

** This function attempts to scan the wal file associated with database zDb

** of database handle db and make all valid snapshots available to

** sqlite3_snapshot_open(). It is an error if there is already a read

** transaction open on the database, or if the database is not a wal mode

** database.

**

** SQLITE_OK is returned if successful, or an SQLite error code otherwise.

*/

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);

/*

** Undo the hack that converts floating point types to integer for

** builds on processors without floating point support.

GCONF_VERSION=1.2.1

STARTUP_NOTIFICATION_VERSION=0.8

DBUS_VERSION=0.60

SQLITE_VERSION=3.15.2

SQLITE_VERSION=3.16.2

dnl Set various checks

dnl ========================================================