SQLite Changelog

New in version

February 26th, 2015
  • The patch release fixes an obscure problem in the SQLite code generator that can cause incorrect results when the qualifying expression of a partial index is used inside the ON clause of a LEFT JOIN. This problem has been in the code since support for partial indexes was first added in version 3.8.0. However, it is difficult to imagine a valid reason to every put the qualifying constraint inside the ON clause of a LEFT JOIN, and so this issue has never come up before.

New in version (January 31st, 2015)

  • The patch release fixes a single minor problem: It ensures that the sqlite3_wal_checkpoint(TRUNCATE) operation will always truncate the write-ahead log even if log had already been reset and contained no new content. It is unclear if this is a bug fix or a new feature.
  • Something like this would normally go into the next regularly scheduled release, but a prominent SQLite user needed the change in a hurry so we were happy to rush it out via this patch.
  • There is no reason to upgrade unless you actually need the enhanced behavior of sqlite3_wal_checkpoint(TRUNCATE).

New in version (January 21st, 2015)

  • Fix a bug in the sorting logic, present since version 3.8.4, that can cause output to appear in the wrong order on queries that contains an ORDER BY clause, a LIMIT clause, and that have approximately 60 or more columns in the result set. Ticket f97c4637102a3ae72b79.
  • SQLITE_SOURCE_ID: "2015-01-20 16:51:25 f73337e3e289915a76ca96e7a05a1a8d4e890d55"
  • SHA1 for sqlite3.c: 33987fb50dcc09f1429a653d6b47672f5a96f19e

New in version 3.8.8 (January 18th, 2015)

  • New Features:
  • Added the PRAGMA data_version command that can be used to determine if a database file has been modified by another process.
  • Added the SQLITE_CHECKPOINT_TRUNCATE option to the sqlite3_wal_checkpoint_v2() interface, with corresponding enhancements to PRAGMA wal_checkpoint.
  • Added the sqlite3_stmt_scanstatus() interface, available only when compiled with SQLITE_ENABLE_STMT_SCANSTATUS.
  • The sqlite3_table_column_metadata() is enhanced to work correctly on WITHOUT ROWID tables and to check for the existence of a a table if the column name parameter is NULL. The interface is now also included in the build by default, without requiring the SQLITE_ENABLE_COLUMN_METADATA compile-time option.
  • Added the SQLITE_ENABLE_API_ARMOR compile-time option.
  • Added the SQLITE_REVERSE_UNORDERED_SELECTS compile-time option.
  • Added the SQLITE_SORTER_PMASZ compile-time option and SQLITE_CONFIG_PMASZ start-time option.
  • Added the SQLITE_CONFIG_PCACHE_HDRSZ option to sqlite3_config() which makes it easier for applications to determine the appropriate amount of memory for use with SQLITE_CONFIG_PAGECACHE.
  • The number of rows in a VALUES clause is no longer limited by SQLITE_LIMIT_COMPOUND_SELECT.
  • Added the eval.c loadable extension that implements an eval() SQL function that will recursively evaluate SQL.
  • Performance Enhancements:
  • Reduce the number of memcpy() operations involved in balancing a b-tree, for 3.2% overall performance boost.
  • Improvements to cost estimates for the skip-scan optimization.
  • The automatic indexing optimization is now capable of generating a partial index if that is appropriate.
  • Bug fixes:
  • Ensure durability following a power loss with "PRAGMA journal_mode=TRUNCATE" by calling fsync() right after truncating the journal file.
  • The query planner now recognizes that any column in the right-hand table of a LEFT JOIN can be NULL, even if that column has a NOT NULL constraint. Avoid trying to optimize out NULL tests in those cases. Fix for ticket 6f2222d550f5b0ee7ed.
  • Make sure ORDER BY puts rows in ascending order even if the DISTINCT operator is implemented using a descending index. Fix for ticket c5ea805691bfc4204b1cb9e.
  • Fix data races that might occur under stress when running with many threads in shared cache mode where some of the threads are opening and closing connections.
  • Fix obscure crash bugs found by american fuzzy lop. Ticket a59ae93ee990a55.
  • Work around a GCC optimizer bug (for gcc 4.2.1 on MacOS 10.7) that caused the R-Tree extension to compute incorrect results when compiled with -O3.
  • Other changes:
  • Disable the use of the strchrnul() C-library routine unless it is specifically enabled using the -DHAVE_STRCHRNULL compile-time option.
  • Improvements to the effectiveness and accuracy of the likelihood(), likely(), and unlikely() SQL hint functions.
  • SQLITE_SOURCE_ID: "2015-01-16 12:08:06 7d68a42face3ab14ed88407d4331872f5b243fdf"
  • SHA1 for sqlite3.c: 91aea4cc722371d58aae3d22e94d2a4165276905

New in version (December 9th, 2014)

  • This release fixes adds in a mutex that is required by the changes of the patch but was accidently omitted. The mutex was not required by any of the internal SQLite tests, but Firefox crashes without it. Test cases have been added to ensure that mutex is never again missed.

New in version (December 6th, 2014)

  • Bug fix: Ensure the cached KeyInfo objects (an internal abstraction not visible to the application) do not go stale when operating in shared cache mode and frequently closing and reopening some database connections while leaving other database connections on the same shared cache open continuously. Ticket e4a18565a36884b00edf.
  • Bug fix: Recognize that any column in the right-hand table of a LEFT JOIN can be NULL even if the column has a NOT NULL constraint. Do not apply optimizations that assume the column is never NULL. Ticket 6f2222d550f5b0ee7ed.
  • SQLITE_SOURCE_ID: "2014-12-05 22:29:24 647e77e853e81a5effeb4c33477910400a67ba86"
  • SHA1 for sqlite3.c: 3ad2f5ba3a4a3e3e51a1dac9fda9224b359f0261

New in version (November 19th, 2014)

  • The primary reason for this release is to enhance the ROLLBACK command so that it allows running queries on the same database connection to continue running as long as the ROLLBACK does not change the schema. In all previous versions of SQLite, a ROLLBACK would cause pending queries to stop immediately and return SQLITE_ABORT or SQLITE_ABORT_ROLLBACK. Pending queries still abort if the ROLLBACK changes the database schema, but as of this patch release, the queries are allowed to continue running if the schema is unmodified.
  • In addition to the ROLLBACK enhancement, this patch release also includes fixes for three obscure bugs.

New in version (October 30th, 2014)

  • The primary reason for this bug-fix release is to address a problem with updating the value of fields at the end of a table that were added using ALTER TABLE ADD COLUMN. This problem 1 first appeared in the 3.8.7 release.
  • Another minor annoyance in the 3.8.7 release was the fact that the Android build tried to use the strchrnul() function from the standard C library but that function is not available on Android. Android builds had to add -DHAVE_STRCHRNUL=0 to work around the problem. This patch fixes that so that Android builds should now work without any changes.
  • The operation of PRAGMA journal_mode=TRUNCATE has been enhanced so that it invokes fsync() after truncating the journal file when PRAGMA synchronous=FULL. This helps to preserve transaction durability in the case of a power loss occurring shortly after commit.
  • Finally, a couple of long-standing and obscure problems associated with run UPDATE and DELETE on VIEWs were fixed.

New in version 3.8.7 (October 17th, 2014)

  • Most of the changes from the previous release have been micro-optimizations designed to help SQLite run a little faster. Each individual optimization has an unmeasurably small performance impact. But the improvements add up. Measured on a well-defined workload (which the SQLite developers use as a proxy for a typical application workload) using cachegrind on Linux and compiled with gcc 4.8.1 and -Os on x64 linux, the current release does over 20% more work for the same number of CPU cycles compared to the previous release. Cachegrind is not a real CPU, and the workload used for measurement is only a proxy. So your performance may vary. We expect to see about half the measured and reported improvement in real-world applications. 10% is less than 20% but it is still pretty good, we think.
  • This release includes a new set of C-language interfaces that have unsigned 64-bit instead of signed 32-bit length parameters. The new APIs do not provide any new capabilities. But they do make it easier to write applications that are more resistant to integer overflow vulnerabilities.
  • This release also includes a new sorter that is able to use multiple threads to help with large sort operations. (Sort operations are sometimes required to implement ORDER BY and/or GROUP BY clauses and are almost always required for CREATE INDEX.) The multi-threads sorter is turned off by default and must be enabled using the PRAGMA threads SQL command. Note that the multi-threaded sorter provides faster real-time performance for large sorts, but it also uses more CPU cycles and more energy.

New in version (February 12th, 2014)

  • SQLite version fixes a bug present in versions 3.8.1, 3.8.2 and 3.8.3 that can cause queries to omit valid out rows. Upgrading from those versions is recommended.
  • The problem only comes up if SQLite is compiled with either the SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 compile-time options. In that case, if a query has a WHERE clause that contains expressions like this:
  • WHERE (expr1 OR expr2 OR ... OR exprN) AND column IS NOT NULL
  • Where all of expr1 through exprN are suitable for use by indexes, then during query planning SQLite might mistakenly converted the "column IS NOT NULL" term into "column>NULL". But the latter term is never true, and so the query would return no rows.

New in version 3.8.3 (February 4th, 2014)

  • Added support for common table expressions and the WITH clause.
  • Added the printf() SQL function.
  • Added SQLITE_DETERMINISTIC as an optional bit in the 4th argument to the sqlite3_create_function() and related interfaces, providing applications with the ability to create new functions that can be factored out of inner loops when they have constant arguments.
  • Add SQLITE_READONLY_DBMOVED error code, returned at the beginning of a transaction, to indicate that the underlying database file has been renamed or moved out from under SQLite.
  • Allow arbitrary expressions, including function calls and subqueries, in the filename argument to ATTACH.
  • Allow a VALUES clause to be used anywhere a SELECT statement is valid.
  • Reseed the PRNG used by sqlite3_randomness(N,P) when invoked with N==0. Automatically reseed after a fork() on unix.
  • Enhance the spellfix1 virtual table so that it can search efficiently by rowid.
  • Performance enhancements.
  • Improvements to the comments in the VDBE byte-code display when running EXPLAIN.
  • Add the "%token_class" directive to LEMON parser generator and use it to simplify the grammar.
  • Change the LEMON source code to avoid calling C-library functions that OpenBSD considers dangerous. (Ex: sprintf).
  • Bug fix: In the command-line shell CSV import feature, do not end a field when an escaped double-quote occurs at the end of a CRLN line.
  • SQLITE_SOURCE_ID: "2014-02-03 13:52:03 e816dd924619db5f766de6df74ea2194f3e3b538"
  • SHA1 for sqlite3.c: 98a07da78f71b0275e8d9c510486877adc31dbee

New in version 3.8.2 (December 6th, 2013)

  • Version 3.8.2 adds support for WITHOUT ROWID tables. This is a significant extension to SQLite. Database files that contain WITHOUT ROWID tables are not readable or writable by prior versions of SQLite, however databases that do not use WITHOUT ROWID tables are fully backwards and forwards compatible.
  • The 3.8.2 release contains a potentially incompatible change. In all prior versions of SQLite, a cast from a very large positive floating point number into an integer resulted in the most negative integer. In other words, CAST(+99.9e99 to INT) would yield -9223372036854775808. This behavior came about because it is what x86/x64 hardware does for the equivalent cast in the C language. But the behavior is bizarre. And so it has been changed effective with this release so that a cast from a floating point number into an integer returns the integer between the floating point value and zero that is closest to the floating point value. Hence, CAST(+99.9e99 to INT) now returns +9223372036854775807. Since routines like sqlite3_column_int64() do an implicit cast if the value being accessed is really a floating point number, they are also affected by this change.
  • Besides the two changes mentioned above, the 3.8.2 release also includes a number of performance enhancements. The skip-scan optimization is now available for databases that have been processed by ANALYZE. Constant SQL functions are now factored out of inner loops, which can result in a significant speedup for queries that contain WHERE clause terms like "date>datetime('now','-2 days')". And various high-runner internal routines have been refactored for reduced CPU load.

New in version 3.8.1 (October 18th, 2013)

  • SQLite version 3.8.1 is a regularly scheduled maintenance release. Upgrading from the previous release is optional, though you should upgrade if you are using partial indices as there was a bug related to partial indices in the previous release that could result in an incorrect answer for count(*) queries.
  • The next generation query planner that was premiered in the previous release continues to work well. The new query planner has been tweaked slightly in the current release to help it make better decisions in some cases, but is largely unchanged. Two new SQL functions, likelihood() and unlikely(), have been added to allow developers to give hints to the query planner without forcing the query planner into a particular decision.
  • Version 3.8.1 is the first SQLite release to take into account the estimated size of table and index rows when choosing a query plan. Row size estimates are based on the declared datatypes of columns. For example, a column of type VARCHAR(1000) is assumed to use much more space than a column of type INT. The datatype-based row size estimate can be overridden by appending a term of the form "sz=NNN" (where NNN is the average row size in bytes) to the end of the sqlite_stat1.stat record for a table or index. Currently, row sizes are only used to help the query planner choose between a table or one of its indices when doing a table scan or a count(*) operation, though future releases are likely to use the estimated row size in other contexts as well. The new PRAGMA stats statement can be used to view row size estimates.
  • Version 3.8.1 adds the SQLITE_ENABLE_STAT4 compile-time option. STAT4 is very similar to STAT3 in that it uses samples from indices to try to guess how many rows of the index will be satisfy by WHERE clause constraints. The difference is that STAT4 samples all columns of the index whereas the older STAT3 only sampled the left-most column. Users of STAT3 are encouraged to upgrade to STAT4. Application developers should use STAT3 and STAT4 with caution since both options, by design, violate the query planner stability guarantee, making it more difficult to ensure uniform performance is widely-deployed and mass-produced embedded applications.

New in version (August 31st, 2013)

  • SQLite version fixes some obscure bugs that were uncovered by users in the 3.8.0 release. Changes from 3.8.0 are minimal.

New in version 3.8.0 (August 26th, 2013)

  • Add support for partial indexes
  • Cut-over to the next generation query planner for faster and better query plans.
  • The EXPLAIN QUERY PLAN output no longer shows an estimate of the number of rows generated by each loop in a join.
  • Added the FTS4 notindexed option, allowing non-indexed columns in an FTS4 table.
  • Added the SQLITE_STMTSTATUS_VM_STEP option to sqlite3_stmt_status().
  • Added the cache_spill pragma.
  • Added the query_only pragma.
  • Added the defer_foreign_keys pragma and the sqlite3_db_status(db, SQLITE_DBSTATUS_DEFERRED_FKS,...) C-language interface.
  • Added the "percentile()" function as a loadable extension in the ext/misc subdirectory of the source tree.
  • Added the SQLITE_ALLOW_URI_AUTHORITY compile-time option.
  • Add the sqlite3_cancel_auto_extension(X) interface.
  • A running SELECT statement that lacks a FROM clause (or any other statement that never reads or writes from any database file) will not prevent a read transaction from closing.
  • Add the SQLITE_DEFAULT_AUTOMATIC_INDEX compile-time option. Setting this option to 0 disables automatic indices by default.
  • Issue an SQLITE_WARNING_AUTOINDEX warning on the SQLITE_CONFIG_LOG whenever the query planner uses an automatic index.
  • Added the SQLITE_FTS3_MAX_EXPR_DEPTH compile-time option.
  • Added an optional 5th parameter defining the collating sequence to the next_char() extension SQL function.
  • The SQLITE_BUSY_SNAPSHOT extended error code is returned in WAL mode when a read transaction cannot be upgraded to a write transaction because the read is on an older snapshot.
  • Enhancements to the sqlite3_analyzer utility program to provide size information separately for each individual index of a table, in addition to the aggregate size.
  • Allow read transactions to be freely opened and closed by SQL statements run from within the implementation of application-defined SQL functions if the function is called by a SELECT statement that does not access any database table.
  • Disable the use of posix_fallocate() on all (unix) systems unless the HAVE_POSIX_FALLOCATE compile-time option is used.
  • Update the ".import" command in the command-line shell to support multi-line fields and correct RFC-4180 quoting and to issue warning and/or error messages if the input text is not strictly RFC-4180 compliant.
  • Bug fix: In the unicode61 tokenizer of FTS4, treat all private code points as identifier symbols.
  • Bug fix: Bare identifiers in ORDER BY clauses bind more tightly to output column names, but identifiers in expressions bind more tightly to input column names. Identifiers in GROUP BY clauses always prefer output column names, however.
  • Bug fixes: Multiple problems in the legacy query optimizer were fixed by the move to NGQP.
  • SQLITE_SOURCE_ID: "2013-08-26 04:50:08 f64cd21e2e23ed7cff48f7dafa5e76adde9321c2"
  • SHA1 for sqlite3.c: b7347f4b4c2a840e6ba12040093d606bd16ea21e

New in version 3.7.17 (May 20th, 2013)

  • Add support for memory-mapped I/O.
  • Add the sqlite3_strglob() convenience interface.
  • Assigned the integer at offset 68 in the database header as the Application ID for when SQLite is used as an application file-format. Added the PRAGMA application_id command to query and set the Application ID.
  • Report rollback recovery in the error log as SQLITE_NOTICE_RECOVER_ROLLBACK. Change the error log code for WAL recover from SQLITE_OK to SQLITE_NOTICE_RECOVER_WAL.
  • Report the risky uses of unlinked database files and database filename aliasing as SQLITE_WARNING messages in the error log.
  • Added the SQLITE_TRACE_SIZE_LIMIT compile-time option.
  • Increase the default value of SQLITE_MAX_SCHEMA_RETRY to 50 and make sure that it is honored in every place that a schema change might force a statement retry.
  • Add a new test harness called "mptester" used to verify correct operation when multiple processes are using the same database file at the same time.
  • Enhance the extension loading mechanism to be more flexible (while still maintaining backwards compatibility) in two ways:
  • If the default entry point "sqlite3_extension_init" is not present in the loadable extension, also try an entry point "sqlite3_X_init" where "X" is based on the shared library filename. This allows every extension to have a different entry point, which allows them to be statically linked with no code changes.
  • The shared library filename passed to sqlite3_load_extension() may omit the filename suffix, and an appropriate architecture-dependent suffix (".so", ".dylib", or ".dll") will be added automatically.
  • Added many new loadable extensions to the source tree, including amatch, closure, fuzzer, ieee754, nextchar, regexp, spellfix, and wholenumber. See header comments on each extension source file for further information about what that extension does.
  • Enhance FTS3 to avoid using excess stack space when there are a huge number of terms on the right-hand side of the MATCH operator. A side-effect of this change is that the MATCH operator can only accommodate 12 NEAR operators at a time.
  • Enhance the fts4aux virtual table so that it can be a TEMP table.
  • Added the fts3tokenize virtual table to the full-text search logic.
  • Query planner enhancement: Use the transitive property of constraints to move constraints into the outer loops of a join whenever possible, thereby reducing the amount of work that needs to occur in inner loops.
  • Discontinue the use of posix_fallocate() on unix, as it does not work on all filesystems.
  • Improved tracing and debugging facilities in the Windows VFS.
  • Bug fix: Fix a potential database corruption bug in shared cache mode when one database connection is closed while another is in the middle of a write transaction. Ticket e636a050b7
  • Bug fix: Only consider AS names from the result set as candidates for resolving identifiers in the WHERE clause if there are no other matches. In the ORDER BY clause, AS names take priority over any column names. Ticket 2500cdb9be05
  • Bug fix: Do not allow a virtual table to cancel the ORDER BY clause unless all outer loops are guaranteed to return no more than one row result. Ticket ba82a4a41eac1.
  • Bug fix: Do not suppress the ORDER BY clause on a virtual table query if an IN constraint is used. Ticket f69b96e3076e.
  • Bug fix: The command-line shell gives an exit code of 0 when terminated using the ".quit" command.
  • Bug fix: Make sure PRAGMA statements appear in sqlite3_trace() output.
  • Bug fix: When a compound query that uses an ORDER BY clause with a COLLATE operator, make sure that the sorting occurs according to the specified collation and that the comparisons associate with the compound query use the native collation. Ticket 6709574d2a8d8.
  • Bug fix: Makes sure the authorizer callback gets a valid pointer to the string "ROWID" for the column-name parameter when doing an UPDATE that changes the rowid. Ticket 0eb70d77cb05bb2272
  • Bug fix: Do not move WHERE clause terms inside OR expressions that are contained within an ON clause of a LEFT JOIN. Ticket f2369304e4
  • Bug fix: Make sure an error is always reported when attempting to preform an operation that requires a collating sequence that is missing. Ticket 0fc59f908b
  • SQLITE_SOURCE_ID: "2013-05-20 00:56:22 118a3b35693b134d56ebd780123b7fd6f1497668"
  • SHA1 for sqlite3.c: 246987605d0503c700a08b9ee99a6b5d67454aab

New in version (January 10th, 2013)

  • SQLite version is a patch release that fixes a single bug that was introduced in version version 3.7.15. The fix is a 4-character edit to a single line of code. Other than this 4-character change and the update of the version number, nothing has changed from version

New in version (October 5th, 2012)

  • Fix a bug (ticket [d02e1406a58ea02d]]) that causes a segfault on a LEFT JOIN that includes an OR in the ON clause.
  • Work around a bug in the optimizer in the VisualStudio-2012 compiler that causes invalid code to be generated when compiling SQLite on ARM.
  • Fix the TCL interface so that the "nullvalue" setting is honored for TCL implementations of SQL functions.
  • SQLITE_SOURCE_ID: "2012-10-04 19:37:12 091570e46d04e84b67228e0bdbcd6e1fb60c6bdb"
  • SHA1 for sqlite3.c: 62aaecaacab3a4bf4a8fe4aec1cfdc1571fe9a44

New in version (May 23rd, 2012)

  • Fix a bug (ticket c2ad16f997) in the 3.7.12 release that can cause a segfault for certain obscure nested aggregate queries.
  • Fix various other minor test script problems.
  • SQLITE_SOURCE_ID: "2012-05-22 02:45:53 6d326d44fd1d626aae0e8456e5fa2049f1ce0789"
  • SHA1 for sqlite3.c: d494e8d81607f0515d4f386156fb0fd86d5ba7df

New in version 3.7.10 (January 17th, 2012)

  • The SQLITE_CONFIG_PCACHE mechanism has been replaced with SQLITE_CONFIG_PCACHE2. If you do not know what this mechanism is (it is an extreme corner-case and is seldom used) then this change will not effect you in the least.
  • The default schema format number for new database files has changed from 1 to 4. SQLite has been able to generate and read database files using schema format 4 for six years. But up unto now, the default schema format has been 1 so that older versions of SQLite could read and write databases generated by newer versions of SQLite. But those older versions of SQLite have become so scarce now that it seems reasonable to make the new format the default.
  • SQLite is changing some of the assumptions it makes above the behavior of disk drives and flash memory devices during a sudden power loss. This change is completely transparent to applications. Read about the powersafe overwrite property for additional information.
  • Lots of new interfaces have been added in this release:
  • sqlite3_db_release_memory()
  • PRAGMA shrink_memory
  • sqlite3_db_filename()
  • sqlite3_stmt_busy()
  • sqlite3_uri_boolean()
  • sqlite3_uri_int64()
  • The PRAGMA cache_size statement has been enhanced. Formerly, you would use this statement to tell SQLite how many pages of the database files it should hold in its cache at once. The total memory requirement would depend on the database page size. Now, if you give PRAGMA cache_size a negative value -N, it will allocate roughly N kibibytes of memory to cache, divided up according to page size. This enhancement allows programs to more easily control their memory usage.
  • There have been several obscure bug fixes. One noteworthy bug, ticket ff5be73dee, could in theory result in a corrupt database file if a power loss occurred at just the wrong moment on an unusually cantankerous disk drive. But that is mostly a theoretical concern and is very unlikely to happen in practice. The bug was found during laboratory testing and has never been observed to occur in the wild.

New in version 3.7.7 (June 24th, 2011)

  • Add support for URI filenames
  • Add the sqlite3_vtab_config() interface in support of ON CONFLICT clauses with virtual tables.
  • Add the xSavepoint, xRelease and xRollbackTo methods in virtual tables in support of SAVEPOINT for virtual tables.
  • Update the built-in FTS3/FTS4 and RTREE virtual tables to support ON CONFLICT clauses and REPLACE.
  • Avoid unnecessary reparsing of the database schema.
  • Added support for the FTS4 prefix option and the FTS4 order option.
  • Allow WAL-mode databases to be opened read-only as long as there is an existing read/write connection.
  • Added support for short filenames.
  • SQLITE_SOURCE_ID: "2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2"
  • SHA1 for sqlite3.c: 5bbe79e206ae5ffeeca760dbd0d66862228db551

New in version (April 15th, 2011)

  • Fix a bug in 3.7.6 that only appears if the SQLITE_FCNTL_SIZE_HINT file control is used with a build of SQLite that makes use of the HAVE_POSIX_FALLOCATE compile-time option and which has SQLITE_ENABLE_LOCKING_MODE turned off.
  • SQLITE_SOURCE_ID: "2011-04-13 14:40:25 a35e83eac7b185f4d363d7fa51677f2fdfa27695"
  • SHA1 for sqlite3.c: b81bfa27d3e09caf3251475863b1ce6dd9f6ab66

New in version 3.7.5 (February 1st, 2011)

  • Added the sqlite3_vsnprintf() interface.
  • Added the SQLITE_OMIT_AUTORESET compile-time option.
  • Added the SQLITE_DEFAULT_FOREIGN_KEYS compile-time option.
  • Updates to sqlite3_stmt_readonly() so that its result is well-defined for all prepared statements and so that it works with VACUUM.
  • Added the "-heap" option to the command-line shell
  • Fix a bug involving frequent changes in and out of WAL mode and VACUUM that could (in theory) cause database corruption.
  • Enhance the sqlite3_trace() mechanism so that nested SQL statements such as might be generated by virtual tables are shown but are shown in comments and without parameter expansion. This greatly improves tracing output when using the FTS3/4 and/or RTREE virtual tables.
  • Change the xFileControl() methods on all built-in VFSes to return SQLITE_NOTFOUND instead of SQLITE_ERROR for an unrecognized operation code.
  • The SQLite core invokes the SQLITE_FCNTL_SYNC_OMITTED file control to the VFS in place of a call to xSync if the database has PRAGMA synchronous set to OFF.

New in version 3.7.4 (December 8th, 2010)

  • Added the sqlite3_blob_reopen() interface to allow an existing sqlite3_blob object to be rebound to a new row.
  • Use the new sqlite3_blob_reopen() interface to improve the performance of FTS.
  • VFSes that do not support shared memory are allowed to access WAL databases if PRAGMA locking_mode is set to EXCLUSIVE.
  • Enhancements to EXPLAIN QUERY PLAN.
  • Added the sqlite3_stmt_readonly() interface.
  • Added PRAGMA checkpoint_fullfsync.
  • Added the SQLITE_FCNTL_FILE_POINTER option to sqlite3_file_control().
  • Added support for FTS4 and enhancements to the FTS matchinfo() function.
  • Added the test_superlock.c module which provides example code for obtaining an exclusive lock to a rollback or WAL database.
  • Added the test_multiplex.c module which provides an example VFS that provides multiplexing (sharding) of a DB, splitting it over multiple files of fixed size.
  • A very obscure bug associated with the or optimization was fixed.

New in version 3.7.2 (September 14th, 2010)

  • Fix an old and very obscure bug that can lead to corruption of the database free-page list when incremental_vacuum is used.

New in version 3.7.0 (July 22nd, 2010)

  • Added support for write-ahead logging.
  • Query planner enhancement - automatic transient indices are created when doing so reduces the estimated query time.
  • Query planner enhancement - the ORDER BY becomes a no-op if the query also contains a GROUP BY clause that forces the correct output order.
  • Add the SQLITE_DBSTATUS_CACHE_USED verb for sqlite3_db_status().
  • The logical database size is now stored in the database header so that bytes can be appended to the end of the database file without corrupting it and so that SQLite will work correctly on systems that lack support for ftruncate().

New in version (March 30th, 2010)

  • SQLite version is a patch release to fix a bug in the offsets() function of FTS3 at the request of the Mozilla.

New in version 3.6.23 (March 10th, 2010)

  • Added the secure_delete pragma.
  • Added the sqlite3_compileoption_used() and sqlite3_compileoption_get() interfaces as well as the compile_options pragma and the sqlite_compileoption_used() and sqlite_compileoption_get() SQL functions.
  • Added the sqlite3_log() interface together with the SQLITE_CONFIG_LOG verb to sqlite3_config(). The ".log" command is added to the Command Line Interface.
  • Improvements to FTS3.
  • Improvements and bug-fixes in support for SQLITE_OMIT_FLOATING_POINT.
  • The integrity_check pragma is enhanced to detect out-of-order rowids.
  • The ".genfkey" operator has been removed from the Command Line Interface.
  • Updates to the co-hosted Lemon LALR(1) parser generator. (These updates did not effect SQLite.)
  • Various minor bug fixes and performance enhancements.