Cordova/PhoneGap sqlite storage plugin

Native interface to sqlite in a Cordova/PhoneGap plugin for Android, iOS, macOS, and Windows 10 (UWP), with API similar to HTML5/Web SQL API.

License for Android and Windows platform versions: MIT or Apache 2.0

License for iOS/macOS platform version: MIT only

|Android Circle-CI (full suite)|iOS Travis-CI (partial suite)| |-----------------------|----------------------| |||

About this version branch

This is the common version branch which supports the most widely used features and serves as the basis for the other versions.

Available for hire

The primary author and maintainer @brodybits (Christopher J. Brody aka Chris Brody) is available for part-time contract assignments. Services available for this project include:

• Priority issue support
• Help with application code such as debugging, optimization, etc.
• Warranty and support retainers
• Priority fixes and enhancements
• Custom feature development

Other services available include:

• Front-end/back-end development
• Mentoring and training services

For more information:

• http://litehelpers.net/
• [email protected]

A quick tour

To open a database:

var db = null;

document.addEventListener('deviceready', function() {
  db = window.sqlitePlugin.openDatabase({name: 'demo.db', location: 'default'});
});

IMPORTANT: Like with the other Cordova plugins your application must wait for the deviceready event. This is especially tricky in Angular/ngCordova/Ionic controller/factory/service callbacks which may be triggered before the deviceready event is fired.

To populate a database using the standard transaction API:

  db.transaction(function(tx) {
    tx.executeSql('CREATE TABLE IF NOT EXISTS DemoTable (name, score)');
    tx.executeSql('INSERT INTO DemoTable VALUES (?,?)', ['Alice', 101]);
    tx.executeSql('INSERT INTO DemoTable VALUES (?,?)', ['Betty', 202]);
  }, function(error) {
    console.log('Transaction ERROR: ' + error.message);
  }, function() {
    console.log('Populated database OK');
  });

To check the data using the standard transaction API:

  db.transaction(function(tx) {
    tx.executeSql('SELECT count(*) AS mycount FROM DemoTable', [], function(tx, rs) {
      console.log('Record count (expected to be 2): ' + rs.rows.item(0).mycount);
    }, function(tx, error) {
      console.log('SELECT error: ' + error.message);
    });
  });

To populate a database using the SQL batch API:

  db.sqlBatch([
    'CREATE TABLE IF NOT EXISTS DemoTable (name, score)',
    [ 'INSERT INTO DemoTable VALUES (?,?)', ['Alice', 101] ],
    [ 'INSERT INTO DemoTable VALUES (?,?)', ['Betty', 202] ],
  ], function() {
    console.log('Populated database OK');
  }, function(error) {
    console.log('SQL batch ERROR: ' + error.message);
  });

To check the data using the single SQL statement API:

  db.executeSql('SELECT count(*) AS mycount FROM DemoTable', [], function(rs) {
    console.log('Record count (expected to be 2): ' + rs.rows.item(0).mycount);
  }, function(error) {
    console.log('SELECT SQL statement ERROR: ' + error.message);
  });

See the Sample section for a sample with a more detailed explanation.

Status

• NOT supported by PhoneGap Developer App or PhoneGap Desktop App
• This version uses a before_plugin_install hook to install sqlite3 library dependencies from cordova-sqlite-storage-dependencies via npm.
• SQLite version 3.15.2 included with the following build settings:
  • SQLITE_THREADSAFE=1
  • SQLITE_DEFAULT_MEMSTATUS=0
  • SQLITE_OMIT_DECLTYPE
  • SQLITE_OMIT_DEPRECATED
  • SQLITE_OMIT_PROGRESS_CALLBACK
  • SQLITE_OMIT_SHARED_CACHE
  • SQLITE_TEMP_STORE=2
  • SQLITE_OMIT_LOAD_EXTENSION
  • SQLITE_ENABLE_FTS3
  • SQLITE_ENABLE_FTS3_PARENTHESIS
  • SQLITE_ENABLE_FTS4
  • SQLITE_ENABLE_RTREE
  • SQLITE_DEFAULT_PAGE_SIZE=1024 and SQLITE_DEFAULT_CACHE_SIZE=2000 to avoid "potentially distruptive change(s)" from SQLite 3.12.0 ref: http://sqlite.org/pgszchng2016.html
  • SQLITE_OS_WINRT for Windows only
• A recent version of the Cordova CLI (such as 6.5.0) is recommended. Cordova versions older than 6.0.0 are missing the [email protected] security fixes. In addition it is required to use cordova prepare in case of cordova-ios older than 4.3.0 (Cordova CLI 6.4.0).
• Use of other systems such as Cordova Plugman, PhoneGap CLI, PhoneGap Build, and Intel XDK is no longer supported since they do not honor the before_plugin_install hook. The supported solution is to use litehelpers / Cordova-sqlite-evcore-extbuild-free (available with GPL or commercial license options) or litehelpers / Cordova-sqlite-legacy-build-support (limited testing, limited updates)
• The iOS database location is now mandatory, as documented below.
• This version supports the use of two (2) possible Android sqlite database implementations:
  • default: lightweight Android-sqlite-connector
  • optional: built-in Android database classes (usage described below)
• Support for WP8 along with Windows 8.1/Windows Phone 8.1/Windows 10 using Visual Studio 2015 is available in litehelpers / Cordova-sqlite-legacy.
• The following features are available in litehelpers / cordova-sqlite-ext:
  • REGEXP (Android/iOS/macOS)
  • SELECT BLOB data in Base64 format (all platforms Android/iOS/macOS/Windows)
  • Pre-populated database (Android/iOS/macOS/Windows)
• Amazon Fire-OS is dropped due to lack of support by Cordova. Android platform version should be used to deploy to Fire-OS 5.0(+) devices. For reference: cordova/cordova-discuss#32 (comment)
• Windows platform version (using a customized version of the performant doo / SQLite3-WinRT C++ component) has the following known limitations:
  • Truncation issue with UNICODE \u0000 character (same as \0)
  • No background processing
  • INCORRECT error code (0) and INCONSISTENT error message (missing actual error info) in error callbacks ref: litehelpers/Cordova-sqlite-storage#539
  • Not possible to read BLOB column values
  • It is not possible to use this plugin with the default "Any CPU" target. A specific target CPU type must be specified when building an app with this plugin.
  • This version has dependency on platform toolset libraries included by Visual Studio 2017 (litehelpers/Cordova-sqlite-storage#580). Visual Studio 2015 is now supported by litehelpers / Cordova-sqlite-legacy-build-support.
  • Windows platform version uses UTF-16le internal database encoding while the other platform versions use UTF-8 internal encoding. (UTF-8 internal encoding is preferred ref: litehelpers/Cordova-sqlite-storage#652)
  • Certain close/delete scenarios in the test suite not working on Windows
• The macOS platform version ("osx" platform) has not been tested in a release build and should be considered pre-alpha.
• FTS3, FTS4, and R-Tree support is tested working OK in this version (for all target platforms in this version branch Android/iOS/macOS/Windows)
• Android is supported back to SDK 10 (a.k.a. Gingerbread, Android 2.3.3); support for older versions is available upon request.
• iOS versions supported: 8.x/9.x/10.x (see deviations section below for differences in case of WKWebView)
• In case of memory issues please use smaller transactions or use the version (with GPL or commercial license options) at: litehelpers / Cordova-sqlite-evcore-extbuild-free

Announcements

• Resolved transaction problem after window.location (page) change with possible data loss ref: litehelpers/Cordova-sqlite-storage#666
• This version references Windows platform toolset v141 to support Visual Studio 2017. Visual Studio 2015 is now supported by litehelpers / Cordova-sqlite-legacy-build-support.
• brodybits / cordova-sqlite-storage-starter-app project is a CC0 (public domain) starting point and may also be used to reproduce issues with this plugin. In addition brodybits / cordova-sqlite-test-app may be used to reproduce issues with other versions of this plugin.
• The Lawnchair adapter is now moved to litehelpers / cordova-sqlite-lawnchair-adapter.
• litehelpers / cordova-sqlite-ext now supports SELECT BLOB data in Base64 format on all platforms in addition to REGEXP (Android/iOS/macOS) and pre-populated database (all platforms).
• brodybits / sql-promise-helper provides a Promise-based API wrapper.
• nolanlawson / pouchdb-adapter-cordova-sqlite supports this plugin along with other implementations such as nolanlawson / sqlite-plugin-2 and Microsoft / cordova-plugin-websql.
• macOS ("osx" platform) is now supported
• New litehelpers / Cordova-sqlite-evcore-extbuild-free version with Android JSON and SQL statement handling implemented in C, as well as support for PhoneGap Build, Intel XDK, etc., available with GPL or commercial license options. Handles large SQL batches in less than half the time as this version. Also supports arbitrary database location on Android.
• Published brodybits / Cordova-quick-start-checklist and brodybits / Avoiding-some-Cordova-pitfalls.
• Android platform version uses the lightweight Android-sqlite-connector by default configuration (may be changed as described below).
• Self-test functions to verify proper installation and operation of this plugin.
• More explicit openDatabase and deleteDatabase iosDatabaseLocation option
• Added simple sql batch function
• MetaMemoryT / websql-promise now provides a Promises-based interface to both Web SQL and this plugin

Highlights

• Drop-in replacement for HTML5/Web SQL API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below. Known deviations are documented in the deviations section below.
• Failure-safe nested transactions with batch processing optimizations (according to HTML5/Web SQL API)
• API (based on HTML5/Web SQL API) is designed to be as flexible as possible but does not allow any transactions to remain hanging open.
• As described in this posting:
  • Keeps sqlite database in known, platform specific user data location on all platforms (Android/iOS/macOS/Windows), which can be reconfigured on iOS/macOS. Whether or not the database on the iOS platform is synchronized to iCloud depends on the selected database location.
  • No arbitrary size limit. SQLite limits described at: http://www.sqlite.org/limits.html
• Also tested for multi-page applications with window location changes
• This project is self-contained though with sqlite3 dependencies auto-fetched by npm. There are no dependencies on other plugins such as cordova-plugin-file.
• Windows platform version uses a customized version of the performant doo / SQLite3-WinRT C++ component.
• SQLCipher support for Android/iOS/macOS/Windows is available in: litehelpers / Cordova-sqlcipher-adapter
• Intellectual property:
  • All source code is tracked to the original author in git
  • Major authors are tracked in AUTHORS.md
  • License of each component is tracked in LICENSE.md
  • History of this project is also described in HISTORY.md

TIP: It is possible to migrate from Cordova to a pure native solution and continue using the data stored by this plugin.

Getting started

Recommended prerequisites

• Install a recent version of Cordova CLI, create a simple app with no plugins, and run it on the desired target platforms.
• Add a very simple plugin such as cordova-plugin-dialogs or an echo plugin and get it working. Ideally you should be able to handle a callback with some data coming from a prompt.

These prereqisites are very well documented in a number of excellent resources including:

• http://cordova.apache.org/ (redirected from http://cordova.io)
• http://www.tutorialspoint.com/cordova/
• https://ccoenraets.github.io/cordova-tutorial/
• https://www.toptal.com/mobile/developing-mobile-applications-with-apache-cordova
• http://www.tutorialspoint.com/cordova/index.htm

More resources can be found by https://www.google.com/search?q=cordova+tutorial. There are even some tutorials available on YouTube as well.

In addition, this guide assumes a basic knowledge of some key JavaScript concepts such as variables, function calls, and callback functions. There is an excellent explanation of JavaScript callbacks at http://cwbuecheler.com/web/tutorials/2013/javascript-callbacks/.

MAJOR TIPS: As described in the Installing section:

• It is recommended to use the --save flag when installing plugins to track them in config.xml. If all plugins are tracked in config.xml then there is no need to commit the plugins subdirectory tree into the source repository.
• In general it is not recommended to commit the platforms subdirectory tree into the source repository.

NOTICE: This plugin is only supported with the Cordova CLI. This plugin is not supported with other Cordova/PhoneGap systems such as PhoneGap CLI, PhoneGap Build, Plugman, Intel XDK, Webstorm, etc.

Windows platform notes

The Windows platform can present a number of challenges which increase when using this plugin. The following tips are recommended for getting started with Windows:

• First start to build and run an app on another platform such as Android or iOS with this plugin.
• Try working with a very simple app using simpler plugins such as cordova-plugin-dialogs and possibly cordova-plugin-file on the Windows platform.
• Read through the Windows platform usage of the Installing section.
• Then try adding this plugin to a very simple app such as brodybits / cordova-sqlite-test-app and running the Windows project in the Visual Studio GUI with a specific target CPU selected. WARNING: It is not possible to use this plugin with the "Any CPU" target.

Quick installation

Use the following command to install this plugin from the Cordova CLI:

cordova plugin add cordova-sqlite-storage --save

Add any desired platform(s) if not already present, for example:

cordova platform add android

OPTIONAL: prepare before building (MANDATORY for cordova-ios older than 4.3.0 (Cordova CLI 6.4.0))

cordova prepare

or to prepare for a single platform, Android for example:

cordova prepare android

Please see the Installing section for more details.

NOTE: The new brodybits / cordova-sqlite-test-app project includes the echo test, self test, and string test described below along with some more sample functions.

Self test

Try the following programs to verify successful installation and operation:

Echo test - verify successful installation and build:

document.addEventListener('deviceready', function() {
  window.sqlitePlugin.echoTest(function() {
    console.log('ECHO test OK');
  });
});

Self test - automatically verify basic database access operations including opening a database; basic CRUD operations (create data in a table, read the data from the table, update the data, and delete the data); close and delete the database:

document.addEventListener('deviceready', function() {
  window.sqlitePlugin.selfTest(function() {
    console.log('SELF test OK');
  });
});

NOTE: It may be easier to use a JavaScript or native alert function call along with (or instead of) console.log to verify that the installation passes both tests. Same for the SQL string test variations below. (Note that the Windows platform does not support the standard alert function, please use cordova-plugin-dialogs instead.)

SQL string test

This test verifies that you can open a database, execute a basic SQL statement, and get the results (should be TEST STRING):

document.addEventListener('deviceready', function() {
  var db = window.sqlitePlugin.openDatabase({name: 'test.db', location: 'default'});
  db.transaction(function(tr) {
    tr.executeSql("SELECT upper('Test string') AS upperString", [], function(tr, rs) {
      console.log('Got upperString result: ' + rs.rows.item(0).upperString);
    });
  });
});

Here is a variation that uses a SQL parameter instead of a string literal:

document.addEventListener('deviceready', function() {
  var db = window.sqlitePlugin.openDatabase({name: 'test.db', location: 'default'});
  db.transaction(function(tr) {
    tr.executeSql('SELECT upper(?) AS upperString', ['Test string'], function(tr, rs) {
      console.log('Got upperString result: ' + rs.rows.item(0).upperString);
    });
  });
});

Moving forward

It is recommended to read through the usage and sample sections before building more complex applications. In general it is recommended to start by doing things one step at a time, especially when an application does not work as expected.

The new brodybits / cordova-sqlite-test-app sample is intended to be a boilerplate to reproduce and demonstrate any issues you may have with this plugin. You may also use it as a starting point to build a new app.

In case you get stuck with something please read through the support section and follow the instructions before raising an issue. Professional support is also available by contacting: [email protected]

Plugin usage examples

• brodybits / cordova-sqlite-storage-starter-app
• http://stackoverflow.com/questions/26604952/a-simple-cordova-android-example-including-sqlite-read-write-and-search

Plugin tutorials

• https://phonegappro.com/tutorials/phonegap-sqlite-tutorial-with-example-apache-cordova/

NOTICE: The above tutorial shows cordova plugin add cordova-sqlite-storage with the --save flag missing. Please be sure to use the --save flag to keep the plugins in config.xml.

Other plugin tutorials wanted ref: litehelpers/Cordova-sqlite-storage#609

SQLite resources

• http://www.tutorialspoint.com/sqlite/index.htm with a number of helpful articles

Some other Cordova resources

• http://www.tutorialspoint.com/cordova/cordova_file_system.htm

Some apps using this plugin

• Trailforks Mountain Bike Trail Map App with a couple of nice videos at: http://www.pinkbike.com/news/trailforks-app-released.html
• Get It Done app by marcucio.com
• KAAHE Health Encyclopedia: Official health app of the Kingdom of Saudi Arabia.
• Larkwire (iOS platform): Learn bird songs the fun way
• Tangorin (Android) Japanese Dictionary at tangorin.com
• GeoWiz.Biz Truck Tracker app with a Personal Edition available in the Android and iOS app stores

Security

Security of sensitive data

According to Web SQL Database API 7.2 Sensitivity of data:

User agents should treat persistently stored data as potentially sensitive; it's quite possible for e-mails, calendar appointments, health records, or other confidential documents to be stored in this mechanism.

To this end, user agents should ensure that when deleting data, it is promptly deleted from the underlying storage.

Unfortunately this plugin will not actually overwrite the deleted content unless the secure_delete PRAGMA is used.

SQL injection

As "strongly recommended" by Web SQL Database API 8.5 SQL injection:

Authors are strongly recommended to make use of the ? placeholder feature of the executeSql() method, and to never construct SQL statements on the fly.

Avoiding data loss

• Double-check that the application code follows the documented API for SQL statements, parameter values, success callbacks, and error callbacks.
• For standard Web SQL transactions include a transaction error callback with the proper logic that indicates to the user if data cannot be stored for any reason. In case of individual SQL error handlers be sure to indicate to the user if there is any issue with storing data.
• For single statement and batch transactions include an error callback with logic that indicates to the user if data cannot be stored for any reason.

Deviations

Some known deviations from the Web SQL database standard

• The window.sqlitePlugin.openDatabase static factory call takes a different set of parameters than the standard Web SQL window.openDatabase static factory call. In case you have to use existing Web SQL code with no modifications please see the Web SQL replacement tip below.
• This plugin does not support the database creation callback or standard database versions. Please read the Database schema versions section below for tips on how to support database schema versioning.
• This plugin does not support the synchronous Web SQL interfaces.
• Known issues with handling of certain ASCII/UNICODE characters as described below.
• It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others ref: litehelpers/Cordova-sqlite-storage#551
• It is possible to insert multiple rows like: transaction.executeSql('INSERT INTO MyTable VALUES (?,?),(?,?)', ['Alice', 101, 'Betty', 102]); which was not supported by SQLite 3.6.19 as referenced by Web SQL API section 5. The iOS WebKit Web SQL implementation seems to support this as well.
• Unlike the HTML5/Web SQL API this plugin handles executeSql calls with too few parameters without error reporting. In case of too many parameters this plugin reports error code 0 (SQLError.UNKNOWN_ERR) while Android/iOS (WebKit) Web SQL correctly reports error code 5 (SQLError.SYNTAX_ERR) ref: https://www.w3.org/TR/webdatabase/#dom-sqlexception-code-syntax
• Positive and negative Infinity SQL parameter argument values are treated like null by this plugin on Android and iOS ref: litehelpers/Cordova-sqlite-storage#405
• Positive and negative Infinity result values cause a crash on iOS/macOS cases ref: litehelpers/Cordova-sqlite-storage#405
• Known issue(s) with of certain ASCII/UNICODE characters as described below.
• Boolean true and false values are handled by converting them to the "true" and "false" TEXT string values, same as WebKit Web SQL on Android and iOS. This does not seem to be 100% correct as discussed in: litehelpers/Cordova-sqlite-storage#545
• A number of uncategorized errors such as CREATE VIRTUAL TABLE USING bogus module are reported with error code 5 (SQLError.SYNTAX_ERR) on Android/iOS/macOS by both (WebKit) Web SQL and this plugin.
• Issues with error code on Windows as well as Android with the androidDatabaseImplementation: 2 setting described below.
• In case of an issue that causes an API function to throw an exception (Android/iOS WebKit) Web SQL includes includes a code member with value of 0 (SQLError.UNKNOWN_ERR) in the exception while the plugin includes no such code member.
• This plugin supports some non-standard features as documented below.
• Results of SELECT with BLOB data such as SELECT LOWER(X'40414243') AS myresult, SELECT X'40414243' AS myresult, or reading data stored by INSERT INTO MyTable VALUES (X'40414243') are not consistent on Android in case the built-in Android database is used (using the androidDatabaseImplementation: 2 setting in window.sqlitePlugin.openDatabase) or Windows. (These work with Android/iOS WebKit Web SQL and have been supported by SQLite for a number of years.)
• Whole number parameter argument values such as 42, -101, or 1234567890123 are handled as INTEGER values by this plugin on Android, iOS (default UIWebView), and Windows while they are handled as REAL values by (WebKit) Web SQL and this plugin on macOS or iOS with WKWebView. This is evident in certain test operations such as SELECT ? as myresult or SELECT TYPEOF(?) as myresult and storage in a field with TEXT affinity.
• INTEGER, REAL, +/- Infinity, NaN, null, undefined parameter argument values are handled as TEXT string values on Android in case the built-in Android database (androidDatabaseImplementation: 2 setting) is used. (This is evident in certain test operations such as SELECT ? as myresult or SELECT TYPEOF(?) as myresult and storage in a field with TEXT affinity.)
• In case of invalid transaction callback arguments such as string values the plugin attempts to execute the transaction while (WebKit) Web SQL would throw an exception.
• The plugin handles invalid SQL arguments array values such as false, true, or a string as if there were no arguments while (WebKit) Web SQL would throw an exception. NOTE: In case of a function in place of the SQL arguments array WebKit Web SQL would report a transaction error while the plugin would simply ignore the function.
• In case of invalid SQL callback arguments such as string values the plugin may execute the SQL and signal transaction success or failure while (WebKit) Web SQL would throw an exception.
• In certain cases such as transaction.executeSql(null) or transaction.executeSql(undefined) the plugin throws an exception while (WebKit) Web SQL indicates a transaction failure.
• In certain cases such as transaction.executeSql() with no arguments (Android/iOS WebKit) Web SQL includes includes a code member with value of 0 (SQLError.UNKNOWN_ERR) in the exception while the plugin includes no such code member.
• If the SQL arguments are passed in an Array subclass object where the constructor does not point to Array then the SQL arguments are ignored by the plugin.
• The results data objects are not immutable as specified/implied by Web SQL API section 4.5.

Security of deleted data

See Security of sensitive data in the Security section above.

Other differences with WebKit Web SQL implementations

• In case of ignored INSERT OR IGNORE statement WebKit Web SQL (Android/iOS) reports insertId with an old INSERT row id value while the plugin reports insertId: undefined.
• In case of a SQL error handler that does not recover the transaction, WebKit Web SQL (Android/iOS) would incorrectly report error code 0 while the plugin would report the same error code as in the SQL error handler. (In case of an error with no SQL error handler then Android/iOS WebKit Web SQL would report the same error code that would have been reported in the SQL error hander.)
• In case a transaction function throws an exception, the message and code if present are reported by the plugin but not by (WebKit) Web SQL.
• SQL error messages are inconsistent on Windows.
• There are some other differences in the SQL error messages reported by WebKit Web SQL and this plugin.

Known issues

• The iOS/macOS platform version does not support certain rapidly repeated open-and-close or open-and-delete test scenarios due to how the implementation handles background processing.
• As described below, auto-vacuum is NOT enabled by default.
• The Android platform version does not always handle four-byte UTF-8 characters emoji characters such as \u1F603 (SMILING FACE, MOUTH OPEN) correctly ref: litehelpers/Cordova-sqlite-storage#564. It is sometimes possible to store and retrieve such characters but certain operations such as hex conversions do not work properly with the default Android-sqlite-connector database implementation. It is suspected that such characters would be stored incorrectly by the default Android platform version. This is not an issue in case the built-in Android database is used (using the androidDatabaseImplementation: 2 setting in window.sqlitePlugin.openDatabase)
• It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others ref: litehelpers/Cordova-sqlite-storage#551
• INSERT statement that affects multiple rows (due to SELECT cause or using TRIGGER(s), for example) reports incorrect rowsAffected on Android in case the built-in Android database used (using the androidDatabaseImplementation option in window.sqlitePlugin.openDatabase)
• Memory issue observed when adding a large number of records due to the JSON implementation which is improved in litehelpers / Cordova-sqlite-evcore-extbuild-free (available with GPL or commercial license options)
• Infinity (positive or negative) values are not supported on Android/iOS/macOS due to issues described above including a possible crash on iOS/macOS ref: litehelpers/Cordova-sqlite-storage#405
• A stability issue was reported on the iOS platform version when in use together with SockJS client such as pusher-js at the same time (see litehelpers/Cordova-sqlite-storage#196). The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).
• SQL errors are reported with an INCORRECT error code (0) on Windows ref: litehelpers/Cordova-sqlite-storage#539. In certain cases SQL errors are also reported with error code 0 on Android in case the built-in Android database is used (using the androidDatabaseImplementation: 2 setting in window.sqlitePlugin.openDatabase).
• Possible crash on Android when using Unicode emoji and other 4-octet UTF-8 characters due to Android bug 81341, which should be fixed in Android 6.x
• Close/delete database bugs described below.
• When a database is opened and deleted without closing, the iOS/macOS platform version is known to leak resources.
• It is NOT possible to open multiple databases with the same name but in different locations (iOS/macOS platform version).

Some more known issues are tracked in the open cordova-sqlite-storage bug-general issues.

Other limitations

• ~~The db version, display name, and size parameter values are not supported and will be ignored.~~ (No longer supported by the API)
• Absolute and relative subdirectory path(s) are not tested or supported.
• This plugin will not work before the callback for the 'deviceready' event has been fired, as described in Usage. (This is consistent with the other Cordova plugins.)
• Extremely large records are not supported by this plugin version. It is recommended to store images and similar binary data in separate files. TBD: specify maximum record. For future consideration: support in a version such as litehelpers / Cordova-sqlite-evcore-extbuild-free (available with GPL or commercial license options)
• This plugin version will not work within a web worker (not properly supported by the Cordova framework). Use within a web worker is supported for Android and iOS in: litehelpers / Cordova-sqlite-evplus-legacy-workers-free (available with GPL or premium commercial license options)
• In-memory database db=window.sqlitePlugin.openDatabase({name: ':memory:', ...}) is currently not supported.
• The Android platform version cannot properly support more than 100 open database files due to the threading model used.
• SQL error messages on Windows platform version are not consistent with Android/iOS/macOS platform versions.
• UNICODE \u2028 (line separator) and \u2029 (paragraph separator) characters are currently not supported and known to be broken in iOS, macOS, and Android platform versions due to JSON issues reported in Cordova bug CB-9435 and cordova/cordova-discuss#57. This is fixed with a workaround for iOS/macOS in: litehelpers / Cordova-sqlite-evplus-legacy-free and litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free (available with GPL or special commercial license options) as well as litehelpers / Cordova-sqlite-evplus-legacy-workers-free (available with GPL or premium commercial license options)
• The BLOB data type is not fully supported by this version branch. SELECT BLOB in Base64 format is supported by litehelpers / cordova-sqlite-ext (permissive license terms) and litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license options).
• Truncation in case of UNICODE \u0000 (same as \0) character on Android (default Android-sqlite-connector database implementation) and Windows
• Case-insensitive matching and other string manipulations on Unicode characters, which is provided by optional ICU integration in the sqlite source and working with recent versions of Android, is not supported for any target platforms.
• The iOS/macOS platform version uses a thread pool but with only one thread working at a time due to "synchronized" database access.
• Some large query results may be slow, also due to the JSON implementation.
• ATTACH to another database file is not supported by this version. Attach/detach is supported (along with the memory and iOS UNICODE \u2028 line separator / \u2029 paragraph separator fixes) in: litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free (available with GPL or special commercial license options)
• UPDATE/DELETE with LIMIT or ORDER BY is not supported.
• WITH clause is not supported by older Android versions in case the androidDatabaseImplementation: 2 (built-in android.database implementation) option is used.
• User-defined savepoints are not supported and not expected to be compatible with the transaction locking mechanism used by this plugin. In addition, the use of BEGIN/COMMIT/ROLLBACK statements is not supported.
• Problems have been reported when using this plugin with Crosswalk (for Android). It may help to install Crosswalk as a plugin instead of using Crosswalk to create the project.
• Does not work with axemclion / react-native-cordova-plugin since the window.sqlitePlugin object is not properly exported (ES5 feature). It is recommended to use andpor / react-native-sqlite-storage for SQLite database access with React Native Android/iOS instead.

Some more limitations are tracked in the open cordova-sqlite-storage doc-todo issues.

Further testing needed

• Integration with PhoneGap developer app
• Use within InAppBrowser
• Use within an iframe (see litehelpers/Cordova-sqlite-storage#368 (comment))
• Date/time handling
• Maximum record size supported
• Actual behavior when using SAVEPOINT(s)
• R-Tree is not fully tested with Android
• Some more UNICODE characters
• ORDER BY random() (ref: litehelpers/Cordova-sqlite-storage#334)
• UPDATE/DELETE with LIMIT or ORDER BY (newer Android/iOS versions)
• Integration with JXCore for Cordova (must be built without sqlite(3) built-in)
• Delete an open database inside a statement or transaction callback.
• WITH clause (not supported by some older sqlite3 versions)
• Handling of invalid transaction and transaction.executeSql arguments
• Use of database locations on macOS
• Extremely large and small INTEGER and REAL values ref: litehelpers/Cordova-sqlite-storage#627)
• More emojis and other 4-octet UTF-8 characters
• ?NNN/:AAA/@AAAA/$AAAA parameter placeholders ref: https://www.sqlite.org/lang_expr.html#varparam, https://www.sqlite.org/c3ref/bind_blob.html)
• Single-statement and SQL batch transaction calls with invalid arguments (TBD behavior subject to change)
• Other open Cordova-sqlite-storage testing issues

Some tips and tricks

• If you run into problems and your code follows the asynchronous HTML5/Web SQL transaction API, you can try opening a test database using window.openDatabase and see if you get the same problems.
• In case your database schema may change, it is recommended to keep a table with one row and one column to keep track of your own schema version number. It is possible to add it later. The recommended schema update procedure is described below.

Pitfalls

Some common pitfall(s)

• If a database is opened using the standard window.openDatabase call it will not have any of the benefits of this plugin and features such as the sqlBatch call would not be available.
• It is NOT allowed to execute sql statements on a transaction that has already finished, as described below. This is consistent with the HTML5/Web SQL API.
• The plugin class name starts with "SQL" in capital letters, but in Javascript the sqlitePlugin object name starts with "sql" in small letters.
• Attempting to open a database before receiving the 'deviceready' event callback.
• Inserting STRING into ID field
• Auto-vacuum is NOT enabled by default. It is recommended to periodically VACUUM the database.
• Transactions on a database are run sequentially. A large transaction could block smaller transactions requested afterwards.

Some weird pitfall(s)

• intent whitelist: blocked intent such as external URL intent may cause this and perhaps certain Cordova plugin(s) to misbehave (see litehelpers/Cordova-sqlite-storage#396)

Angular/ngCordova/Ionic-related pitfalls

• Angular/ngCordova/Ionic controller/factory/service callbacks may be triggered before the 'deviceready' event is fired
• As discussed in litehelpers/Cordova-sqlite-storage#355, it may be necessary to install ionic-plugin-keyboard
• Navigation items such as root page can be tricky on Ionic 2 ref: litehelpers/Cordova-sqlite-storage#613

Windows platform pitfalls

• This plugin does not work with the default "Any CPU" target. A specific, valid CPU target platform must be specified.
• It is not allowed to change the app ID in the Windows platform project. As described in the Windows platform usage of the Installing section a Windows-specific app ID may be declared using the windows-identity-name attribute or "WindowsStoreIdentityName" setting.
• A problem locating SQLite3.md generally means that there was a problem building the C++ library.
• Visual Studio 2015 is no longer supported by this version. Visual Studio 2015 is now supported by litehelpers / Cordova-sqlite-legacy-build-support.

General Cordova pitfalls

Documented in: brodybits / Avoiding-some-Cordova-pitfalls

General SQLite pitfalls

From https://www.sqlite.org/datatype3.html#section_1:

SQLite uses a more general dynamic type system.

This is generally nice to have, especially in conjunction with a dynamically typed language such as JavaScript. Here are some major SQLite data typing principles:

• From https://www.sqlite.org/datatype3.html#section_3: the CREATE TABLE SQL statement declares each column with one of the following type affinities: TEXT, NUMERIC, INTEGER, REAL, or BLOB.
• From https://www.sqlite.org/datatype3.html#section_3_1 with column type affinity determination rules: it should be possible to do CREATE TABLE with columns of almost any type name (for example: CREATE TABLE MyTable (data ABC);) and each column type affinity is determined according to pattern matching. If a declared column type name does not match any of the patterns the column has NUMERIC affinity.
• From https://www.sqlite.org/datatype3.html#section_3_2: a column with no data type name specified actually gets the BLOB affinity.

However there are some possible gotchas:

1. From https://www.sqlite.org/datatype3.html#section_3_2:

Note that a declared type of "FLOATING POINT" would give INTEGER affinity, not REAL affinity, due to the "INT" at the end of "POINT". And the declared type of "STRING" has an affinity of NUMERIC, not TEXT.

2. From ibid: a column declared as "DATETIME" has NUMERIC affinity, which gives no hint whether an INTEGER Unix time value, a REAL Julian time value, or possibly even a TEXT ISO8601 date/time string may be stored (further refs: https://www.sqlite.org/datatype3.html#section_2_2, https://www.sqlite.org/datatype3.html#section_3)

From https://groups.google.com/forum/#!topic/phonegap/za7z51_fKRw, as discussed in litehelpers/Cordova-sqlite-storage#546: it was discovered that are some more points of possible confusion with date/time. For example, there is also a datetime function that returns date/time in TEXT string format. This should be considered a case of "DATETIME" overloading since SQLite is not case sensitive. This could really become confusing if different programmers or functions consider date/time to be stored in different ways.

FUTURE TBD: Proper date/time handling will be further tested and documented at some point.

Major TODOs

• More formal documentation of API, especially for non-standard functions
• IndexedDBShim adapter
• Further cleanup of support section
• Resolve or document remaining open cordova-sqlite-storage bugs
• Resolve cordova-sqlite-help doc-todo issues and cordova-sqlite-storage doc-todo issues

For future considertion

• Auto-vacuum option
• Browser platform
• Support for extremely large records in a version such as litehelpers / Cordova-sqlite-evcore-extbuild-free (available with GPL or commercial license options)
• Integrate with some other libraries such as Sequelize, Squel.js, WebSqlSync, Persistence.js, Knex, etc.

Alternatives

Other versions

• litehelpers / cordova-sqlite-ext - version with REGEXP (Android/iOS/macOS), SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows), and pre-populated databases (all platforms Android/iOS/macOS/Windows)
• litehelpers / Cordova-sqlite-legacy-build-support - maintenance of WP8 version along with Windows 8.1/Windows Phone 8.1 and the other supported platforms Android/iOS/macOS/Windows 10; limited support for PhoneGap CLI/PhoneGap Build/plugman/Intel XDK; limited testing; limited updates
• litehelpers / Cordova-sqlcipher-adapter - supports SQLCipher for Android/iOS/macOS/Windows
• litehelpers / Cordova-sqlite-evcore-extbuild-free - Enhancements for Android: JSON and SQL statement handling implemented in C, supports larger transactions and handles large SQL batches in less than half the time as this version. Supports arbitrary database location on Android. Support for build environments such as PhoneGap Build and Intel XDK. Available with GPL or commercial license options. Also includes REGEXP (Android/iOS/macOS) and SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows).
• litehelpers / Cordova-sqlite-evplus-legacy-workers-free - version with support for web workers, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS) (with GPL or premium commercial license options)
• litehelpers / Cordova-sqlite-evplus-legacy-free - internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS) - with GPL or special commercial license options
• litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free - version with support for ATTACH, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (with GPL or special commercial license options)
• Adaptation for React Native Android and iOS: andpor / react-native-sqlite-storage
• Original version for iOS (with a slightly different transaction API): davibe / Phonegap-SQLitePlugin

Other SQLite adapter projects

• object-layer / AnySQL - Unified SQL API over multiple database engines
• samikrc / CordovaSQLite - Simpler sqlite plugin with a simpler API and browser platform
• nolanlawson / sqlite-plugin-2 - Simpler fork/rewrite
• nolanlawson / node-websql - Web SQL API implementation for Node.js
• an-rahulpandey / cordova-plugin-dbcopy - Alternative way to copy pre-populated database
• EionRobb / phonegap-win8-sqlite - WebSQL add-on for Win8/Metro apps (perhaps with a different API), using an old version of the C++ library from SQLite3-WinRT Component (as referenced by 01org / cordova-win8)
• SQLite3-WinRT Component - C++ component that provides a nice SQLite API with promises for WinJS
• 01org / cordova-win8 - old, unofficial version of Cordova API support for Windows 8 Metro that includes an old version of the C++ SQLite3-WinRT Component
• Microsoft / cordova-plugin-websql - Windows 8(+) and Windows Phone 8(+) WebSQL plugin versions in C#
• Thinkwise / cordova-plugin-websql - fork of Microsoft / cordova-plugin-websql that supports asynchronous execution
• MetaMemoryT / websql-client - provides the same API and connects to websql-server through WebSockets.

Alternative solutions

• Use phearme / cordova-ContentProviderPlugin to query content providers on Android devices
• ABB-Austin / cordova-plugin-indexeddb-async - Asynchronous IndexedDB plugin for Cordova that uses axemclion / IndexedDBShim (Browser/iOS/Android/Windows) and Thinkwise / cordova-plugin-websql - (Windows)
• Use NativeScript with its web view and [NathanaelA / nativescript-sqlite](https://github.com/Natha naelA/nativescript-sqlite) (Android and/or iOS)
• Standard HTML5 local storage
• Realm.io

Usage

Self-test functions

To verify that both the Javascript and native part of this plugin are installed in your application:

window.sqlitePlugin.echoTest(successCallback, errorCallback);

To verify that this plugin is able to open a database (named ___$$$___litehelpers___$$$___test___$$$___.db), execute the CRUD (create, read, update, and delete) operations, and clean it up properly:

window.sqlitePlugin.selfTest(successCallback, errorCallback);

IMPORTANT: Please wait for the 'deviceready' event (see below for an example).

General

• Drop-in replacement for HTML5/Web SQL API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below. Some other known deviations are documented below. Reports of any other deviations would be appreciated.
• Single-page application design is recommended.
• In case of a multi-page application the JavaScript used by each page must use sqlitePlugin.openDatabase to open the database access handle object before it can access the data.

NOTE: If a sqlite statement in a transaction fails with an error, the error handler must return false in order to recover the transaction. This is correct according to the HTML5/Web SQL API standard. This is different from the WebKit implementation of Web SQL in Android and iOS which recovers the transaction if a sql error hander returns a non-true value.

See the Sample section for a sample with detailed explanations.

Opening a database

To open a database access handle object (in the new default location):

var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'}, successcb, errorcb);

WARNING: The new "default" location value is NOT the same as the old default location and would break an upgrade for an app that was using the old default value (0) on iOS.

To specify a different location (affects iOS/macOS only):

var db = window.sqlitePlugin.openDatabase({name: 'my.db', iosDatabaseLocation: 'Library'}, successcb, errorcb);

where the iosDatabaseLocation option may be set to one of the following choices:

• default: Library/LocalDatabase subdirectory - NOT visible to iTunes and NOT backed up by iCloud
• Library: Library subdirectory - backed up by iCloud, NOT visible to iTunes
• Documents: Documents subdirectory - visible to iTunes and backed up by iCloud

WARNING: Again, the new "default" iosDatabaseLocation value is NOT the same as the old default location and would break an upgrade for an app using the old default value (0) on iOS.

ALTERNATIVE (deprecated):

• var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 1}, successcb, errorcb);

with the location option set to one the following choices (affects iOS only):

• 0 ~~(default)~~: Documents - visible to iTunes and backed up by iCloud
• 1: Library - backed up by iCloud, NOT visible to iTunes
• 2: Library/LocalDatabase - NOT visible to iTunes and NOT backed up by iCloud (same as using "default")

No longer supported (see tip below to overwrite window.openDatabase): ~~var db = window.sqlitePlugin.openDatabase("myDatabase.db", "1.0", "Demo", -1);~~

IMPORTANT: Please wait for the 'deviceready' event, as in the following example:

// Wait for Cordova to load
document.addEventListener('deviceready', onDeviceReady, false);

// Cordova is ready
function onDeviceReady() {
  var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'});
  // ...
}

The successcb and errorcb callback parameters are optional but can be extremely helpful in case anything goes wrong. For example:

window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'}, function(db) {
  db.transaction(function(tx) {
    // ...
  }, function(err) {
    console.log('Open database ERROR: ' + JSON.stringify(err));
  });
});

If any sql statements or transactions are attempted on a database object before the openDatabase result is known, they will be queued and will be aborted in case the database cannot be opened.

DATABASE NAME NOTES:

• Database file names with slash (/) character(s) are not supported and not expected to work.
• Database file names with ASCII control characters such as tab, vertical tab, carriage return, line feed, form feed, and backspace are not supported and do not work on Windows.
• Some other ASCII characters not supported and not working on Windows: * < > ? \ " |
• Database file names with emojis and other 4-octet UTF-8 characters are NOT RECOMMENDED.

OTHER NOTES:

• The database file name should include the extension, if desired.
• It is possible to open multiple database access handle objects for the same database.
• The database handle access object can be closed as described below.

Web SQL replacement tip:

To overwrite window.openDatabase:

window.openDatabase = function(dbname, ignored1, ignored2, ignored3) {
  return window.sqlitePlugin.openDatabase({name: dbname, location: 'default'});
};

iCloud backup notes

As documented in the "A User’s iCloud Storage Is Limited" section of iCloudFundamentals in Mac Developer Library iCloud Design Guide (near the beginning):

How to disable iCloud backup

Use the location or iosDatabaseLocation option in sqlitePlugin.openDatabase() to store the database in a subdirectory that is NOT backed up to iCloud, as described in the section below.

NOTE: Changing BackupWebStorage in config.xml has no effect on a database created by this plugin. BackupWebStorage applies only to local storage and/or Web SQL storage created in the WebView (not using this plugin). For reference: phonegap/build#338 (comment)

Android sqlite implementation

By default, this plugin uses Android-sqlite-connector, which is lightweight and should be more efficient than the built-in Android database classes. To use the built-in Android database classes instead:

var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default', androidDatabaseImplementation: 2});

Workaround for Android db locking issue

litehelpers/Cordova-sqlite-storage#193 was reported (as observed by a number of app developers) that when using the androidDatabaseImplementation: 2 setting on certain Android versions and if the app is stopped or aborted without closing the database then:

• (sometimes) there is an unexpected database lock
• the data that was inserted is lost.

The cause of this issue remains unknown. Of interest: android / platform_external_sqlite commit d4f30d0d15 which references and includes the sqlite commit at: http://www.sqlite.org/src/info/6c4c2b7dba

This is not an issue when the default Android-sqlite-connector database implementation is used, which is the case when no androidDatabaseImplementation setting is used.

There is an optional workaround that simply closes and reopens the database file at the end of every transaction that is committed. The workaround is enabled by opening the database with options as follows:

var db = window.sqlitePlugin.openDatabase({
  name: 'my.db',
  location: 'default',
  androidDatabaseImplementation: 2,
  androidLockWorkaround: 1
});

IMPORTANT NOTE: This workaround is only applied when using db.sqlBatch or db.transaction(), not applied when running executeSql() on the database object.

SQL transactions

The following types of SQL transactions are supported by this version:

• Single-statement transactions
• SQL batch transactions
• Standard asynchronous transactions

NOTE: Transaction requests are kept in one queue per database and executed in sequential order, according to the HTML5/Web SQL API.

WARNING: It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others. This could result in data loss if such a SQL statement list with any INSERT or UPDATE statement(s) are included. For reference: litehelpers/Cordova-sqlite-storage#551

Single-statement transactions

Sample with INSERT:

db.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value'], function (resultSet) {
  console.log('resultSet.insertId: ' + resultSet.insertId);
  console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
}, function(error) {
  console.log('SELECT error: ' + error.message);
});

Sample with SELECT:

db.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function (resultSet) {
  console.log('got stringlength: ' + resultSet.rows.item(0).stringlength);
}, function(error) {
  console.log('SELECT error: ' + error.message);
});

NOTE/minor bug: The object returned by resultSet.rows.item(rowNumber) is not immutable. In addition, multiple calls to resultSet.rows.item(rowNumber) with the same rowNumber on the same resultSet object return the same object. For example, the following code will show Second uppertext result: ANOTHER:

db.executeSql("SELECT UPPER('First') AS uppertext", [], function (resultSet) {
  var obj1 = resultSet.rows.item(0);
  obj1.uppertext = 'ANOTHER';
  console.log('Second uppertext result: ' + resultSet.rows.item(0).uppertext);
  console.log('SELECT error: ' + error.message);
});

SQL batch transactions

Sample:

db.sqlBatch([
  'DROP TABLE IF EXISTS MyTable',
  'CREATE TABLE MyTable (SampleColumn)',
  [ 'INSERT INTO MyTable VALUES (?)', ['test-value'] ],
], function() {
  db.executeSql('SELECT * FROM MyTable', [], function (resultSet) {
    console.log('Sample column value: ' + resultSet.rows.item(0).SampleColumn);
  });
}, function(error) {
  console.log('Populate table error: ' + error.message);
});

In case of an error, all changes in a sql batch are automatically discarded using ROLLBACK.

Standard asynchronous transactions

Standard asynchronous transactions follow the HTML5/Web SQL API which is very well documented and uses BEGIN and COMMIT or ROLLBACK to keep the transactions failure-safe. Here is a simple example:

db.transaction(function(tx) {
  tx.executeSql('DROP TABLE IF EXISTS MyTable');
  tx.executeSql('CREATE TABLE MyTable (SampleColumn)');
  tx.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value'], function(tx, resultSet) {
    console.log('resultSet.insertId: ' + resultSet.insertId);
    console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
  }, function(tx, error) {
    console.log('INSERT e