Documentation Source Text

     the [SQLITE_ENABLE_DESERIALIZE] compile-time option is used.
<li> Recognize TRUE and FALSE as constants.  (For compatibility, if there
     exist columns named "true" or "false", then the identifiers refer to the
     columns rather than Boolean constants.)
<li> Support operators IS TRUE, IS FALSE, IS NOT TRUE, and IS NOT FALSE.
<li> Added the [SQLITE_DBSTATUS_CACHE_SPILL] option to [sqlite3_db_status()] for
     reporting the number of cache spills that have occurred.
<li> The "alternate-form-2" flag ("!") on the [built-in printf] implementation
     now causes string substitutions to measure the width and precision in
     characters instead of bytes.
<li> If the [xColumn] method in a [virtual table] implementation returns
     an error message using [sqlite3_result_error()] then give that error
     message preference over internally-generated messages.
<li> Added the -A command-line option to the [CLI] to make it easier to manage
     [SQLite Archive files].

<h2> SQL Used To Implement SQLite Archive Operations </h2>

<p>The various SQLite Archive Archive commands are implemented using SQL statements.
Application developers can easily add SQLite Archive Archive reading and writing
support to their own projects by running the appropriate SQL.

<p>To see what SQL statements are used to implement an SQLite Archive
operation, add the --dryrun or -n option.  This causes the SQL to be
displayed but inhibits the execution of the SQL.

<p>The SQL statements used to implement SQLite Archive operations make use of
various [loadable extensions].  These extensions are all available in
the [https://sqlite.org/src|SQLite source tree] in the
[https://sqlite.org/src/file/ext/misc|ext/misc/ subfolder].

sources on the internet.

<p>
Many people associated "open-source" software with software that has
grown organically through contributions from countless individuals.
And, indeed, there is some open-source software that works that way.
But not SQLite.  SQLite uses the the
[https://en.wikipedia.org/wiki/The_Cathedral_and_the_Bazaar|cathedral development philosophy]
not the bazaar approach.  All of the SQLite code has been written
by people who are well known to each other.

<tcl>hd_fragment warrantyoftitle {Warranty of Title}</tcl>

<div class="rightsidebar">
<form method="GET" action="https://www.hwaci.com/cgi-bin/license-step1">

to be false.)^ ^(Values 1, 1.0, 0.1, -0.1 and '1english' are considered to 
be true.)^

<p>Beginning with SQLite 3.23.0 ([dateof:3.23.0]), SQLite recognizes the
identifiers "TRUE" and "FALSE" as boolean literals, if and only if those
identifiers are not already used for some other meaning.  If there already
exists columns or tables or other objects named TRUE or FALSE, then for
the sake of backwards compatibility, the TRUE and FALSE identifiers refer
to those other objects, not to the boolean values.

<p>The boolean identifiers TRUE and FALSE are usually just aliases for
the integer values 1 and 0, respectively.  However, if TRUE or FALSE
occur on the right-hand side of an IS operator, then they form new
unary postfix operators "IS TRUE" and "IS FALSE" which test the boolean
value of the operand on the left.

<h3>Functions</h3>
<p>SQLite supports many [corefunc|simple] and [aggfunc|aggregate]

The first argument is an integer which is the value of the pointer
to the underlying [sqlite3_stmt] object.  This integer can be used
to correlate SQL statement text with the result of a <b>profile</b>
or <b>row</b> callback. The second argument is the
unexpanded text of the SQL statement being run.  By "unexpanded", we
mean that variable substitutions in the text are not expanded into the
variable values.  This is different from the behavior of the "trace"
method which does expand variable substitutions.

<p>Traces for <b>profile</b> invoke the callback with two arguments
as each SQL statement finishes.  The first argument is an integer which
is the value of the underlying [sqlite3_stmt] object.  The second
argument is the approximate run-time for the statement in nanoseconds.
The run-time is the best estimate available depending on the capabilities
of the platform on which the application is running.

like Rust or Go in which it is impossible, or is at least difficult, to make
common programming errors like memory leaks or array overruns.  So the
question often arises as to why SQLite is not coded in a "safe" language.

<ol>
<li><p>
None of the safe programming languages existed for the first 10 years
of SQLite's existence.  SQLite could be recoded in Go or Rust, but doing
so would probably introduce far more bugs than would be fixed, and it
seems also likely to result in slower code.

<li><p>
Safe programming languages solve the easy problems: memory leaks,
use-after-free errors, array overruns, etc.  Safe languages provide
no help beyond ordinary C code in solving the rather more difficult