Documentation Source Text

  the files is globally readable but only writable by the creator.
}

COMPILE_OPTION {SQLITE_DEFAULT_FOREIGN_KEYS=<i>&lt;0 or 1&gt;</i>} {
  This macro determines whether enforcement of
  [foreign key constraints] is enabled or disabled by default for
  new database connections.  Each database connection can always turn
  enforcement of foreign key constraints on and off and run-time using
  the [foreign_keys pragma].  Enforcement of foreign key constraints
  is normally off by default, but if this compile-time parameter is
  set to 1, enforcement of foreign key constraints will be on by default.
}

COMPILE_OPTION {SQLITE_DEFAULT_MMAP_SIZE=<i>N</i>} {
  This macro sets the default limit on the amount of memory that
  will be used for memory-mapped I/O
  for each open database file.  If the <i>N</i>
  is zero, then memory mapped I/O is disabled by default.  This
  compile-time limit and the [SQLITE_MAX_MMAP_SIZE] can be modified
  at start-time using the
  [sqlite3_config]([SQLITE_CONFIG_MMAP_SIZE]) call, or at run-time
  using the [mmap_size pragma].
}

  This macro sets the default page count for the [WAL]
  [checkpointing | automatic checkpointing] feature.  If unspecified,
  the default page count is 1000.
}

COMPILE_OPTION {SQLITE_DEFAULT_WORKER_THREADS=<i>N</i>} {
  This macro sets the default value for
  the [SQLITE_LIMIT_WORKER_THREADS] parameter.  The [SQLITE_LIMIT_WORKER_THREADS]
  parameter sets the maximum number of auxiliary threads that a single
  [prepared statement] will launch to assist it with a query.  If not specified,
  the default maximum is 0.
  The value set here cannot be more than [SQLITE_MAX_WORKER_THREADS].
}

COMPILE_OPTION {SQLITE_DQS=<i>N</i>} {
  This macro determines the default values for

COMPILE_OPTION {SQLITE_MAX_MMAP_SIZE=<i>N</i>} {
  This macro sets a hard upper bound on the amount of address space that
  can be used by any single database for memory-mapped I/O.
  Setting this value to 0 completely disables memory-mapped I/O and
  causes logic associated with memory-mapped I/O to be omitted from the
  build.  This option does change the default memory-mapped I/O address
  space size (set by [SQLITE_DEFAULT_MMAP_SIZE] or
  sqlite3_config([SQLITE_CONFIG_MMAP_SIZE]) or the
  run-time memory-mapped I/O address space size (set by
  sqlite3_file_control([SQLITE_FCNTL_MMAP_SIZE]) or
  [PRAGMA mmap_size]) as long as those other settings are less than the
  maximum value defined here.
}

COMPILE_OPTION {SQLITE_MAX_SCHEMA_RETRY=<i>N</i>} {

  query planner search limit only applies to queries that are deliberately
  crafted to use excess planning time.
}

COMPILE_OPTION {SQLITE_QUERY_PLANNER_LIMIT_INCR=<i>N</i>} {
  The [SQLITE_QUERY_PLANNER_LIMIT] option sets an initial baseline value
  for the maximum number of index-and-constraint combinations that the
  query planner consider.  The baseline query planner limit is increased
  by SQLITE_QUERY_PLANNER_LIMIT_INCR prior to processing each table of a
  join so that each table is guaranteed to be able to propose at least
  some index-and-constraint combinations to the optimizer even if prior
  tables of the join have exhausted the baseline limit.  The default
  value for both this compile-time option and the
  [SQLITE_QUERY_PLANNER_LIMIT] option are set high enough so that they should
  never be reached for real-world queries.

  The default setting is 1.
  Additional information can be found in [tempstore | tempfiles.html].
}

COMPILE_OPTION {SQLITE_TRACE_SIZE_LIMIT=<i>N</i>} {
  If this macro is defined to a positive integer <i>N</i>, then the length of
  strings and BLOB that are expanded into parameters in the output of
  [sqlite3_trace()] is limited to <i>N</i> bytes.
}

COMPILE_OPTION {SQLITE_TRUSTED_SCHEMA=<i>&lt;0 or 1&gt;</i>} {
  This macro determines the default value for the
  [SQLITE_DBCONFIG_TRUSTED_SCHEMA] and [PRAGMA trusted_schema] setting.
  If no alternative is specified, the trusted-schema setting defaults

  the SQLITE_ALLOW_URI_AUTHORITY compile-time option, then the URI is
  converted into a Uniform Naming Convention (UNC) filename and passed
  down to the underlying operating system that way.
  <p>
  Some future versions of SQLite may change to enable this feature
  by default.
}

COMPILE_OPTION {SQLITE_ALLOW_COVERING_INDEX_SCAN=<i>&lt;0 or 1&gt;</i>} {
  This C-preprocess macro determines the default setting of the
  [SQLITE_CONFIG_COVERING_INDEX_SCAN] configuration setting.  It defaults
  to 1 (on) which means that covering indices are used for full table
  scans where possible, in order to reduce I/O and improve performance.
  However, the use of a covering index for a full scan will cause results
  to appear in a different order from legacy, which could cause some
  (incorrectly-coded) legacy applications to break.  Hence, the covering
  index scan option can be disabled at compile-time on systems that what
  to minimize their risk of exposing errors in legacy applications.
}

COMPILE_OPTION {SQLITE_ENABLE_8_3_NAMES=<i>&lt;1 or 2&gt;</i>} {
  If this C-preprocessor macro is defined, then extra code is
  included that allows SQLite to function on a filesystem that
  only support 8+3 filenames.  If the value of this macro is 1,
  then the default behavior is to continue to use long filenames and
  to only use 8+3 filenames if the
  database connection is opened using [URI filenames] with
  the "<tt>8_3_names=1</tt>" query parameter.  If the value of
  this macro is 2, then the use of 8+3 filenames becomes the default
  but may be disabled on using the <tt>8_3_names=0</tt> query parameter.
}

  The SQLITE_ENABLE_API_ARMOR option does not guarantee that all
  illegal API usages will be detected.  Even when
  SQLITE_ENABLE_API_ARMOR is enabled, passing incorrect values
  into the C-language APIs can cause a process crash due to segmentation
  fault or null-pointer deference or other reasons.  The
  SQLITE_ENABLE_API_ARMOR compile-time option is intended as an aid
  for application testing and debugging option.  Applications
  should not depend SQLITE_ENABLE_API_ARMOR for safety.
  SQLITE_ENABLE_API_ARMOR is appropriate as a second line of
  defense against application bugs, but it should not be the only
  defense.  If any SQLite interface returns SQLITE_MISUSE, that
  indicates that the application is using SQLite contrary to
  the spec and that the application contains a bug.  The SQLITE_MISUSE
  return provides the application with the opportunity to respond
  gracefully to that bug, rather than simply crashing the process or

  small updates.  However, few filesystems support this capability
  and the code paths that check for this capability slow down write
  performance on systems that lack atomic write capability, so this
  feature is disabled by default.
}

COMPILE_OPTION {SQLITE_ENABLE_BATCH_ATOMIC_WRITE} {
  This compile-time option enables SQLite to take advantage batch
  atomic write capabilities in the underlying filesystem.  As of
  SQLite version 3.21.0 ([dateof:3.21.0]) this is only supported on
  [https://en.wikipedia.org/wiki/F2FS|F2FS].  However, the interface
  is implemented generically, using [sqlite3_file_control()] with
  [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]
  so the capability can be added to other filesystem times in the
  future.  When this option is enabled, SQLite automatically detects
  that the underlying filesystem supports batch atomic writes, and
  when it does so it avoids writing the [rollback journal] for transaction
  control.  This can make transactions over twice as fast, while
  simultaneously reducing wear on SSD storage devices.
<p>
  Future versions of SQLite might enable the batch-atomic-write

  to omit them.
}

COMPILE_OPTION {SQLITE_ENABLE_EXPLAIN_COMMENTS} {
  This option adds extra logic to SQLite that inserts comment text into the
  output of [EXPLAIN].  These extra comments use extra memory, thus
  making [prepared statements] larger and very slightly slower, and so they are
  turned off by default and in most application.  But some applications, such
  as the [command-line shell] for SQLite, value clarity of EXPLAIN output
  over raw performance and so this compile-time option is available to them.
  The SQLITE_ENABLE_EXPLAIN_COMMENTS compile-time option is also enabled
  automatically if [SQLITE_DEBUG] is enabled.
}


COMPILE_OPTION {SQLITE_ENABLE_FTS3} {
  When this option is defined in the [amalgamation], versions 3 and 4
  of the full-text search engine are added to the build automatically.
}

COMPILE_OPTION {SQLITE_ENABLE_FTS3_PARENTHESIS} {
  This option modifies the query pattern parser in FTS3 such that it
  supports operators AND and NOT (in addition to the usual OR and NEAR)
  and also allows query expressions to contain nested parenthesis.
}

COMPILE_OPTION {SQLITE_ENABLE_FTS3_TOKENIZER} {
  This option enables the two-argument version of the [fts3_tokenizer()]
  interface.  The second argument to fts3_tokenizer() is suppose to be a
  pointer to a function (encoded as a BLOB) that implements an
  application defined tokenizer.  If hostile actors are able to run
  the two-argument version of fts3_tokenizer() with an arbitrary second
  argument, they could use crash or take control of the process.
  <p>
  Because of security concerns, the two-argument fts3_tokenizer() feature
  was disabled beginning with [Version 3.11.0] ([dateof:3.11.0])
  unless this compile-time option is used.
  [Version 3.12.0] ([dateof:3.12.0]) added the
  [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER],1,0) interface
  that activates the two-argument version of [fts3_tokenizer()]
  for a specific [database connection] at run-time.
}

COMPILE_OPTION {SQLITE_ENABLE_FTS4} {
  When this option is defined in the [amalgamation], versions 3 and 4
  of the full-text search engine are added to the build automatically.
}

COMPILE_OPTION {SQLITE_ENABLE_FTS5} {
  When this option is defined in the [amalgamation], versions 5
  of the full-text search engine ([fts5]) is added to the build automatically.
}

COMPILE_OPTION {SQLITE_ENABLE_GEOPOLY} {
  When this option is defined in the [amalgamation], the [Geopoly extension]
  is included in the build.
}

  with SQLite version 3.38.0, those functions are included by default.
  Use the [-DSQLITE_OMIT_JSON] option to omit them.
}

COMPILE_OPTION {SQLITE_ENABLE_LOCKING_STYLE} {
  This option enables additional logic in the OS interface layer for
  Mac OS X. The additional logic attempts to determine the type of the
  underlying filesystem and choose and alternative locking strategy
  that works correctly for that filesystem type. Five locking strategies
  are available:

  <ul>
    <li> POSIX locking style. This is the default locking style and the
         style used by other (non Mac OS X) Unixes. Locks are obtained and
         released using the fcntl() system call.

    <li> AFP locking style. This locking style is used for network file
         systems that use the AFP (Apple Filing Protocol) protocol. Locks
         are obtained by calling the library function _AFPFSSetLock().

    <li> Flock locking style. This is used for file-systems that do not
         support POSIX locking style. Locks are obtained and released using
         the flock() system call.

    <li> Dot-file locking style. This locking style is used when neither
         flock nor POSIX locking styles are supported by the file system.
         Database locks are obtained by creating and entry in the file-system
         at a well-known location relative to the database file (a "dot-file")
         and relinquished by deleting the same file.

    <li> No locking style. If none of the above can be supported, this
         locking style is used. No database locking mechanism is used. When
         this system is used it is not safe for a single database to be
         accessed by multiple clients.

}

COMPILE_OPTION {SQLITE_ENABLE_ORDERED_SET_AGGREGATES} {
  This option enables support for the "WITHIN GROUP ORDER BY"
  ordered-set aggregate syntax. For example:
  <p><pre>
          SELECT percentile_cont(0.75) WITHIN GROUP (ORDER BY x) FROM tab;</pre>
  <p>The above is the SQL-standard way to compute the 75-percentile
  value of a distribution.  The usual way to do this in SQLite is
  as follows:
  <p><pre>
          SELECT percentile_cont(x,0.75) FROM tab;</pre>
  <p>Though simpler, easier to read, and easier to type, this syntax
  is <i>not</i> compliant with standard SQL.  The simpler, non-standard
  syntax is always available in SQLite.  But the SQL-standard compliant

  This option causes the [query planner stability guarantee] (QPSG) to
  be on by default.  Normally the QPSG is off and must be activated
  at run-time using the [SQLITE_DBCONFIG_ENABLE_QPSG] option to the
  [sqlite3_db_config()] interface.
}

COMPILE_OPTION {SQLITE_ENABLE_RBU} {
  Enable the code the implements the [RBU extension].
}

COMPILE_OPTION {SQLITE_ENABLE_RTREE} {
  This option causes SQLite to include support for the
  [rtree | R*Tree index extension].
}

  impact on performance.
}

COMPILE_OPTION {SQLITE_ENABLE_STMT_SCANSTATUS} {
  This option enables the [sqlite3_stmt_scanstatus()] and
  [sqlite3_stmt_scanstatus_v2()] interfaces.  Those
  interfaces are normally omitted from the build
  because they imposes a performance penalty, even on statements that
  do not use the feature.
}

COMPILE_OPTION {SQLITE_ENABLE_STMTVTAB} {
  This compile-time option enables the [SQLITE_STMT virtual table] logic.
}

  continued to be supported through [version 3.29.0] ([dateof:3.29.0])
  but has now become a no-op.
  <p>
}

COMPILE_OPTION {SQLITE_ENABLE_STAT4} {
  This option adds additional logic to the [ANALYZE] command and to
  the [query planner] that can help SQLite to chose a better query plan
  under certain situations.  The [ANALYZE] command is enhanced to collect
  histogram data from all columns of every index and store that data
  in the [sqlite_stat4] table.  The query planner will then use the
  histogram data to help it make better index choices.  The downside of
  this compile-time option is that it violates the
  [query planner stability guarantee] making it more difficult to ensure
  consistent performance in mass-produced applications.

  This option enables the [sqlite3_unlock_notify()] interface and
  its associated functionality.  See the documentation titled
  [Using the SQLite Unlock Notification Feature] for additional
  information.
}

COMPILE_OPTION {SQLITE_INTROSPECTION_PRAGMAS} {
  This option is obsolete.  It used to enable some extra
  some extra PRAGMA statements such as
  [PRAGMA function_list], [PRAGMA module_list], and
  [PRAGMA pragma_list], but those pragmas are now all
  enabled by default.  See [SQLITE_OMIT_INTROSPECTION_PRAGMAS].
}

COMPILE_OPTION {SQLITE_SOUNDEX} {
  This option enables the [soundex() SQL function].
}

COMPILE_OPTION {SQLITE_STRICT_SUBTYPE=1} {
  This option causes [application-defined SQL functions] to raise an SQL
  error if they invoke the [sqlite3_result_subtype()] interface but
  where not registered with the [SQLITE_RESULT_SUBTYPE] property.
  This recommended option helps to identify problems in the
  implementation of application-defined SQL functions early in the
  development cycle.
}

COMPILE_OPTION {SQLITE_USE_ALLOCA} {
  If this option is enabled, then the alloca() memory allocator will be

}

COMPILE_OPTION {SQLITE_HAVE_ZLIB} {
  This option causes some extensions to link against the
  [https://zlib.net|zlib compression library].
  <p>
  This option has no effect on the SQLite core.  It is only used by extensions.
  This is option is necessary for the compression and decompression
  functions that are part of [SQL Archive] support in the
  [command-line shell].
  <p>
  When compiling with this option, it will normally
  be necessary to add a linker option to include the zlib library in the
  build.  Normal this option is "-lz" but might be different on different
  systems.
  <p>
  When building with MSVC on Windows systems, one can put the zlib source
  code in the compat/zlib subdirectory of the source tree and then add
  the USE_ZLIB=1 option to the nmake command to cause the Makefile.msc
  to automatically build and use an appropriate zlib library implementation.
}

COMPILE_OPTION {SQLITE_DISABLE_FTS3_UNICODE} {
  If this C-preprocessor macro is defined, the [unicode61] tokenizer
  in [FTS3] is omitted from the build and is unavailable to
  applications.
}

COMPILE_OPTION {SQLITE_DISABLE_FTS4_DEFERRED} {
  If this C-preprocessor macro disables the "deferred token" optimization
  in [FTS4].  The "deferred token" optimization avoids loading massive
  posting lists for terms that are in most documents of the collection
  and instead simply scans for those tokens in the document source.  [FTS4]
  should get exactly the same answer both with and without this optimization.
}

COMPILE_OPTION {SQLITE_DISABLE_INTRINSIC} {
  This option disables the use of compiler-specific built-in functions
  such as __builtin_bswap32() and __builtin_add_overflow() in GCC and Clang,
  or _byteswap_ulong() and _ReadWriteBarrier() with MSVC.
}

COMPILE_OPTION {SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS} {
  This option disables the collection of the [sqlite3_status()] 
  [SQLITE_STATUS_PAGECACHE_OVERFLOW] and [SQLITE_STATUS_PAGECACHE_SIZE]
  statistics.  Setting this option has been shown to increase performance in
  high concurrency multi-threaded applications.
}
</tcl>

<tcl>

COMPILE_OPTION {SQLITE_OMIT_ATTACH} {
  When this option is defined, the [ATTACH] and [DETACH] commands are
  omitted from the build.
}

COMPILE_OPTION {SQLITE_OMIT_AUTHORIZATION} {
  Defining this option omits the authorization callback feature from the
  library. The [sqlite3_set_authorizer()] API function is not present
  in the library.
}

COMPILE_OPTION {SQLITE_OMIT_AUTOINCREMENT} {
  This option is omits the [AUTOINCREMENT] feature.
  When this is macro is defined, columns declared as
  "[INTEGER PRIMARY KEY] AUTOINCREMENT"
  behave in the same way as columns declared as "[INTEGER PRIMARY KEY]" when a

  See also: [SQLITE_DEFAULT_AUTOMATIC_INDEX].
}

COMPILE_OPTION {SQLITE_OMIT_AUTORESET} {
  By default, the [sqlite3_step()] interface will automatically invoke
  [sqlite3_reset()] to reset the [prepared statement] if necessary.  This
  compile-time option changes that behavior so that [sqlite3_step()] will
  return [SQLITE_MISUSE] if it called again after returning anything other
  than [SQLITE_ROW], [SQLITE_BUSY], or [SQLITE_LOCKED] unless there was an
  intervening call to [sqlite3_reset()].

  In SQLite [version 3.6.23.1] ([dateof:3.6.23.1])
  and earlier, [sqlite3_step()] used to always
  return [SQLITE_MISUSE] if it was invoked again after returning anything
  other than [SQLITE_ROW] without an intervening call to [sqlite3_reset()].
  This caused problems on some poorly written smartphone applications which
  did not correctly handle the [SQLITE_LOCKED] and [SQLITE_BUSY] error
  returns.  Rather than fix the many defective smartphone applications,
  the behavior of SQLite was changed in 3.6.23.2 to automatically reset
  the prepared statement.  But that changed caused issues in other
  improperly implemented applications that were actually looking
  for an [SQLITE_MISUSE] return to terminate their query loops.  (Anytime
  an application gets an SQLITE_MISUSE error code from SQLite, that means the
  application is misusing the SQLite interface and is thus incorrectly
  implemented.)  The SQLITE_OMIT_AUTORESET interface was added to SQLite
  [version 3.7.5] ([dateof:3.7.5]) in an effort to get all of the (broken)
  applications to work again without having to actually fix the applications.
}

  This option is used to omit the [PRAGMA] command
  from the library. Note that it is useful to define the macros that omit
  specific pragmas in addition to this, as they may also remove supporting code
  in other sub-systems. This macro removes the [PRAGMA] command only.
}

COMPILE_OPTION {SQLITE_OMIT_PROGRESS_CALLBACK} {
  This option may be defined to omit the capability to issue "progress"
  callbacks during long-running SQL statements. The
  [sqlite3_progress_handler()]
  API function is not present in the library.

}

COMPILE_OPTION {SQLITE_OMIT_QUICKBALANCE} {
  This option omits an alternative, faster B-Tree balancing routine.
  Using this option makes SQLite slightly smaller at the expense of
  making it run slightly slower.
}

COMPILE_OPTION {SQLITE_OMIT_SHARED_CACHE} {
  This option builds SQLite without support for [shared cache mode].
  The [sqlite3_enable_shared_cache()] is omitted along with a fair
  amount of logic within the B-Tree subsystem associated with shared
  cache management.

  This compile-time option is recommended most applications as it
  results in improved performance and reduced library footprint.
}

COMPILE_OPTION {SQLITE_OMIT_SEH} {
  If defined, Structured Exception Handling (SEH) is disabled on
  Windows builds.  SEH is a Windows-specific technique for catching
  exceptions raised while accessing a memory-mapped file.  SEH is used

  either will result in a parse error.
  This option also disables enforcement of [foreign key constraints],
  since the code that implements triggers and which is omitted by this
  option is also used to implement [foreign key actions].
}

COMPILE_OPTION {SQLITE_OMIT_TRUNCATE_OPTIMIZATION} {
  A default build of SQLite, if a [DELETE] statement has no WHERE clause
  and operates on a table with no triggers, an optimization occurs that
  causes the DELETE to occur by dropping and recreating the table.
  Dropping and recreating a table is usually much faster than deleting
  the table content row by row.  This is the "truncate optimization".
}

COMPILE_OPTION {SQLITE_OMIT_UTF16} {
  This macro is used to omit support for UTF16 text encoding. When this is
  defined all API functions that return or accept UTF16 encoded text are
  unavailable. These functions can be identified by the fact that they end
  with '16', for example [sqlite3_prepare16()], [sqlite3_column_text16()] and