Index: src/sqlite.h.in
==================================================================
--- src/sqlite.h.in
+++ src/sqlite.h.in
@@ -28,11 +28,11 @@
 ** The name of this file under configuration management is "sqlite.h.in".
 ** The makefile makes some minor changes to this file (such as inserting
 ** the version number) and changes its name to "sqlite3.h" as
 ** part of the build process.
 **
-** @(#) $Id: sqlite.h.in,v 1.317 2008/05/21 15:01:21 shane Exp $
+** @(#) $Id: sqlite.h.in,v 1.318 2008/05/23 17:21:09 shane Exp $
 */
 #ifndef _SQLITE3_H_
 #define _SQLITE3_H_
 #include <stdarg.h>     /* Needed for the definition of va_list */
 
@@ -294,11 +294,11 @@
 **
 ** {F12102} If the S parameter to [sqlite3_exec(D,S,C,A,E)] is NULL then
 **          the actions of the interface shall be the same as if the
 **          S parameter where an empty string.
 **
-** {F12104} The return value of [sqlite3_exec()] shall be SQLITE_OK if all
+** {F12104} The return value of [sqlite3_exec()] shall be [SQLITE_OK] if all
 **          SQL statements run successfully and to completion.
 **
 ** {F12105} The return value of [sqlite3_exec()] shall be an appropriate 
 **          non-zero [error code] if any SQL statement fails.
 **
@@ -770,20 +770,20 @@
 ** to hold the  [sqlite3_file] structure passed as the third 
 ** argument to xOpen.  {END}  The xOpen method does not have to
 ** allocate the structure; it should just fill it in.
 ** 
 ** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] 
-** to test for the existance of a file,
+** to test for the existence of a file,
 ** or [SQLITE_ACCESS_READWRITE] to test to see
 ** if a file is readable and writable, or [SQLITE_ACCESS_READ]
 ** to test to see if a file is at least readable.  {END} The file can be a 
 ** directory.
 ** 
 ** {F11150} SQLite will always allocate at least mxPathname+1 bytes for
 ** the output buffers for xGetTempname and xFullPathname. {F11151} The exact
 ** size of the output buffer is also passed as a parameter to both 
-** methods. {END} If the output buffer is not large enough, SQLITE_CANTOPEN
+** methods. {END} If the output buffer is not large enough, [SQLITE_CANTOPEN]
 ** should be returned. As this is handled as a fatal error by SQLite,
 ** vfs implementations should endeavor to prevent this by setting 
 ** mxPathname to a sufficiently large value.
 ** 
 ** The xRandomness(), xSleep(), and xCurrentTime() interfaces
@@ -826,11 +826,11 @@
 ** CAPI3REF: Flags for the xAccess VFS method {F11190}
 **
 ** {F11191} These integer constants can be used as the third parameter to
 ** the xAccess method of an [sqlite3_vfs] object. {END}  They determine
 ** what kind of permissions the xAccess method is
-** looking for.  {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method
+** looking for.  {F11192} With [SQLITE_ACCESS_EXISTS], the xAccess method
 ** simply checks to see if the file exists. {F11193} With
 ** SQLITE_ACCESS_READWRITE, the xAccess method checks to see
 ** if the file is both readable and writable.  {F11194} With
 ** SQLITE_ACCESS_READ the xAccess method
 ** checks to see if the file is readable.
@@ -982,11 +982,11 @@
 **
 ** LIMITATIONS:
 **
 ** {U12252} If a separate thread makes changes on the same database connection
 **          while [sqlite3_changes()] is running then the value returned
-**          is unpredictable and unmeaningful.
+**          is unpredictable and not meaningful.
 */
 int sqlite3_changes(sqlite3*);
 
 /*
 ** CAPI3REF: Total Number Of Rows Modified {F12260}
@@ -1027,11 +1027,11 @@
 **
 ** LIMITATIONS:
 **
 ** {U12264} If a separate thread makes changes on the same database connection
 **          while [sqlite3_total_changes()] is running then the value 
-**          returned is unpredictable and unmeaningful.
+**          returned is unpredictable and not meaningful.
 */
 int sqlite3_total_changes(sqlite3*);
 
 /*
 ** CAPI3REF: Interrupt A Long-Running Query {F12270}
@@ -1176,19 +1176,19 @@
 **          parameter with a new busy handler identified by the 2nd and 3rd
 **          parameters.
 **
 ** {F12312} The default busy handler for new database connections is NULL.
 **
-** {F12314} When two or more database connection share a common cache,
+** {F12314} When two or more database connection share a [sqlite3_enable_shared_cache | common cache],
 **          the busy handler for the database connection currently using
 **          the cache is invoked when the cache encounters a lock.
 **
 ** {F12316} If a busy handler callback returns zero, then the SQLite
 **          interface that provoked the locking event will return
 **          [SQLITE_BUSY].
 **
-** {F12318} SQLite will invokes the busy handler with two argument which
+** {F12318} SQLite will invokes the busy handler with two arguments which
 **          are a copy of the pointer supplied by the 3rd parameter to
 **          [sqlite3_busy_handler()] and a count of the number of prior
 **          invocations of the busy handler for the same locking event.
 **
 ** LIMITATIONS:
@@ -1290,11 +1290,11 @@
 ** string of its 2nd parameter.  It returns a result table to the
 ** pointer given in its 3rd parameter.
 **
 ** After the calling function has finished using the result, it should 
 ** pass the pointer to the result table to sqlite3_free_table() in order to 
-** release the memory that was malloc-ed.  Because of the way the 
+** release the memory that was malloced.  Because of the way the 
 ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
 ** function must not try to call [sqlite3_free()] directly.  Only 
 ** [sqlite3_free_table()] is able to release the memory properly and safely.
 **
 ** The sqlite3_get_table() interface is implemented as a wrapper around
@@ -1369,11 +1369,11 @@
 ** the zero terminator.  So the longest string that can be completely
 ** written will be n-1 characters.
 **
 ** These routines all implement some additional formatting
 ** options that are useful for constructing SQL statements.
-** All of the usual printf formatting options apply.  In addition, there
+** All of the usual printf() formatting options apply.  In addition, there
 ** is are "%q", "%Q", and "%z" options.
 **
 ** The %q option works like %s in that it substitutes a null-terminated
 ** string from the argument list.  But %q also doubles every '\'' character.
 ** %q is designed for use inside a string literal.  By doubling each '\''
@@ -1456,11 +1456,11 @@
 ** CAPI3REF: Memory Allocation Subsystem {F17300}
 **
 ** The SQLite core  uses these three routines for all of its own
 ** internal memory allocation needs. "Core" in the previous sentence
 ** does not include operating-system specific VFS implementation.  The
-** windows VFS uses native malloc and free for some operations.
+** Windows VFS uses native malloc() and free() for some operations.
 **
 ** The sqlite3_malloc() routine returns a pointer to a block
 ** of memory at least N bytes in length, where N is the parameter.
 ** If sqlite3_malloc() is unable to obtain sufficient free
 ** memory, it returns a NULL pointer.  If the parameter N to
@@ -1514,14 +1514,14 @@
 ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
 ** implementation of these routines to be omitted.  That capability
 ** is no longer provided.  Only built-in memory allocators can be
 ** used.
 **
-** The windows OS interface layer calls
+** The Windows OS interface layer calls
 ** the system malloc() and free() directly when converting
 ** filenames between the UTF-8 encoding used by SQLite
-** and whatever filename encoding is used by the particular windows
+** and whatever filename encoding is used by the particular Windows
 ** installation.  Memory allocation errors are detected, but
 ** they are reported back as [SQLITE_CANTOPEN] or
 ** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
 **
 ** INVARIANTS:
@@ -1554,11 +1554,11 @@
 **           to a block of checked-out memory of at least N bytes in size
 **           that is 8-byte aligned, or a NULL pointer.
 **
 ** {F17321}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first
 **           copies the first K bytes of content from P into the newly allocated
-**           where K is the lessor of N and the size of the buffer P.
+**           where K is the lesser of N and the size of the buffer P.
 **
 ** {F17322}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first
 **           releases the buffer P.
 **
 ** {F17323}  When [sqlite3_realloc(P,N)] returns NULL, the buffer P is
@@ -1593,22 +1593,22 @@
 **          number of bytes of memory currently outstanding 
 **          (malloced but not freed).
 **
 ** {F17373} The [sqlite3_memory_highwater()] routine returns the maximum
 **          value of [sqlite3_memory_used()] 
-**          since the highwater mark was last reset.
+**          since the high-water mark was last reset.
 **
 ** {F17374} The values returned by [sqlite3_memory_used()] and
 **          [sqlite3_memory_highwater()] include any overhead
 **          added by SQLite in its implementation of [sqlite3_malloc()],
 **          but not overhead added by the any underlying system library
 **          routines that [sqlite3_malloc()] may call.
 ** 
-** {F17375} The memory highwater mark is reset to the current value of
+** {F17375} The memory high-water mark is reset to the current value of
 **          [sqlite3_memory_used()] if and only if the parameter to
 **          [sqlite3_memory_highwater()] is true.  The value returned
-**          by [sqlite3_memory_highwater(1)] is the highwater mark
+**          by [sqlite3_memory_highwater(1)] is the high-water mark
 **          prior to the reset.
 */
 sqlite3_int64 sqlite3_memory_used(void);
 sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
 
@@ -1617,11 +1617,11 @@
 **
 ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
 ** select random ROWIDs when inserting new records into a table that
 ** already uses the largest possible ROWID.  The PRNG is also used for
 ** the build-in random() and randomblob() SQL functions.  This interface allows
-** appliations to access the same PRNG for other purposes.
+** applications to access the same PRNG for other purposes.
 **
 ** A call to this routine stores N bytes of randomness into buffer P.
 **
 ** The first time this routine is invoked (either internally or by
 ** the application) the PRNG is seeded using randomness obtained
@@ -1792,11 +1792,11 @@
 ** top-level SQL code.
 **
 ** INVARIANTS:
 **
 ** {F12551} The second parameter to an 
-**          [sqlite3_set_authorizer | authorizer callback is always an integer
+**          [sqlite3_set_authorizer | authorizer callback] is always an integer
 **          [SQLITE_COPY | authorizer code] that specifies what action
 **          is being authorized.
 **
 ** {F12552} The 3rd and 4th parameters to the 
 **          [sqlite3_set_authorizer | authorization callback function]
@@ -1855,11 +1855,11 @@
 **
 ** The callback function registered by sqlite3_trace() is invoked at
 ** various times when an SQL statement is being run by [sqlite3_step()].
 ** The callback returns a UTF-8 rendering of the SQL statement text
 ** as the statement first begins executing.  Additional callbacks occur
-** as each triggersubprogram is entered.  The callbacks for triggers
+** as each triggered subprogram is entered.  The callbacks for triggers
 ** contain a UTF-8 SQL comment that identifies the trigger.
 ** 
 ** 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
@@ -1946,11 +1946,11 @@
 ** {F12915} If a call to [sqlite3_step()] results in fewer than
 **          N opcodes being executed,
 **          then the progress callback is never invoked. {END}
 ** 
 ** {F12916} Every call to [sqlite3_progress_handler()]
-**          overwrites any previously registere progress handler.
+**          overwrites any previously registered progress handler.
 **
 ** {F12917} If the progress handler callback is NULL then no progress
 **          handler is invoked.
 **
 ** {F12918} If the progress callback returns a result other than 0, then
@@ -1983,11 +1983,11 @@
 ** Whether or not an error occurs when it is opened, resources
 ** associated with the [sqlite3*] handle should be released by passing it
 ** to [sqlite3_close()] when it is no longer required.
 **
 ** The [sqlite3_open_v2()] interface works like [sqlite3_open()] 
-** except that it acccepts two additional parameters for additional control
+** except that it accepts two additional parameters for additional control
 ** over the new database connection.  The flags parameter can be
 ** one of:
 **
 ** <ol>
 ** <li>  [SQLITE_OPEN_READONLY]
@@ -2026,11 +2026,11 @@
 ** [sqlite3_vfs] object that defines the operating system 
 ** interface that the new database connection should use.  If the
 ** fourth parameter is a NULL pointer then the default [sqlite3_vfs]
 ** object is used.
 **
-** <b>Note to windows users:</b>  The encoding used for the filename argument
+** <b>Note to Windows users:</b>  The encoding used for the filename argument
 ** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever
 ** codepage is currently defined.  Filenames containing international
 ** characters must be converted to UTF-8 prior to passing them into
 ** [sqlite3_open()] or [sqlite3_open_v2()].
 **
@@ -2086,11 +2086,11 @@
 **          ephemeral, in-memory database is created for the connection.
 **          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required
 **          in sqlite3_open_v2()?</todo>
 **
 ** {F12719} If the filename is NULL or an empty string, then a private,
-**          ephermeral on-disk database will be created.
+**          ephemeral on-disk database will be created.
 **          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required
 **          in sqlite3_open_v2()?</todo>
 **
 ** {F12721} The [database connection] created by 
 **          [sqlite3_open_v2(F,D,G,V)] will use the
@@ -2170,11 +2170,11 @@
 
 /*
 ** CAPI3REF: SQL Statement Object {F13000}
 ** KEYWORDS: {prepared statement} {prepared statements}
 **
-** An instance of this object represent single SQL statements.  This
+** An instance of this object represents a single SQL statement.  This
 ** object is variously known as a "prepared statement" or a 
 ** "compiled SQL statement" or simply as a "statement".
 ** 
 ** The life of a statement object goes something like this:
 **
@@ -2213,11 +2213,11 @@
 **
 ** Run time limits are intended for use in applications that manage
 ** both their own internal database and also databases that are controlled
 ** by untrusted external sources.  An example application might be a
 ** webbrowser that has its own databases for storing history and
-** separate databases controlled by javascript applications downloaded
+** separate databases controlled by JavaScript applications downloaded
 ** off the internet.  The internal databases can be given the
 ** large, default limits.  Databases managed by external sources can
 ** be given much smaller limits designed to prevent a denial of service
 ** attach.  Developers might also want to use the [sqlite3_set_authorizer()]
 ** interface to further control untrusted SQL.  The size of the database
@@ -2230,11 +2230,11 @@
 ** INVARIANTS:
 **
 ** {F12762} A successful call to [sqlite3_limit(D,C,V)] where V is
 **          positive changes the
 **          limit on the size of construct C in [database connection] D
-**          to the lessor of V and the hard upper bound on the size
+**          to the lesser of V and the hard upper bound on the size
 **          of C that is set at compile-time.
 **
 ** {F12766} A successful call to [sqlite3_limit(D,C,V)] where V is negative
 **          leaves the state of [database connection] D unchanged.
 **
@@ -2325,11 +2325,11 @@
 ** performance advantage to be had by passing an nByte parameter that 
 ** is equal to the number of bytes in the input string <i>including</i> 
 ** the nul-terminator bytes.{END}
 **
 ** *pzTail is made to point to the first byte past the end of the
-** first SQL statement in zSql.  These routines only compiles the first
+** first SQL statement in zSql.  These routines only compile the first
 ** statement in zSql, so *pzTail is left pointing to what remains
 ** uncompiled.
 **
 ** *ppStmt is left pointing to a compiled [prepared statement] that can be
 ** executed using [sqlite3_step()].  Or if there is an error, *ppStmt is
@@ -2441,11 +2441,11 @@
 );
 
 /*
 ** CAPIREF: Retrieving Statement SQL {F13100}
 **
-** This intereface can be used to retrieve a saved copy of the original
+** This interface  can be used to retrieve a saved copy of the original
 ** SQL text used to create a [prepared statement].
 **
 ** INVARIANTS:
 **
 ** {F13101} If the [prepared statement] passed as 
@@ -2488,11 +2488,11 @@
 ** sqlite3_value object but no mutex is held for an unprotected
 ** sqlite3_value object.  If SQLite is compiled to be single-threaded
 ** (with SQLITE_THREADSAFE=0 and with [sqlite3_threadsafe()] returning 0)
 ** then there is no distinction between
 ** protected and unprotected sqlite3_value objects and they can be
-** used interchangable.  However, for maximum code portability it
+** used interchangeable.  However, for maximum code portability it
 ** is recommended that applications make the distinction between
 ** between protected and unprotected sqlite3_value objects even if
 ** they are single threaded.
 **
 ** The sqlite3_value objects that are passed as parameters into the
@@ -2553,11 +2553,11 @@
 ** 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 number of <u>bytes</u>
 ** in the value, not the number of characters. 
 ** If the fourth parameter is negative, the length of the string is
-** number of bytes up to the first zero terminator.
+** the number of bytes up to the first zero terminator.
 **
 ** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
 ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
 ** string after SQLite has finished with it. If the fifth argument is
 ** the special value [SQLITE_STATIC], then SQLite assumes that the
@@ -2567,11 +2567,11 @@
 ** the sqlite3_bind_*() routine returns.
 **
 ** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
 ** is filled with zeros.  A zeroblob uses a fixed amount of memory
 ** (just an integer to hold it size) while it is being processed.
-** Zeroblobs are intended to serve as place-holders for BLOBs whose
+** Zeroblobs are intended to serve as placeholders for BLOBs whose
 ** content is later written using 
 ** [sqlite3_blob_open | increment BLOB I/O] routines. A negative
 ** value for the zeroblob results in a zero-length BLOB.
 **
 ** The sqlite3_bind_*() routines must be called after
@@ -2580,11 +2580,11 @@
 ** Bindings are not cleared by the [sqlite3_reset()] routine.
 ** Unbound parameters are interpreted as NULL.
 **
 ** These routines return [SQLITE_OK] on success or an error code if
 ** anything goes wrong.  [SQLITE_RANGE] is returned if the parameter
-** index is out of range.  [SQLITE_NOMEM] is returned if malloc fails.
+** index is out of range.  [SQLITE_NOMEM] is returned if malloc() fails.
 ** [SQLITE_MISUSE] might be returned if these routines are called on a
 ** virtual machine that is the wrong state or which has already been finalized.
 ** Detection of misuse is unreliable.  Applications should not depend
 ** on SQLITE_MISUSE returns.  SQLITE_MISUSE is intended to indicate a
 ** a logic error in the application.  Future versions of SQLite might
@@ -2610,13 +2610,13 @@
 **          the "?" is the leftmost SQL parameter.
 **
 ** {F13515} The index of an "?NNN" SQL parameter is the integer NNN.
 **
 ** {F13518} The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is
-**          the same as the index of leftmost occurances of the same
+**          the same as the index of leftmost occurrences of the same
 **          parameter, or one more than the largest index over all
-**          parameters to the left if this is the first occurrance
+**          parameters to the left if this is the first occurrence
 **          of this parameter, or 1 if this is the leftmost parameter.
 **
 ** {F13521} The [sqlite3_prepare | SQL statement compiler] fail with
 **          an [SQLITE_RANGE] error if the index of an SQL parameter
 **          is less than 1 or greater than SQLITE_MAX_VARIABLE_NUMBER.
@@ -2681,11 +2681,11 @@
 ** CAPI3REF: Number Of SQL Parameters {F13600}
 **
 ** This routine can be used to find the number of SQL parameters
 ** in a prepared statement.  SQL parameters are tokens of the
 ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
-** place-holders for values that are [sqlite3_bind_blob | bound]
+** placeholders for values that are [sqlite3_bind_blob | bound]
 ** to the parameters at a later time.
 **
 ** This routine actually returns the index of the largest parameter.
 ** For all forms except ?NNN, this will correspond to the number of
 ** unique parameters.  If parameters of the ?NNN are used, there may
@@ -2834,23 +2834,23 @@
 **          result set of [prepared statement] S as a
 **          zero-terminated UTF-16 string in the native byte order.
 **
 ** {F13724} The [sqlite3_column_name()] and [sqlite3_column_name16()]
 **          interfaces return a NULL pointer if they are unable to
-**          allocate memory memory to hold there normal return strings.
+**          allocate memory to hold their normal return strings.
 **
 ** {F13725} If the N parameter to [sqlite3_column_name(S,N)] or
 **          [sqlite3_column_name16(S,N)] is out of range, then the
-**          interfaces returns a NULL pointer.
+**          interfaces return a NULL pointer.
 ** 
 ** {F13726} The strings returned by [sqlite3_column_name(S,N)] and
 **          [sqlite3_column_name16(S,N)] are valid until the next
 **          call to either routine with the same S and N parameters
 **          or until [sqlite3_finalize(S)] is called.
 **
 ** {F13727} When a result column of a [SELECT] statement contains
-**          an AS clause, the name of that column is the indentifier
+**          an AS clause, the name of that column is the identifier
 **          to the right of the AS keyword.
 */
 const char *sqlite3_column_name(sqlite3_stmt*, int N);
 const void *sqlite3_column_name16(sqlite3_stmt*, int N);
 
@@ -2896,49 +2896,49 @@
 ** INVARIANTS:
 **
 ** {F13741} The [sqlite3_column_database_name(S,N)] interface returns either
 **          the UTF-8 zero-terminated name of the database from which the 
 **          Nth result column of [prepared statement] S 
-**          is extracted, or NULL if the the Nth column of S is a
+**          is extracted, or NULL if the Nth column of S is a
 **          general expression or if unable to allocate memory
 **          to store the name.
 **          
 ** {F13742} The [sqlite3_column_database_name16(S,N)] interface returns either
 **          the UTF-16 native byte order
 **          zero-terminated name of the database from which the 
 **          Nth result column of [prepared statement] S 
-**          is extracted, or NULL if the the Nth column of S is a
+**          is extracted, or NULL if the Nth column of S is a
 **          general expression or if unable to allocate memory
 **          to store the name.
 **          
 ** {F13743} The [sqlite3_column_table_name(S,N)] interface returns either
 **          the UTF-8 zero-terminated name of the table from which the 
 **          Nth result column of [prepared statement] S 
-**          is extracted, or NULL if the the Nth column of S is a
+**          is extracted, or NULL if the Nth column of S is a
 **          general expression or if unable to allocate memory
 **          to store the name.
 **          
 ** {F13744} The [sqlite3_column_table_name16(S,N)] interface returns either
 **          the UTF-16 native byte order
 **          zero-terminated name of the table from which the 
 **          Nth result column of [prepared statement] S 
-**          is extracted, or NULL if the the Nth column of S is a
+**          is extracted, or NULL if the Nth column of S is a
 **          general expression or if unable to allocate memory
 **          to store the name.
 **          
 ** {F13745} The [sqlite3_column_origin_name(S,N)] interface returns either
 **          the UTF-8 zero-terminated name of the table column from which the 
 **          Nth result column of [prepared statement] S 
-**          is extracted, or NULL if the the Nth column of S is a
+**          is extracted, or NULL if the Nth column of S is a
 **          general expression or if unable to allocate memory
 **          to store the name.
 **          
 ** {F13746} The [sqlite3_column_origin_name16(S,N)] interface returns either
 **          the UTF-16 native byte order
 **          zero-terminated name of the table column from which the 
 **          Nth result column of [prepared statement] S 
-**          is extracted, or NULL if the the Nth column of S is a
+**          is extracted, or NULL if the Nth column of S is a
 **          general expression or if unable to allocate memory
 **          to store the name.
 **          
 ** {F13748} The return values from
 **          [sqlite3_column_database_name|column metadata interfaces]
@@ -3100,11 +3100,11 @@
 **           to return another row of the result set, it returns
 **           [SQLITE_ROW].
 **
 ** {F15308}  If a call to [sqlite3_step(S)] encounters an
 **           [sqlite3_interrupt|interrupt] or a run-time error,
-**           it returns an appropraite error code that is not one of
+**           it returns an appropriate error code that is not one of
 **           [SQLITE_OK], [SQLITE_ROW], or [SQLITE_DONE].
 **
 ** {F15310}  If an [sqlite3_interrupt|interrupt] or run-time error
 **           occurs during a call to [sqlite3_step(S)]
 **           for a [prepared statement] S created using
@@ -3262,11 +3262,11 @@
 ** </table>
 ** </blockquote>
 **
 ** The table above makes reference to standard C library functions atoi()
 ** and atof().  SQLite does not really use these functions.  It has its
-** on equavalent internal routines.  The atoi() and atof() names are
+** own equivalent internal routines.  The atoi() and atof() names are
 ** used in the table for brevity and because they are familiar to most
 ** C programmers.
 **
 ** Note that when type conversions occur, pointers returned by prior
 ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
@@ -3495,15 +3495,15 @@
 ** function or aggregate. A scalar SQL function requires an implementation of
 ** the xFunc callback only, NULL pointers should be passed as the xStep
 ** and xFinal parameters. An aggregate SQL function requires an implementation
 ** of xStep and xFinal and NULL should be passed for xFunc. To delete an
 ** existing SQL function or aggregate, pass NULL for all three function
-** callback.
+** callbacks.
 **
 ** It is permitted to register multiple implementations of the same
 ** functions with the same name but with either differing numbers of
-** arguments or differing perferred text encodings.  SQLite will use
+** arguments or differing preferred text encodings.  SQLite will use
 ** the implementation most closely matches the way in which the
 ** SQL function is used.
 **
 ** INVARIANTS:
 **
@@ -3515,11 +3515,11 @@
 **
 ** {F16106} A successful invocation of
 **          the [sqlite3_create_function(D,X,N,E,...)] interface registers
 **          or replaces callback functions in [database connection] D
 **          used to implement the SQL function named X with N parameters
-**          and having a perferred text encoding of E.
+**          and having a preferred text encoding of E.
 **
 ** {F16109} A successful call to [sqlite3_create_function(D,X,N,E,P,F,S,L)]
 **          replaces the P, F, S, and L values from any prior calls with
 **          the same D, X, N, and E values.
 **
@@ -3641,11 +3641,11 @@
 ** object results in undefined behavior.
 **
 ** These routines work just like the corresponding 
 ** [sqlite3_column_blob | sqlite3_column_* routines] except that 
 ** these routines take a single [protected sqlite3_value] object pointer
-** instead of an [sqlite3_stmt*] pointer and an integer column number.
+** instead of a [sqlite3_stmt*] pointer and an integer column number.
 **
 ** The sqlite3_value_text16() interface extracts a UTF16 string
 ** in the native byte-order of the host machine.  The
 ** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
 ** extract UTF16 strings as big-endian and little-endian respectively.
@@ -3770,11 +3770,11 @@
 ** INVARIANTS:
 **
 ** {F16211} The first invocation of [sqlite3_aggregate_context(C,N)] for
 **          a particular instance of an aggregate function (for a particular
 **          context C) causes SQLite to allocation N bytes of memory,
-**          zero that memory, and return a pointer to the allocationed
+**          zero that memory, and return a pointer to the allocated
 **          memory.
 **
 ** {F16213} If a memory allocation error occurs during
 **          [sqlite3_aggregate_context(C,N)] then the function returns 0.
 **
@@ -3793,11 +3793,11 @@
 /*
 ** CAPI3REF: User Data For Functions {F16240}
 **
 ** The sqlite3_user_data() interface returns a copy of
 ** the pointer that was the pUserData parameter (the 5th parameter)
-** of the the [sqlite3_create_function()]
+** of the [sqlite3_create_function()]
 ** and [sqlite3_create_function16()] routines that originally
 ** registered the application defined function. {END}
 **
 ** This routine must be called from the same thread in which
 ** the application-defined function is running.
@@ -3815,11 +3815,11 @@
 /*
 ** CAPI3REF: Database Connection For Functions {F16250}
 **
 ** The sqlite3_context_db_handle() interface returns a copy of
 ** the pointer to the [database connection] (the 1st parameter)
-** of the the [sqlite3_create_function()]
+** of the [sqlite3_create_function()]
 ** and [sqlite3_create_function16()] routines that originally
 ** registered the application defined function.
 **
 ** INVARIANTS:
 **
@@ -3847,11 +3847,11 @@
 **
 ** The sqlite3_get_auxdata() interface returns a pointer to the meta-data
 ** associated by the sqlite3_set_auxdata() function with the Nth argument
 ** value to the application-defined function.
 ** If no meta-data has been ever been set for the Nth
-** argument of the function, or if the cooresponding function parameter
+** argument of the function, or if the corresponding function parameter
 ** has changed since the meta-data was set, then sqlite3_get_auxdata()
 ** returns a NULL pointer.
 **
 ** The sqlite3_set_auxdata() interface saves the meta-data
 ** pointed to by its 3rd parameter as the meta-data for the N-th
@@ -3941,11 +3941,11 @@
 **
 ** The sqlite3_result_blob() interface sets the result from
 ** an application defined function to be the BLOB whose content is pointed
 ** to by the second parameter and which is N bytes long where N is the
 ** third parameter. 
-** The sqlite3_result_zeroblob() inerfaces set the result of
+** The sqlite3_result_zeroblob() interfaces set the result of
 ** the application defined function to be a BLOB containing all zero
 ** bytes and N bytes in size, where N is the value of the 2nd parameter.
 **
 ** The sqlite3_result_double() interface sets the result from
 ** an application defined function to be a floating point value specified
@@ -4026,11 +4026,11 @@
 ** A [protected sqlite3_value] object may always be used where an
 ** [unprotected sqlite3_value] object is required, so either
 ** kind of [sqlite3_value] object can be used with this interface.
 **
 ** If these routines are called from within the different thread 
-** than the one containing the application-defined function that recieved
+** than the one containing the application-defined function that received
 ** the [sqlite3_context] pointer, the results are undefined.
 **
 ** INVARIANTS:
 **
 ** {F16403} The default return value from any SQL function is NULL.
@@ -4178,11 +4178,11 @@
 ** return negative, zero or positive if
 ** the first string is less than, equal to, or greater than the second
 ** string. i.e. (STRING1 - STRING2).
 **
 ** The sqlite3_create_collation_v2() works like sqlite3_create_collation()
-** excapt that it takes an extra argument which is a destructor for
+** except that it takes an extra argument which is a destructor for
 ** the collation.  The destructor is called when the collation is
 ** destroyed and is passed a copy of the fourth parameter void* pointer
 ** of the sqlite3_create_collation_v2().
 ** Collations are destroyed when
 ** they are overridden by later calls to the collation creation functions
@@ -4374,11 +4374,11 @@
 
 /*
 ** CAPI3REF:  Name Of The Folder Holding Temporary Files {F10310}
 **
 ** If this global variable is made to point to a string which is
-** the name of a folder (a.ka. directory), then all temporary files
+** the name of a folder (a.k.a. directory), then all temporary files
 ** created by SQLite will be placed in that directory.  If this variable
 ** is NULL pointer, then SQLite does a search for an appropriate temporary
 ** file directory.
 **
 ** It is not safe to modify this variable once a database connection
@@ -4389,15 +4389,15 @@
 SQLITE_EXTERN char *sqlite3_temp_directory;
 
 /*
 ** CAPI3REF:  Test To See If The Database Is In Auto-Commit Mode {F12930}
 **
-** The sqlite3_get_autocommit() interfaces returns non-zero or
+** The sqlite3_get_autocommit() interface returns non-zero or
 ** zero if the given database connection is or is not in autocommit mode,
 ** respectively.   Autocommit mode is on
 ** by default.  Autocommit mode is disabled by a [BEGIN] statement.
-** Autocommit mode is reenabled by a [COMMIT] or [ROLLBACK].
+** Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
 **
 ** If certain kinds of errors occur on a statement within a multi-statement
 ** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], 
 ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
 ** transaction might be rolled back automatically.  The only way to
@@ -4633,21 +4633,21 @@
 /*
 ** CAPI3REF:  Attempt To Free Heap Memory {F17340}
 **
 ** The sqlite3_release_memory() interface attempts to
 ** free N bytes of heap memory by deallocating non-essential memory
-** allocations held by the database labrary. {END}  Memory used
+** allocations held by the database library. {END}  Memory used
 ** to cache database pages to improve performance is an example of
 ** non-essential memory.  Sqlite3_release_memory() returns
 ** the number of bytes actually freed, which might be more or less
 ** than the amount requested.
 **
 ** INVARIANTS:
 **
 ** {F17341} The [sqlite3_release_memory(N)] interface attempts to
 **          free N bytes of heap memory by deallocating non-essential
-**          memory allocations held by the database labrary.
+**          memory allocations held by the database library.
 **
 ** {F16342} The [sqlite3_release_memory(N)] returns the number
 **          of bytes actually freed, which might be more or less
 **          than the amount requested.
 */
@@ -4671,11 +4671,11 @@
 ** A negative or zero value for N means that there is no soft heap limit and
 ** [sqlite3_release_memory()] will only be called when memory is exhausted.
 ** The default value for the soft heap limit is zero.
 **
 ** SQLite makes a best effort to honor the soft heap limit.  
-** But if the soft heap limit cannot honored, execution will
+** But if the soft heap limit cannot be honored, execution will
 ** continue without error or notification.  This is why the limit is 
 ** called a "soft" limit.  It is advisory only.
 **
 ** Prior to SQLite version 3.5.0, this routine only constrained the memory
 ** allocated by a single thread - the same thread in which this routine
@@ -4735,11 +4735,11 @@
 ** may be NULL.
 **
 ** Meta information is returned by writing to the memory locations passed as
 ** the 5th and subsequent parameters to this function. Any of these 
 ** arguments may be NULL, in which case the corresponding element of meta 
-** information is ommitted.
+** information is omitted.
 **
 ** <pre>
 ** Parameter     Output Type      Description
 ** -----------------------------------
 **
@@ -4886,11 +4886,11 @@
 **
 ** The interface to the virtual-table mechanism is currently considered
 ** to be experimental.  The interface might change in incompatible ways.
 ** If this is a problem for you, do not use the interface at this time.
 **
-** When the virtual-table mechanism stablizes, we will declare the
+** When the virtual-table mechanism stabilizes, we will declare the
 ** interface fixed, support it indefinitely, and remove this comment.
 */
 
 /*
 ** Structures used by the virtual table interface
@@ -5116,11 +5116,11 @@
 ** This API makes sure a global version of a function with a particular
 ** name and number of parameters exists.  If no such function exists
 ** before this API is called, a new function is created.  The implementation
 ** of the new function always causes an exception to be thrown.  So
 ** the new function is not good for anything by itself.  Its only
-** purpose is to be a place-holder function that can be overloaded
+** purpose is to be a placeholder function that can be overloaded
 ** by virtual tables.
 **
 ** This API should be considered part of the virtual table interface,
 ** which is experimental and subject to change.
 */
@@ -5198,11 +5198,11 @@
 **          success and an appropriate [error code] on failure.
 **
 ** {F17821} If an error occurs during evaluation of [sqlite3_blob_open(D,...)]
 **          then subsequent calls to [sqlite3_errcode(D)],
 **          [sqlite3_errmsg(D)], and [sqlite3_errmsg16(D)] will return
-**          information approprate for that error.
+**          information appropriate for that error.
 */
 int sqlite3_blob_open(
   sqlite3*,
   const char *zDb,
   const char *zTable,
@@ -5302,11 +5302,11 @@
 **          appropriate [error code] or [extended error code].
 **
 ** {F17868} If an error occurs during evaluation of [sqlite3_blob_read(P,...)]
 **          then subsequent calls to [sqlite3_errcode(D)],
 **          [sqlite3_errmsg(D)], and [sqlite3_errmsg16(D)] will return
-**          information approprate for that error, where D is the
+**          information appropriate for that error, where D is the
 **          database handle that was used to open blob handle P.
 */
 int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
 
 /*
@@ -5357,11 +5357,11 @@
 **          appropriate [error code] or [extended error code].
 **
 ** {F17888} If an error occurs during evaluation of [sqlite3_blob_write(D,...)]
 **          then subsequent calls to [sqlite3_errcode(D)],
 **          [sqlite3_errmsg(D)], and [sqlite3_errmsg16(D)] will return
-**          information approprate for that error.
+**          information appropriate for that error.
 */
 int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
 
 /*
 ** CAPI3REF:  Virtual File System Objects {F11200}
@@ -5446,11 +5446,11 @@
 **
 ** The SQLITE_MUTEX_NOOP implementation is a set of routines 
 ** that does no real locking and is appropriate for use in 
 ** a single-threaded application.  The SQLITE_MUTEX_OS2,
 ** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations
-** are appropriate for use on os/2, unix, and windows.
+** are appropriate for use on OS/2, Unix, and Windows.
 ** 
 ** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
 ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
 ** implementation is included with the library.  The
 ** mutex interface routines defined here become external
@@ -5508,11 +5508,11 @@
 ** a static mutex. {END}
 **
 ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
 ** to enter a mutex. {F17024} If another thread is already within the mutex,
 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
-** SQLITE_BUSY. {F17025}  The sqlite3_mutex_try() interface returns SQLITE_OK
+** SQLITE_BUSY. {F17025}  The sqlite3_mutex_try() interface returns [SQLITE_OK]
 ** upon successful entry.  {F17026} Mutexes created using
 ** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
 ** {F17027} In such cases the,
 ** mutex must be exited an equal number of times before another thread
 ** can enter.  {U17028} If the same thread tries to enter any other
@@ -5617,11 +5617,11 @@
 /*
 ** CAPI3REF: Testing Interface {F11400}
 **
 ** The sqlite3_test_control() interface is used to read out internal
 ** state of SQLite and to inject faults into SQLite for testing
-** purposes.  The first parameter a operation code that determines
+** purposes.  The first parameter is an operation code that determines
 ** the number, meaning, and operation of all subsequent parameters.
 **
 ** This interface is not for use by applications.  It exists solely
 ** for verifying the correct operation of the SQLite library.  Depending
 ** on how the SQLite library is compiled, this interface might not exist.
@@ -5637,11 +5637,11 @@
 ** CAPI3REF: Testing Interface Operation Codes {F11410}
 **
 ** These constants are the valid operation code parameters used
 ** as the first argument to [sqlite3_test_control()].
 **
-** These parameters and their meansing are subject to change
+** These parameters and their meanings are subject to change
 ** without notice.  These values are for testing purposes only.
 ** Applications should not use any of these parameters or the
 ** [sqlite3_test_control()] interface.
 */
 #define SQLITE_TESTCTRL_FAULT_CONFIG             1