Bug 874171 - Upgrade SQLite to version 3.7.17 (SQLite changes). r=mak

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

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

*/

#define SQLITE_VERSION        "3.7.16.1"

#define SQLITE_VERSION_NUMBER 3007016

#define SQLITE_SOURCE_ID      "2013-03-29 13:44:34 527231bc67285f01fb18d4451b28f61da3c4e39d"

#define SQLITE_VERSION        "3.7.17"

#define SQLITE_VERSION_NUMBER 3007017

#define SQLITE_SOURCE_ID      "2013-05-20 00:56:22 118a3b35693b134d56ebd780123b7fd6f1497668"

/*

** CAPI3REF: Run-Time Library Version Numbers

#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_NOTICE      27   /* Notifications from sqlite3_log() */

#define SQLITE_WARNING     28   /* Warnings from sqlite3_log() */

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

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

/* end-of-error-codes */

#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))

#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))

#define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))

#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<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_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))

#define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))

#define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))

#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))

#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

/*

** CAPI3REF: Flags For File Open Operations

  void (*xShmBarrier)(sqlite3_file*);

  int (*xShmUnmap)(sqlite3_file*, int deleteFlag);

  /* Methods above are valid for version 2 */

  int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);

  int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p);

  /* Methods above are valid for version 3 */

  /* Additional methods may be added in future releases */

};

** it is able to override built-in [PRAGMA] statements.

**

** <li>[[SQLITE_FCNTL_BUSYHANDLER]]

** ^This file-control may be invoked by SQLite on the database file handle

** ^The [SQLITE_FCNTL_BUSYHANDLER]

** file-control may be invoked by SQLite on the database file handle

** shortly after it is opened in order to provide a custom VFS with access

** to the connections busy-handler callback. The argument is of type (void **)

** - an array of two (void *) values. The first (void *) actually points

** current operation.

**

** <li>[[SQLITE_FCNTL_TEMPFILENAME]]

** ^Application can invoke this file-control to have SQLite generate a

** ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control

** to have SQLite generate a

** temporary filename using the same algorithm that is followed to generate

** temporary filenames for TEMP tables and other internal uses.  The

** argument should be a char** which will be filled with the filename

** written into memory obtained from [sqlite3_malloc()].  The caller should

** invoke [sqlite3_free()] on the result to avoid a memory leak.

**

** <li>[[SQLITE_FCNTL_MMAP_SIZE]]

** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the

** maximum number of bytes that will be used for memory-mapped I/O.

** The argument is a pointer to a value of type sqlite3_int64 that

** is an advisory maximum number of bytes in the file to memory map.  The

** pointer is overwritten with the old value.  The limit is not changed if

** the value originally pointed to is negative, and so the current limit 

** can be queried by passing in a pointer to a negative number.  This

** file-control is used internally to implement [PRAGMA mmap_size].

**

** </ul>

*/

#define SQLITE_FCNTL_LOCKSTATE               1

#define SQLITE_FCNTL_PRAGMA                 14

#define SQLITE_FCNTL_BUSYHANDLER            15

#define SQLITE_FCNTL_TEMPFILENAME           16

#define SQLITE_FCNTL_MMAP_SIZE              18

/*

** CAPI3REF: Mutex Handle

** page cache implementation into that object.)^ </dd>

**

** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>

** <dd> ^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a

** <dd> The SQLITE_CONFIG_LOG option is used to configure the SQLite

** global [error log].

** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a

** function with a call signature of void(*)(void*,int,const char*), 

** and a pointer to void. ^If the function pointer is not NULL, it is

** invoked by [sqlite3_log()] to process each logging event.  ^If the

** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE

** <dd> These options are obsolete and should not be used by new code.

** They are retained for backwards compatibility but are now no-ops.

** </dl>

** </dd>

**

** [[SQLITE_CONFIG_SQLLOG]]

** <dt>SQLITE_CONFIG_SQLLOG

** <dd>This option is only available if sqlite is compiled with the

** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should

** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should

** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int).

** The second should be of type (void*). The callback is invoked by the library

** in three separate circumstances, identified by the value passed as the

** fourth parameter is 1, then the SQL statement that the third parameter

** points to has just been executed. Or, if the fourth parameter is 2, then

** the connection being passed as the second parameter is being closed. The

** third parameter is passed NULL In this case.

** third parameter is passed NULL In this case.  An example of using this

** configuration option can be seen in the "test_sqllog.c" source file in

** the canonical SQLite source tree.</dd>

**

** [[SQLITE_CONFIG_MMAP_SIZE]]

** <dt>SQLITE_CONFIG_MMAP_SIZE

** <dd>SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values

** that are the default mmap size limit (the default setting for

** [PRAGMA mmap_size]) and the maximum allowed mmap size limit.

** The default setting can be overridden by each database connection using

** either the [PRAGMA mmap_size] command, or by using the

** [SQLITE_FCNTL_MMAP_SIZE] file control.  The maximum allowed mmap size

** cannot be changed at run-time.  Nor may the maximum allowed mmap size

** exceed the compile-time maximum mmap size set by the

** [SQLITE_MAX_MMAP_SIZE] compile-time option.  

** If either argument to this option is negative, then that argument is

** changed to its compile-time default.

** </dl>

*/

#define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */

#define SQLITE_CONFIG_GETPCACHE2   19  /* sqlite3_pcache_methods2* */

#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */

#define SQLITE_CONFIG_SQLLOG       21  /* xSqllog, void* */

#define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */

/*

** CAPI3REF: Database Connection Configuration Options

** as each triggered subprogram is entered.  The callbacks for triggers

** contain a UTF-8 SQL comment that identifies the trigger.)^

**

** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit

** the length of [bound parameter] expansion in the output of sqlite3_trace().

**

** ^The callback function registered by sqlite3_profile() is invoked

** as each SQL statement finishes.  ^The profile callback contains

** the original statement text and an estimate of wall-clock time

** <li>

** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it

** always used to do, [sqlite3_step()] will automatically recompile the SQL

** statement and try to run it again.

** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY]

** retries will occur before sqlite3_step() gives up and returns an error.

** </li>

**

** <li>

** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).

**

** ^The third argument is the value to bind to the parameter.

** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16()

** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter

** is ignored and the end result is the same as sqlite3_bind_null().

**

** ^(In those routines that have a fourth argument, its value is the

** number of bytes in the parameter.  To be clear: the value is the

** the content before returning.

**

** The typedef is necessary to work around problems in certain

** C++ compilers.  See ticket #2191.

** C++ compilers.

*/

typedef void (*sqlite3_destructor_type)(void*);

#define SQLITE_STATIC      ((sqlite3_destructor_type)0)

** ^This interface loads an SQLite extension library from the named file.

**

** ^The sqlite3_load_extension() interface attempts to load an

** SQLite extension library contained in the file zFile.

** [SQLite extension] library contained in the file zFile.  If

** the file cannot be loaded directly, attempts are made to load

** with various operating-system specific extensions added.

** So for example, if "samplelib" cannot be loaded, then names like

** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might

** be tried also.

**

** ^The entry point is zProc.

** ^zProc may be 0, in which case the name of the entry point

** defaults to "sqlite3_extension_init".

** ^(zProc may be 0, in which case SQLite will try to come up with an

** entry point name on its own.  It first tries "sqlite3_extension_init".

** If that does not work, it constructs a name "sqlite3_X_init" where the

** X is consists of the lower-case equivalent of all ASCII alphabetic

** characters in the filename from the last "/" to the first following

** "." and omitting any initial "lib".)^

** ^The sqlite3_load_extension() interface returns

** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.

** ^If an error occurs and pzErrMsg is not 0, then the

** CAPI3REF: Enable Or Disable Extension Loading

**

** ^So as not to open security holes in older applications that are

** unprepared to deal with extension loading, and as a means of disabling

** extension loading while evaluating user-entered SQL, the following API

** unprepared to deal with [extension loading], and as a means of disabling

** [extension loading] while evaluating user-entered SQL, the following API

** is provided to turn the [sqlite3_load_extension()] mechanism on and off.

**

** ^Extension loading is off by default. See ticket #1863.

** ^Extension loading is off by default.

** ^Call the sqlite3_enable_load_extension() routine with onoff==1

** to turn extension loading on and call it with onoff==0 to turn

** it back off again.

**

** ^This interface causes the xEntryPoint() function to be invoked for

** each new [database connection] that is created.  The idea here is that

** xEntryPoint() is the entry point for a statically linked SQLite extension

** xEntryPoint() is the entry point for a statically linked [SQLite extension]

** that is to be automatically loaded into all new database connections.

**

** ^(Even though the function prototype shows that xEntryPoint() takes

SQLITE_API int sqlite3_stricmp(const char *, const char *);

SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);

/*

** CAPI3REF: String Globbing

*

** ^The [sqlite3_strglob(P,X)] interface returns zero if string X matches

** the glob pattern P, and it returns non-zero if string X does not match

** the glob pattern P.  ^The definition of glob pattern matching used in

** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the

** SQL dialect used by SQLite.  ^The sqlite3_strglob(P,X) function is case

** sensitive.

**

** Note that this routine returns zero on a match and non-zero if the strings

** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].

*/

SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);

/*

** CAPI3REF: Error Logging Interface

**

** ^The [sqlite3_log()] interface writes a message into the error log

** ^The [sqlite3_log()] interface writes a message into the [error log]

** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].

** ^If logging is enabled, the zFormat string and subsequent arguments are

** used with [sqlite3_snprintf()] to generate the final output string.