RSQLite 2.1.4

• Replace std::mem_fn() by boost::mem_fn() which works for older compilers.

RSQLite 2.1.3

• Replace std::mem_fun_ref() by std::mem_fn().

RSQLite 2.1.2

Bundled library

• Upgrade bundled sqlite version to 3.29.0.

Compatibility fixes

• Compatibility with new releases of blob and hms.

• dbUnquoteIdentifier() also handles unquoted identifiers of the form table or schema.table, for compatibility with dbplyr.

Bug fixes

• Fix query for listing tables in schema (#279).

• Coercing NULL values to integer64 and numeric now works in corner cases (#291).

• dbExistsTable() works in corner cases where the table name contains backticks (#275).

• Error messages are encoded in UTF-8.

• Column names are marked as UTF-8 on return, to fix encoding problems on Windows (#276, @shrektan).

• Fix segmentation fault when an open connection is garbage-collected with options(warn = 2) (#245).

New features

• Add regular expression operator (#296, @rfhb).

Internal

• Load extensions through API call, to support repeated loading.

• Align DbResult and other classes with RPostgres and RMariaDB.

• Tested with R >= 3.2 only (but not declared).

• Use default_skip.

• Improve warning when dbGetQuery() is called with a statement (#226).

• Add test for correct use of non-UTF8-encoded column names (#277, @wush978).

• Avoid including the call in errors.

RSQLite 2.1.0

Bug fixes

• Fix rchk warnings on CRAN (#250).
• dbRowsAffected() and dbExecute() return zero after a DROP TABLE statement, and not the number of rows affected by the last INSERT, UPDATE, or DELETE (#238).
• dbIsValid() returns FALSE instead of throwing an error for an invalid connection object (#217).
• Names in the x argument to dbQuoteIdentifier() are preserved in the output (r-lib/DBI#173).
• Ignore invalid UTF-8 strings in dbQuoteIdentifier() (r-dbi/DBItest#156).

Features

• Update bundled sqlite3 library to 3.22 (#252).
• Values of class "integer64" are now supported for dbWriteTable() and dbBind() (#243).
• New connections now automatically load default RSQLite extensions (#236).
• Implement dbUnquoteIdentifier().

Internal

• Now raising error if dbBind() is called with too many named arguments, according to spec.
• Refactor connection and result handling to be more similar to other backends.

v2.0

API changes

• Updated embedded SQLite to 3.19.3.
• 64-bit integers are returned as integer64 vectors. The bit64
  package is imported to support this data type (#65).
• The row.names argument to dbFetch(), dbReadTable(),
  dbWriteTable(), sqliteBuildTableDefinition(), and sqlData() now
  defaults to FALSE. The old default can be restored temporarily on a
  per-package basis by calling
  pkgconfig::set_config("RSQLite::row.names.query" = NA). NULL is a
  valid value for the row.names argument, same as FALSE (#210).
• The name argument to dbBegin(), dbCommit(), and dbRollback()
  is now declared after the ellipsis. Code that calls these methods with
  an unnamed second argument still works but receives a warning (#208).
• The select.cols argument to dbReadTable() is deprecated, use
  dbGetQuery() with a SELECT query instead (#185).
• The methods related to tables (dbReadTable(), dbWriteTable(),
  dbExistsTable(), and dbRemoveTable()) always treat the name
  argument as literal name, even if it contains backticks. This breaks the
  CRAN version (but not the GitHub version) of the sqldf package (#188).
• dbWriteTable(append = TRUE) raises an error if column names are not
  the same in the data and the existing table (#165).
• dbFetch() now errs for n < -1, and accepts n == Inf.
• Removed dummy dbGetQuery() method introduced for compatibility with
  some Bioconductor packages (#187).
• sqlData() now returns quoted strings, like the default
  implementation in DBI (#207).
• dbWriteTable() returns invisibly.
• Now returning objects of type blob for blobs (#189).
• dbGetRowsAffected() now returns NA for a statement with
  placeholders, if dbBind() has not been called.
• If a column contains incompatible values (e.g., numbers and strings),
  a warning is raised in dbFetch() (#161).
• Failing to set PRAGMA cache_size or PRAGMA synchronous in
  dbConnect() now gives a clear warning (#197).
• Improve warning message if named parameters are not used in
  dbGetPreparedQuery() or dbSendPreparedQuery() (#193).
• SQLite collects additional histogram data during ANALYZE, which may
  lead to faster executions of queries (#124).

Bug fixes

• Identifiers are now escaped with backticks, to avoid ambiguous
  handling of double quotes in the context of strings (#123).
• Fix dbBind() behavior and tests. Attempting to bind to a query
  without parameters throws an error (#114).
• Fix corner case when repeatedly fetching from columns that don't have
  an affinity.
• The variance() and stdev() extension functions now return NULL
  for input of length 1 (#201).
• Fix roundtrip of raw columns (#116).

Documentation

• Remove redundant documentation, link to DBI more prominently (#186).

Internal

• Most DBItest tests now pass. Reduced number of skips shown for tests.
• C++ code now compiles with strict compiler settings -Wall -Wextra -pedantic -Wconversion.
• Restore compatibility with older compilers/libraries by using
  <boost/limits.hpp> (#206).
• Use boost/cstdint instead of compound data type for 64-bit values
  (#198).
• Remove Makevars.local logic, resolve installation issues with
  non-GNU Make (#203).
• All methods of DBI are reexported.
• Registering native functions, as required by R >= 3.4.0.
• Use UTF-8 encoded file names as required by the SQLite API, to support
  non-ASCII file names (#211).
• Calling dbFetch(n = 0) instead of dbFetch(n = 1) in
  dbListFields().
• Exclude SQLite3 source code from coverage computation again (#204).

v1.1-2

• Check reverse dependencies.
• Check and warn if the name argument is quoted in dbReadTable() and dbRemoveTable(), for compatibility with sqldf (#196).

v1.1-1

• Fix protection issue that could lead to memory access errors when fetching BLOB data (#192, #194, @MikeBadescu).

v1.1

RSQLite 1.1 (2016-11-25)

• New maintainer: Kirill Müller.

Bundled SQLite

• RSQLite always builds with the included source, which is located in src/sqlite3. This prevents bugs due to API mismatches and considerably simplifies the build process.
• Current version: 3.11.1.
• Enable JSON1 extension (#152, @TigerToes).
• Include support for FTS5 (@mkuhn).
• Compilation limits SQLITE_MAX_VARIABLE_NUMBER and SQLITE_MAX_COLUMN have been reset to the defaults. The documentation suggests setting to such high values is a bad idea.
• Header files for sqlite3 are no longer installed, linking to the package is not possible anymore. Packages that require access to the low-level sqlite3 API should bundle their own copy.

Breaking changes

• RSQLite() no longer automatically attaches DBI when loaded. This is to
  encourage you to use library(DBI); dbConnect(RSQLite::SQLite()).
• Functions that take a table name, such as dbWriteTable() and dbReadTable(),
  now quote the table name via dbQuoteIdentifier().
  This means that caller-quoted names should be marked as such with DBI::SQL().

New features

• RSQLite has been rewritten (essentially from scratch) in C++ with
  Rcpp. This has considerably reduced the amount of code, and allows us to
  take advantage of the more sophisticated memory management tools available in
  Rcpp. This rewrite should yield some minor performance improvements, but
  most importantly protect against memory leaks and crashes. It also provides
  a better base for future development. In particular, it is now technically
  possible to have multiple result sets per connection, although this feature
  is currently disabled (#150).
• You can now use SQLite's URL specification for databases. This allows you to
  create shared in-memory databases
  (#70).
• Queries (#69), query parameters and table data are always converted to UTF-8 before being sent to the database.
• Adapted to DBI 0.5, new code should use dbExecute() instead of dbGetQuery(), and dbSendStatement() instead of dbSendQuery() where appropriate.
• New strategy for prepared queries. Create a prepared query with dbSendQuery() or dbSendStatement() and bind values with dbBind(). The same query/statement can be executed efficiently multiple times by passing a data-frame-like object (#168, #178, #181).
• dbSendQuery(), dbGetQuery(), dbSendStatement() and dbExecute()
  also support inline parameterised queries,
  like dbGetQuery(datasetsDb(), "SELECT * FROM mtcars WHERE cyl = :cyl", params = list(cyl = 4)). This has no performance benefits but protects you
  from SQL injection attacks.
• Improve column type inference: the first non-NULL value decides the type of a column (#111). If there are no non-NULL values, the column affinity is used, determined according to sqlite3 rules (#160).
• dbFetch() uses the same row name strategy as dbReadTable() (#53).
• dbColumnInfo() will now return information even before you've retrieved any data.
• New sqliteVersion() prints the header and library versions of RSQLite.
• Deprecation warnings are given only once, with a clear reference to the source.
• datasetsDb() now returns a read-only database, to avoid modifications to the installed file.

Deprecated functions

• make.db.names() has been formally deprecated. Please use dbQuoteIdentifier() instead. This function is also used in dbReadTable(), dbRemoveTable(), and dbListFields() (#106, #132).
• sqliteBuildTableDefinition() has been deprecated. Use DBI::sqlCreateTable() instead.
• dbGetException() now raises a deprecation warning and always returns list(errorNum = 0L, errorMsg = "OK"), because querying the last SQLite error only works if an error actually occurred (#129).
• dbSendPreparedQuery() and dbGetPreparedQuery() have been reimplemented (with deprecation warning) using dbSendQuery(), dbBind() and dbFetch() for compatibility with existing packages (#100, #153, #168, #181). Please convert to the new API, because the old function may be removed completely very soon: They were never part of the official API, and do less argument checking than the new APIs. Both dbSendPreparedQuery() and dbGetPreparedQuery() ignore parameters not found in the query, with a warning (#174).
• Reimplemented dbListResults() (with deprecation warning) for compatibility with existing packages (#154).
• Soft-deprecated dbGetInfo(): The "Result" method is implemented by DBI, the methods for the other classes raise a warning (#137). It's now better to access the metadata with individual functions dbHasCompleted(), dbGetRowCount() and dbGetRowsAffected().
• All summary() methods have been removed: the same information is now displayed in the show() methods, which were previously pretty useless.

Compatibility fixes

• The raw data type is supported in dbWriteTable(), creates a TEXT column with a warning (#173).
• Numeric values for the row.names argument are converted to logical, with a warning (#170).
• If the number of data frame columns matches the number of existing columns for dbWriteTable(append = TRUE), columns will be matched by position for compatibility, with a warning in case of a name mismatch (#164).
• dbWriteTable() supports the field.types argument when creating a new table (#171), and the temporary argument, default FALSE (#113).
• Reexporting dbGetQuery() and dbDriver() (#147, #148, #183).
• sqliteCopyDatabase() accepts character as to argument again, in this case a temporary connection is opened.
• Reimplemented dbWriteTable("SQLiteConnection", "character", "character") for import of CSV files, using a function from the old codebase (#151).
• dbWriteTable("SQLiteConnection", "character", "data.frame") looks
  for table names already enclosed in backticks and uses these,
  (with a warning), for compatibility with the sqldf package.

Performance

• The dbExistsTable() function now works faster by filtering the list of tables using SQL (#166).

Documentation

• Start on a basic vignette: vignette("RSQLite") (#50).
• Reworked function and method documentation, removed old documentation (#121).
• Using dbExecute() in documentation and examples.
• Using both ":memory:" and ":file::memory:" in documentation.
• Added additional documentation and unit tests for
  autoincrement keys (#119, @wibeasley).

Internal

• Avoid warning about missing long long data type in C++98 by using a compound data type built from two 32-bit integers, with static assert that the size is 8 indeed.
• Remove all compilation warnings.
• All DBI methods contain an ellipsis ... in their signature. Only the name argument to the transaction methods appears before the ellipsis for compatibility reasons.
• Using the DBItest package for testing (#105), with the new constructor_relax_args tweak.
• Using the plogr for logging at the C++ level, can be enabled via RSQLite:::init_logging().
• Using new sqlRownamesToColumn() and sqlColumnToRownames() (r-dbi/DBI#91).
• Using astyle for code formatting (#159), also in tests (but only if sources can be located), stripped space at end of line in all source files.
• Tracking dependencies between source and header files (#138).
• Moved all functions from headers to modules (#162).
• Fixed all warnings in tests (#157).
• Checking message wording for deprecation warnings (#157).
• Testing simple and named transactions (#163).
• Using container-based builds and development version of testthat on Travis.
• Enabled AppVeyor testing.
• Differential reverse dependency checks.
• Added upgrade script for sqlite3 sources and creation script for the datasets database to the data-raw directory.

RSQLite 1.0.0

New features

• Updated to SQLite 3.8.6
• Added datasetsDb(), a bundled SQLite database containing all data frames
  in the datasets package (#15).
• Inlined RSQLite.extfuns - use initExtension() to load the many
  useful extension functions (#44).
• Methods no longer automatically clone the connection is there is an open
  result set. This was implement inconsistently in a handful of places (#22).
  RSQLite is now more forgiving if you forget to close a result set - it will
  close it for you, with a warning. It's still good practice to clean up
  after yourself, but you don't have to.
• dbBegin(), dbCommit(), dbRollback() throw errors on failure, rather than
  return FALSE. They all gain a name argument to specify named savepoints.
• dbFetch() method added (fetch() will be deprecated in the future)
• dbRemoveTable() throws errors on failure, rather than returning FALSE.
• dbWriteTable() has been rewritten:
  • It quotes field names using dbQuoteIdentifier(), rather
    than use a flawed black-list based approach with name munging.
  • It now throws errors on failure, rather than returning FALSE.
  • It will automatically add row names only if they are character, not integer.
  • When loading a file from disk, dbWriteTable() will no longer
    attempt to guess the correct values for row.names and header - instead
    supply them explicitly if the defaults are incorrect.
  • It uses named save points so it can be nested inside other
    transactions (#41).
  • When given a zero-row data frame it will just creates the table
    definition (#35).

Changes to objects

• The dbname, loadable.extensions, flags and vfs properties of
  a SqliteConnection are now slots. Access them directly instead of using
  dbGetInfo().

Deprecated and removed functions

• RSQLite is no longer nominally compatible with S (#39).
• idIsValid() is deprecated. Please use dbIsValid() instead.
• dbBeginTransaction() has been deprecated. Please use dbBegin() instead.
• dbCallProc() method removed, since generic is now deprecated.
• Renamed dbBuildTableDefinition() to sqliteBuildTableDefinition()
  to avoid implying it's a DBI generic. Old function is aliased to new with
  a warning.
• dbFetch() no longer numbers row names sequentially between fetches.
• safe.write() is no longer exported as it shouldn't be part of the
  public RSQLite interface (#26).
• Internal sqlite*() functions are no longer exported (#20).
• Removed SqliteObject and dbObject classes, modifying SqliteDriver,
  SqliteConnection, and SqliteResult to use composition instead of multiple
  inheritance.