These constants are the available integer configuration options that
can be passed as the first argument to the sqlite3_config() interface.

New configuration options may be added in future releases of SQLite.
Existing configuration options might be discontinued. Applications
should check the return code from sqlite3_config() to make sure that
the call worked. The sqlite3_config() interface will return a
non-zero error code if a discontinued or unsupported configuration option
is invoked.

SQLITE_CONFIG_SINGLETHREAD

There are no arguments to this option. R-02748-19096:[This option sets the
threading mode to Single-thread.]
In other words, it disables
all mutexing and puts SQLite into a mode where it can only be used
by a single thread. R-54466-46756:[If SQLite is compiled with
the SQLITE_THREADSAFE=0 compile-time option then
it is not possible to change the threading mode from its default
value of Single-thread and so sqlite3_config() will return
SQLITE_ERROR if called with the SQLITE_CONFIG_SINGLETHREAD
configuration option.]

R-55594-21030:[The SQLITE_CONFIG_MALLOC option takes a single argument which is
a pointer to an instance of the sqlite3_mem_methods structure.
The argument specifies
alternative low-level memory allocation routines to be used in place of
the memory allocation routines built into SQLite.]R-24625-56801:[SQLite makes
its own private copy of the content of the sqlite3_mem_methods structure
before the sqlite3_config() call returns.]

SQLITE_CONFIG_GETMALLOC

R-51213-46414:[The SQLITE_CONFIG_GETMALLOC option takes a single argument which
is a pointer to an instance of the sqlite3_mem_methods structure.
The sqlite3_mem_methods
structure is filled with the currently defined memory allocation routines.]
This option can be used to overload the default memory allocation
routines with a wrapper that simulations memory allocation failure or
tracks memory usage, for example.

SQLITE_CONFIG_MEMSTATUS

R-61275-35157:[The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int,
interpreted as a boolean, which enables or disables the collection of
memory allocation statistics.]R-36322-06257:[When memory allocation statistics are
disabled, the following SQLite interfaces become non-operational:

]R-25715-37072:[Memory allocation statistics are enabled by default unless SQLite is
compiled with SQLITE_DEFAULT_MEMSTATUS=0 in which case memory
allocation statistics are disabled by default.]

SQLITE_CONFIG_SCRATCH

R-21225-56069:[The SQLITE_CONFIG_SCRATCH option specifies a static memory buffer
that SQLite can use for scratch memory.]R-08404-60887:[There are three arguments
to SQLITE_CONFIG_SCRATCH: A pointer an 8-byte
aligned memory buffer from which the scratch allocations will be
drawn, the size of each scratch allocation (sz),
and the maximum number of scratch allocations (N).]
The first argument must be a pointer to an 8-byte aligned buffer
of at least sz*N bytes of memory.
R-12970-05880:[SQLite will not use more than one scratch buffers per thread.]R-28375-38319:[SQLite will never request a scratch buffer that is more than 6
times the database page size.]R-12271-02651:[If SQLite needs needs additional
scratch memory beyond what is provided by this configuration option, then
sqlite3_malloc() will be used to obtain the memory needed.]

R-00896-24328:[The SQLITE_CONFIG_PAGECACHE option specifies a memory pool
that SQLite can use for the database page cache with the default page
cache implementation.]
This configuration option is a no-op if an application-define page
cache implementation is loaded using the SQLITE_CONFIG_PCACHE2.
R-18761-36601:[There are three arguments to SQLITE_CONFIG_PAGECACHE: A pointer to
8-byte aligned memory (pMem), the size of each page cache line (sz),
and the number of cache lines (N).]
The sz argument should be the size of the largest database page
(a power of two between 512 and 65536) plus some extra bytes for each
page header. R-00442-36377:[The number of extra bytes needed by the page header
can be determined using SQLITE_CONFIG_PCACHE_HDRSZ.]R-50503-22862:[It is harmless, apart from the wasted memory,
for the sz parameter to be larger than necessary.]
The pMem
argument must be either a NULL pointer or a pointer to an 8-byte
aligned block of memory of at least sz*N bytes, otherwise
subsequent behavior is undefined.
R-59103-42685:[When pMem is not NULL, SQLite will strive to use the memory provided
to satisfy page cache needs, falling back to sqlite3_malloc() if
a page cache line is larger than sz bytes or if all of the pMem buffer
is exhausted.]R-35105-34724:[If pMem is NULL and N is non-zero, then each database connection
does an initial bulk allocation for page cache memory
from sqlite3_malloc() sufficient for N cache lines if N is positive or
of -1024*N bytes if N is negative, .]R-59294-22119:[If additional
page cache memory is needed beyond what is provided by the initial
allocation, then SQLite goes to sqlite3_malloc() separately for each
additional cache line.]

SQLITE_CONFIG_HEAP

R-17492-23689:[The SQLITE_CONFIG_HEAP option specifies a static memory buffer
that SQLite will use for all of its dynamic memory allocation needs
beyond those provided for by SQLITE_CONFIG_SCRATCH and
SQLITE_CONFIG_PAGECACHE.]R-06626-12911:[The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled
with either SQLITE_ENABLE_MEMSYS3 or SQLITE_ENABLE_MEMSYS5 and returns
SQLITE_ERROR if invoked otherwise.]R-19854-42126:[There are three arguments to SQLITE_CONFIG_HEAP:
An 8-byte aligned pointer to the memory,
the number of bytes in the memory buffer, and the minimum allocation size.]R-49920-60189:[If the first pointer (the memory pointer) is NULL, then SQLite reverts
to using its default memory allocator (the system malloc() implementation),
undoing any prior invocation of SQLITE_CONFIG_MALLOC.]R-61006-08918:[If the
memory pointer is not NULL then the alternative memory
allocator is engaged to handle all of SQLites memory allocation needs.]
The first pointer (the memory pointer) must be aligned to an 8-byte
boundary or subsequent behavior of SQLite will be undefined.
The minimum allocation size is capped at 2**12. Reasonable values
for the minimum allocation size are 2**5 through 2**8.

R-51136-58806:[The SQLITE_CONFIG_GETMUTEX option takes a single argument which
is a pointer to an instance of the sqlite3_mutex_methods structure. The
sqlite3_mutex_methods
structure is filled with the currently defined mutex routines.]
This option can be used to overload the default mutex allocation
routines with a wrapper used to track mutex usage for performance
profiling or testing, for example. R-14450-37597:[If SQLite is compiled with
the SQLITE_THREADSAFE=0 compile-time option then
the entire mutexing subsystem is omitted from the build and hence calls to
sqlite3_config() with the SQLITE_CONFIG_GETMUTEX configuration option will
return SQLITE_ERROR.]

SQLITE_CONFIG_LOOKASIDE

R-03669-30599:[The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine
the default size of lookaside memory on each database connection.
The first argument is the
size of each lookaside buffer slot and the second is the number of
slots allocated to each database connection.]R-16423-47210:[SQLITE_CONFIG_LOOKASIDE
sets the default lookaside size. The SQLITE_DBCONFIG_LOOKASIDE
option to sqlite3_db_config() can be used to change the lookaside
configuration on individual connections.]

R-22035-46182:[The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which
is a pointer to an sqlite3_pcache_methods2 object. SQLite copies of
the current page cache implementation into that object.]

SQLITE_CONFIG_LOG

The SQLITE_CONFIG_LOG option is used to configure the SQLite
global error log.
(R-37795-21752:[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.]R-61189-52809:[If the function pointer is not NULL, it is
invoked by sqlite3_log() to process each logging event.]R-14213-41276:[If the
function pointer is NULL, the sqlite3_log() interface becomes a no-op.]R-42990-60904:[The void pointer that is the second argument to SQLITE_CONFIG_LOG is
passed through as the first parameter to the application-defined logger
function whenever that function is invoked.]R-15331-08345:[The second parameter to
the logger function is a copy of the first parameter to the corresponding
sqlite3_log() call and is intended to be a result code or an
extended result code.]R-18658-48735:[The third parameter passed to the logger is
log message after formatting via sqlite3_snprintf().]
The SQLite logging interface is not reentrant; the logger function
supplied by the application must not invoke any SQLite interface.
In a multi-threaded application, the application-defined logger
function must be threadsafe.

SQLITE_CONFIG_URI

R-25451-61125:[The SQLITE_CONFIG_URI option takes a single argument of type int.
If non-zero, then URI handling is globally enabled. If the parameter is zero,
then URI handling is globally disabled.]R-51689-46548:[If URI handling is globally
enabled, all filenames passed to sqlite3_open(), sqlite3_open_v2(),
sqlite3_open16() or
specified as part of ATTACH commands are interpreted as URIs, regardless
of whether or not the SQLITE_OPEN_URI flag is set when the database
connection is opened.]R-48725-32206:[If it is globally disabled, filenames are
only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
database connection is opened.]R-43642-56306:[By default, URI handling is globally
disabled. The default value may be changed by compiling with the
SQLITE_USE_URI symbol defined.]

SQLITE_CONFIG_COVERING_INDEX_SCAN

R-36592-02772:[The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer
argument which is interpreted as a boolean in order to enable or disable
the use of covering indices for full table scans in the query optimizer.]R-38720-18127:[The default setting is determined
by the SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on"
if that compile-time option is omitted.]
The ability to disable the use of covering indices for full table scans
is because some incorrectly coded legacy applications might malfunction
when the optimization is enabled. Providing the ability to
disable the optimization allows the older, buggy application code to work
without change even with newer versions of SQLite.

SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE

These options are obsolete and should not be used by new code.
They are retained for backwards compatibility but are now no-ops.

SQLITE_CONFIG_SQLLOG

This option is only available if sqlite is compiled with the
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. If the fourth parameter is 0, then the database connection
passed as the second argument has just been opened. The third argument
points to a buffer containing the name of the main database file. If 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. An example of using this
configuration option can be seen in the "test_sqllog.c" source file in
the canonical SQLite source tree.

SQLITE_CONFIG_MMAP_SIZE

R-58063-38258:[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.]R-45910-50363:[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.]R-34993-45031:[The maximum allowed mmap size
will be silently truncated if necessary so that it does not exceed the
compile-time maximum mmap size set by the
SQLITE_MAX_MMAP_SIZE compile-time option.]R-53367-43190:[If either argument to this option is negative, then that argument is
changed to its compile-time default.]

SQLITE_CONFIG_WIN32_HEAPSIZE

R-04780-55815:[The SQLITE_CONFIG_WIN32_HEAPSIZE option is only available if SQLite is
compiled for Windows with the SQLITE_WIN32_MALLOC pre-processor macro
defined.]R-34926-03360:[SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
that specifies the maximum size of the created heap.]

SQLITE_CONFIG_PCACHE_HDRSZ

R-39100-27317:[The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which
is a pointer to an integer and writes into that integer the number of extra
bytes per page required for each page in SQLITE_CONFIG_PAGECACHE.]
The amount of extra space required can change depending on the compiler,
target platform, and SQLite version.

SQLITE_CONFIG_PMASZ

R-02136-28803:[The SQLITE_CONFIG_PMASZ option takes a single parameter which
is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded
sorter to that integer.]
The default minimum PMA Size is set by the
SQLITE_SORTER_PMASZ compile-time option. New threads are launched
to help with sort operations when multithreaded sorting
is enabled (using the PRAGMA threads command) and the amount of content
to be sorted exceeds the page size times the minimum of the
PRAGMA cache_size setting and this value.

SQLITE_CONFIG_STMTJRNL_SPILL

R-61413-50265:[The SQLITE_CONFIG_STMTJRNL_SPILL option takes a single parameter which
becomes the statement journal spill-to-disk threshold.]Statement journals are held in memory until their size (in bytes)
exceeds this threshold, at which point they are written to disk.
Or if the threshold is -1, statement journals are always held
exclusively in memory.
Since many statement journals never become large, setting the spill
threshold to a value such as 64KiB can greatly reduce the amount of
I/O required to support statement rollback.
The default value for this setting is controlled by the
SQLITE_STMTJRNL_SPILL compile-time option.