Cordova/PhoneGap sqlite storage - free enterprise version with performance improvements for Android and extra features for PhoneGap Build
Native SQLite component with API based on HTML5/Web SQL (DRAFT) API for the following platforms:
- Android
- iOS
- macOS ("osx" platform)
- Windows 10 (UWP) DESKTOP ONLY, with ARM CPU support removed again from this plugin version (see below for major limitations)
This plugin version uses a special, non-standard Android NDK sqlite database access library (C-language implementation), with some premium improvements to the internal JSON interface between the Javascript and native Android implementation, to provide significant performance and memory usage improvements on the Android platform.
This plugin version is available under GPL v3 (https://www.gnu.org/licenses/gpl-3.0.txt) or commercial license options and includes components available under the MIT and Apache 2.0 licenses listed in LICENSE.md. Contact for commercial license: sales@litehelpers.net
NOTE: Commercial licenses for litehelpers / Cordova-sqlite-enterprise-free are valid for this plugin version as well.
- Multiple SQLite corruption problem - see section below &
xpbrew/cordova-sqlite-storage#626
- Breaking changes coming soon - see section nearby & see
xpbrew/cordova-sqlite-storage#922
Free license terms | Commercial license & support | |
---|---|---|
cordova-sqlite-storage - core plugin version |
MIT (or Apache 2.0 on Android & Windows) | |
cordova-sqlite-express-build-support - using built-in SQLite libraries on Android, iOS, and macOS |
MIT (or Apache 2.0 on Android & Windows) | |
cordova-sqlite-ext - with extra features including BASE64, REGEXP, and pre-populated databases |
MIT (or Apache 2.0 on Android & Windows) | |
cordova-sqlite-evcore-extbuild-free - plugin version with lighter resource usage in Android NDK |
GPL v3 | available, see https://xpbrew.consulting/ |
cordova-plugin-sqlite-evplus-ext-common-free - includes workaround for extra-large result data on Android and lighter resource usage on iOS, macOS, and in Android NDK |
GPL v3 | available, see https://xpbrew.consulting/ |
New SQLite plugin design with a simpler API is in progress with a working demo - see brodybits/ask-me-anything#3
in an upcoming major release - see xpbrew/cordova-sqlite-storage#922
some highlights:
- error
code
will always be0
(which is already the case on Windows); actual SQLite3 error code will be part of the errormessage
member whenever possible (seexpbrew/cordova-sqlite-storage#821
) - drop support for location: 0-2 values in openDatabase call (please use
location: 'default'
oriosDatabaseLocation
setting in openDatabase as documented below) - throw an exception in case of
androidDatabaseImplementation: 2
setting which is now superseded byandroidDatabaseProvider: 'system'
setting
under consideration:
- remove
androidLockWorkaround: 1
option if not needed any longer -xpbrew/cordova-sqlite-storage#925
Free enterprise version with Android performance improvements and other features with sqlite3 dependencies included, working with PhoneGap Build.
This plugin uses non-standard android-sqlite-evcore-ndk-driver-free sqlite database access implementation on Android. In case an application access the SAME database using multiple plugins there is a risk of data corruption ref: storesafe/cordova-sqlite-storage#626 as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html.
The workaround is to use the androidDatabaseProvider: 'system'
setting as described in the Android database provider section below:
var db = window.sqlitePlugin.openDatabase({
name: 'my.db',
location: 'default',
androidDatabaseProvider: 'system'
});
This plugin version also uses a fixed version of sqlite3 on iOS, macOS, and Windows. In case the application accesses the SAME database using multiple plugins there is a risk of data corruption as described in https://www.sqlite.org/howtocorrupt.html (similar to the multiple sqlite problem for Android as described in http://ericsink.com/entries/multiple_sqlite_problem.html).
To open a database:
var db = null;
document.addEventListener('deviceready', function() {
db = window.sqlitePlugin.openDatabase({
name: 'my.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 DRAFT 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');
});
or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:
db.transaction(function(tx) {
tx.executeSql('CREATE TABLE IF NOT EXISTS DemoTable (name, score)');
tx.executeSql('INSERT INTO DemoTable VALUES (?1,?2)', ['Alice', 101]);
tx.executeSql('INSERT INTO DemoTable VALUES (?1,?2)', ['Betty', 202]);
}, function(error) {
console.log('Transaction ERROR: ' + error.message);
}, function() {
console.log('Populated database OK');
});
To check the data using the DRAFT 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);
});
or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:
db.sqlBatch([
'CREATE TABLE IF NOT EXISTS DemoTable (name, score)',
[ 'INSERT INTO DemoTable VALUES (?1,?2)', ['Alice', 101] ],
[ 'INSERT INTO DemoTable VALUES (?1,?2)', ['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 (using the DRAFT standard transaction API).
- Patches will not be accepted on this plugin version due to some possible licensing issues.
- This plugin is not supported by PhoneGap Developer App or PhoneGap Desktop App.
- This plugin version includes the SQLite and Android-sqlite-evcore-native-driver-free dependencies to work with PhoneGap Build and other some other build systems such as Cordova Plugman, PhoneGap CLI, and Intel XDK.
- A recent version of the Cordova CLI is recommended. Known issues with older versions of Cordova:
- Cordova pre-7.0.0 do not automatically save the state of added plugins and platforms (
--save
flag is needed for Cordova pre-7.0.0) - It may be needed to use
cordova prepare
in case of cordova-ios pre-4.3.0 (Cordova CLI6.4.0
). - Cordova versions older than
6.0.0
are missing thecordova-ios@4.0.0
security fixes.
- Cordova pre-7.0.0 do not automatically save the state of added plugins and platforms (
- This plugin version includes the following extra (non-standard) features:
- BASE64 and BLOBFROMBASE64 integrated from brodybits / sqlite3-base64, using brodybits / libb64-core (based on http://libb64.sourceforge.net/ by Chris Venter, public domain)
- REGEXP for Android (default Android-sqlite-connector database implementation), iOS, and macOS using brodybits / sqlite3-regexp-cached (based on http://git.altlinux.org/people/at/packages/?p=sqlite3-pcre.git by Alexey Tourbin, public domain)
- SQLite
3.40.0
included when building (all platforms), with the following compile-time definitions:SQLITE_THREADSAFE=1
SQLITE_DEFAULT_SYNCHRONOUS=3
(EXTRA DURABLE build setting) ref: xpbrew/cordova-sqlite-storage#736SQLITE_LOCKING_STYLE=1
on iOS/macOS ONLYHAVE_USLEEP=1
(iOS/macOS/Windows)SQLITE_DEFAULT_MEMSTATUS=0
SQLITE_OMIT_DECLTYPE
SQLITE_OMIT_DEPRECATED
SQLITE_OMIT_PROGRESS_CALLBACK
SQLITE_OMIT_SHARED_CACHE
SQLITE_OMIT_LOAD_EXTENSION
SQLITE_TEMP_STORE=2
SQLITE_ENABLE_FTS3
SQLITE_ENABLE_FTS3_PARENTHESIS
SQLITE_ENABLE_FTS4
SQLITE_ENABLE_FTS5
SQLITE_ENABLE_RTREE
SQLITE_ENABLE_JSON1
SQLITE_ENABLE_RTREE
SQLITE_DEFAULT_PAGE_SIZE=4096
- new default page size ref: http://sqlite.org/pgszchng2016.htmlSQLITE_DEFAULT_CACHE_SIZE=-2000
- new default cache size ref: http://sqlite.org/pgszchng2016.htmlSQLITE_OS_WINRT
(Windows only)NDEBUG
on Windows (Release build only)
SQLITE_DBCONFIG_DEFENSIVE
flag is used for extra SQL safety on all platforms Android/iOS/macOS/Windows ref:- The iOS database location is now mandatory, as documented below.
- This version branch supports the use of two (2) possible Android sqlite database implementations:
- default: high-performance, lightweight
android-sqlite-evcore-ndk-driver-free
NDK library (C-language implementation) - optional: Android system database implementation, using the
androidDatabaseProvider: 'system'
setting insqlitePlugin.openDatabase()
call as described in the Android database provider section below.
- default: high-performance, lightweight
- The following feature is available in brodybits / cordova-sqlite-ext (with permissive license terms, missing performance enhancements from
android-sqlite-evcore-ndk-driver-free
), MISSING in this plugin version:- Pre-populated database (Android/iOS/macOS/Windows)
- Windows platform version using a customized version of the performant doo / SQLite3-WinRT C++ component based on the brodybits/SQLite3-WinRT sync-api-fix branch, with the following known limitations:
- This plugin version branch has dependency on platform toolset libraries included by Visual Studio 2017 ref: xpbrew/cordova-sqlite-storage#580. Visual Studio 2015 is now supported by
brodybits/cordova-sqlite-legacy
(permissive license terms, no performance enhancements for Android) andbrodybits/cordova-sqlite-evcore-legacy-ext-common-free
(GPL or commercial license terms, with performance enhancements for Android). UNTESTED workaround for Visual Studio 2015: it may be possible to support this plugin version on Visual Studio 2015 Update 3 by installing platform toolset v141.) - Visual Studio components needed: Universal Windows Platform development, C++ Universal Windows Platform tools. A recent version of Visual Studio 2017 will offer to install any missing feature components.
- Target Windows version:
10.0.17763.0
(Windows 10 build 17763 aka October 2018 Update or version 1809) ref: https://docs.microsoft.com/en-us/windows/uwp/whats-new/windows-10-build-17763 - Minimum Windows version
10.0.15063.0
(Windows 10 build 15063 aka Creators Update or version 1703) ref: https://docs.microsoft.com/en-us/windows/uwp/whats-new/windows-10-build-15063 - 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.
- ARM target CPU support removed again from this plugin version
- The
SQLite3-WinRT
component insrc/windows/SQLite3-WinRT-sync
is based on doo/SQLite3-WinRT commit f4b06e6 from 2012, which is missing the asynchronous C++ API improvements. There is no background processing on the Windows platform. - Truncation issue with UNICODE
\u0000
character (same as\0
) - INCONSISTENT error code (0) and INCORRECT error message (missing actual error info) in error callbacks ref: xpbrew/cordova-sqlite-storage#539
- Not possible to SELECT BLOB column values directly. It is recommended to use built-in HEX function to retrieve BLOB column values, which should work consistently across all platform implementations as well as (WebKit) Web SQL. Non-standard BASE64 function to SELECT BLOB column values in Base64 format is supported by
brodybits/cordova-sqlite-ext
(permissive license terms) and litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms). - Windows platform version uses
UTF-16le
internal database encoding while the other platform versions useUTF-8
internal encoding. (UTF-8
internal encoding is preferred ref: xpbrew/cordova-sqlite-storage#652) - Known issue with database names that contain certain US-ASCII punctuation and control characters (see below)
- This plugin version branch has dependency on platform toolset libraries included by Visual Studio 2017 ref: xpbrew/cordova-sqlite-storage#580. Visual Studio 2015 is now supported by
- The macOS platform version ("osx" platform) is not tested in a release build and should be considered pre-alpha with known issues:
cordova prepare osx
is needed before building and running from Xcode- known issue between
cordova-osx
and Cordova CLI10.0.0
: apache/cordova-osx#106
- Android versions supported: minimum 5.1, see also: https://cordova.apache.org/docs/en/latest/guide/platforms/android/
- iOS versions supported: 8.x / 9.x / 10.x / 11.x / 12.x (see deviations section below for differences in case of WKWebView)
- FTS3, FTS4, and R-Tree are fully tested and supported for all target platforms in this version branch.
- Default
PRAGMA journal_mode
setting (tested):- Android use of the
androidDatabaseProvider: 'system'
setting:persist
(pre-8.0) /truncate
(Android 8.0, 8.1) /wal
(Android Pie) - otherwise:
delete
- Android use of the
- AUTO-VACUUM is not enabled by default. If no form of
VACUUM
orPRAGMA auto_vacuum
is used then sqlite will automatically reuse deleted data space for new data but the database file will never shrink. For reference: http://www.sqlite.org/pragma.html#pragma_auto_vacuum and xpbrew/cordova-sqlite-storage#646
- Custom Android database location (supports external storage directory)
- For Android platform this plugin version uses the lightweight, performant
android-sqlite-evcore-ndk-driver-free
database access implementation, with some premium improvements to the internal JSON interface (by default configuration), now with a solution for Android 11 devices and target SDK 30 (FIXES storesafe/cordova-sqlite-evcore-extbuild-free#56). Theandroid-sqlite-evcore-ndk-driver-free
is a NDK library (with C-language implementation) for JSON and SQL statement handling which processes large batches in less than half the time compared tocordova-sqlite-storage
, as measured by:brodybits/cordova-sqlite-perftest
. - This plugin version includes the following extra (non-standard) features: BASE 64 (all platforms Android/iOS/macOS/Windows), REGEXP (Android/iOS/macOS)
- Using version of SQLite3 (...) with window functions and recent security updates:
- Using
SQLITE_DEFAULT_SYNCHRONOUS=3
(EXTRA DURABLE) build setting to be extra robust against possible database corruption ref: xpbrew/cordova-sqlite-storage#736 SQLITE_DBCONFIG_DEFENSIVE
flag is used for extra SQL safety, as described above- Recent build fixes:
- Fixed iOS/macOS platform version to use custom version of PSPDFThreadSafeMutableDictionary.m to avoid threading issue, custom version to avoid potential conflicts with custom iOS/macOS plugins ref: xpbrew/cordova-sqlite-storage#716, xpbrew/cordova-sqlite-storage#861
- workaround for redefinition of
SYNTAX_ERR
when using some other plugins ref: xpbrew/cordova-sqlite-storage#868
- Nice overview of alternatives for storing local data in Cordova apps at: https://www.sitepoint.com/storing-local-data-in-a-cordova-app/
- New alternative solution for small data storage: TheCocoaProject / cordova-plugin-nativestorage - simpler "native storage of variables" for Android/iOS/Windows
- Resolved Java 6/7/8 concurrent map compatibility issue reported in xpbrew/cordova-sqlite-storage#726, with no more static state in evcore plugin version, THANKS to pointer by @NeoLSN (Jason Yang/楊朝傑) in xpbrew/cordova-sqlite-storage#727.
- Updated workaround solution to BUG 666 (xpbrew/cordova-sqlite-storage#666) (possible transaction issue after window.location change with possible data loss): close database if already open before opening again
- Windows 10 (UWP) build with /SAFESEH flag on Win32 (x86) target to specify "Image has Safe Exception Handlers" as described in https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers
- This plugin version references Windows platform toolset v141 to support Visual Studio 2017 ref: xpbrew/cordova-sqlite-storage#580. (Visual Studio 2015 is now supported by
brodybits/cordova-sqlite-legacy
(permissive license terms, no performance enhancements for Android) andbrodybits/cordova-sqlite-evcore-legacy-ext-common-free
(GPL or commercial license terms, with performance enhancements for Android). UNTESTED workaround for Visual Studio 2015: it may be possible to support this plugin version on Visual Studio 2015 Update 3 by installing platform toolset v141.) - The brodybits / cordova-sqlite-test-app project is a CC0 (public domain) starting point (NOTE that this plugin must be added) and may also be used to reproduce issues with this plugin.
- This plugin version includes the following extra features: BASE64 (all platforms Android/iOS/macOS/Windows), REGEXP (Android/iOS/macOS)
- The Lawnchair adapter is now moved to litehelpers / cordova-sqlite-lawnchair-adapter.
- This plugin version now supports SELECT BLOB data in Base64 format on all platforms in addition to REGEXP (Android/iOS/macOS)
and pre-populated database (all platforms - FUTURE TODO). - brodybits / sql-promise-helper provides a Promise-based API wrapper.
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
- Published brodybits / Cordova-quick-start-checklist and brodybits / Avoiding-some-Cordova-pitfalls.
- Self-test functions to verify proper installation and operation of this plugin
- More explicit
openDatabase
anddeleteDatabase
iosDatabaseLocation
option - Added straightforward sql batch function
- MetaMemoryT / websql-promise now provides a Promises-based interface to both (WebKit) Web SQL and this plugin
- SQLCipher for Android/iOS/macOS/Windows is supported by brodybits / cordova-sqlcipher-adapter - WITHOUT the evcore performance improvements for Android (plugin version with SQLCipher support together with evcore performance for Android may be published if there is sufficient interest from the user community)
- Drop-in replacement for HTML5/Web SQL (DRAFT) API: the only change should be to replace the static
window.openDatabase()
factory call withwindow.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 (DRAFT) API)
- Transaction API (based on HTML5/Web SQL (DRAFT) API) is designed for maximum flexiblibility, does not allow any transactions to be left hanging open.
- As described in this posting:
- Keeps sqlite database in known, platform specific user data location on all supported platforms (Android/iOS/macOS/Windows), which can be reconfigured on Android, iOS, and 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 validated for multi-page applications by internal test selfTest function.
- This project is self-contained. 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: brodybits / 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.
- 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:
- In case of extra-old Cordova CLI pre-7.0, it is recommended to use the
--save
flag when installing plugins to add them toconfig.xml
/package.json
. (This is automatic starting with Cordova CLI 7.0.) - Assuming that all plugins are added to
config.xml
orpackage.json
, there is no need to commit theplugins
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.
Use of this plugin on the Windows platform is not always straightforward, due to the need to build the internal SQLite3 C++ library. 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 subsection (under 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.
Use the following command to install this plugin version from the Cordova CLI:
cordova plugin add cordova-sqlite-evcore-extbuild-free # --save option *recommended* for Cordova CLI pre-7.0
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.
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.)
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);
});
});
});
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: sales@xpbrew.consulting
Simple example:
- brodybits / cordova-sqlite-storage-starter-app (using
cordova-sqlite-storage
plugin version)
Tutorials:
- https://codesundar.com/cordova-sqlite-storage/ (using
cordova-sqlite-storage
plugin version with JQuery)
PITFALL WARNING: A number of tutorials show up in search results that use Web SQL database instead of this plugin.
WANTED: simple, working CRUD tutorial sample ref: xpbrew/cordova-sqlite-storage#795
- http://www.tutorialspoint.com/sqlite/index.htm with a number of helpful articles
- ExplorOz Traveller App for Android and iOS
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.
As "strongly recommended" by Web SQL Database API 8.5 SQL injection:
Authors are strongly recommended to make use of the
?
placeholder feature of theexecuteSql()
method, and to never construct SQL statements on the fly.
- 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.
- The
window.sqlitePlugin.openDatabase
static factory call takes a different set of parameters than the standard Web SQLwindow.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: xpbrew/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 (DRAFT) API section 5. The iOS WebKit Web SQL implementation seems to support this as well. - Unlike the HTML5/Web SQL (DRAFT) 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 likenull
by this plugin on Android and iOS ref: xpbrew/cordova-sqlite-storage#405 - Positive and negative
Infinity
result values cause a crash on iOS/macOS cases ref: xpbrew/cordova-sqlite-storage#405 - Known issue(s) with of certain ASCII/UNICODE characters as described below.
- Boolean
true
andfalse
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: xpbrew/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.
- Error is reported with error code of
0
on Windows as well as Android with theandroidDatabaseProvider: 'system'
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 byINSERT INTO MyTable VALUES (X'40414243')
are not consistent on Android with use ofandroidDatabaseProvider: 'system'
setting 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
, or1234567890123
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 by this plugin on iOS with WKWebView (using cordova-plugin-wkwebview-engine) or macOS ("osx"). This is evident in certain test operations such asSELECT ? as myresult
orSELECT 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 with use of theandroidDatabaseProvider: 'system'
setting. (This is evident in certain test operations such asSELECT ? as myresult
orSELECT 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)
ortransaction.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 theconstructor
does not point toArray
then the SQL arguments are ignored by the plugin. - The results data objects are not immutable as specified/implied by Web SQL (DRAFT) API section 4.5.
- This plugin supports use of numbered parameters (
?1
,?2
, etc.) as documented in https://www.sqlite.org/c3ref/bind_blob.html, not supported by HTML5/Web SQL (DRAFT) API ref: Web SQL (DRAFT) API section 4.2. - In case of UPDATE this plugin reports
insertId
with the result ofsqlite3_last_insert_rowid()
(except for Android withandroidDatabaseProvider: 'system'
setting) while attempt to accessinsertId
on the result set database opened by HTML5/Web SQL (DRAFT) API results in an exception.
See Security of sensitive data in the Security section above.
- FTS3 is not consistently supported by (WebKit) Web SQL on Android/iOS.
- FTS4 and R-Tree are not consistently supported by (WebKit) Web SQL on Android/iOS or desktop browser.
- 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 and less descriptive on Android in case of the default
android-sqlite-evcore-ndk-driver-free
implementation. - There are some other differences in the SQL error messages reported by WebKit Web SQL and this plugin.
- Possible crashes with certain cases of invalid binary string data on Android
- The iOS/macOS platform versions do not support certain rapidly repeated open-and-close or open-and-delete test scenarios due to how the implementation handles background processing
- The default
android-sqlite-evcore-ndk-driver-free
database access implementation does not currently handle control characters such as vertical tab, form feed, or backspace characters properly ref: storesafe/cordova-sqlite-evcore-extbuild-free#28 - 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: xpbrew/cordova-sqlite-storage#551
- Execution of INSERT statement that affects multiple rows (due to SELECT cause or using TRIGGER(s), for example) reports incorrect rowsAffected on Android with use of the
androidDatabaseProvider: 'system'
setting. - FIXED in this plugin version:
Memory issue observed when adding a large number of records due to the JSON implementation which is improved in storesafe / cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms) - 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: xpbrew/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 xpbrew/cordova-sqlite-storage#196). The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).
- Hanging transactions in case of special JSON characters in result columns ref: storesafe/cordova-sqlite-evcore-extbuild-free#51
- SQL errors are reported with incorrect & inconsistent error message on Windows - error message info not always correct, see also storesafe/cordova-sqlite-storage#539
- Incorrect handling of NULL characters (
'\0\
or'\u0000'
) on Android (defaultandroid-sqlite-evcore-ndk-driver-free
database access implementation) and Windows ref: storesafe/cordova-sqlite-evcore-extbuild-free#27 - 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.
Some additional issues are tracked in open cordova-sqlite-storage bug-general issues and open cordova-sqlite-evcore-extbuild-free bug-general issues.
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. It is recommended to store images and similar binary data in separate files. TBD: specify maximum record. For future consideration: support in this plugin version (GPL or commercial license terms).
- 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/iOS/macOS in litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free (GPL or special premium commercial license terms).
- 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 reported by 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 on 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 (GPL or special commercial license terms) as well as litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free (GPL or premium commercial license terms). - SELECT BLOB column value type is not supported consistently across all platforms (not supported on Windows). It is recommended to use the built-in HEX function to SELECT BLOB column data in hexadecimal format, working consistently across all platforms. As an alternative: SELECT BLOB in Base64 format using BASE64 function (described elsewhere in this document) is supported by this plugin version (GPL or commercial license options, as documented above) as well as brodybits / cordova-sqlite-ext (permissive license terms). INLINE BLOB values such as
X'010203'
are supported by the SQLite syntax on all platforms. FUTURE TBD equivalent to UNHEX (supported in MySQL) or conversion of Base-64 string to BLOB is desired. - Database files with certain multi-byte UTF-8 characters are not well tested and not expected to work consistently across all platform implementations. The default
android-sqlite-evcore-ndk-driver-free
database access implementation may not function properly on certain Android versions in case of database file names with emoji and other 4-byte UTF-8 characters ref: storesafe/cordova-sqlite-evcore-extbuild-free#26 - Issues with UNICODE
\u0000
character (same as\0
):- Truncation in case of argument value with UNICODE
\u0000
character reproduced on (WebKit) Web SQL; known issues with this plugin version as referenced above on Android (defaultandroid-sqlite-evcore-native-driver-free
database access implementation) and Windows (storesafe/cordova-sqlite-evcore-extbuild-free#27) - SQL error reported in case of inline value string with with UNICODE
\u0000
character on (WebKit) Web SQL, plugin on Android with use of theandroidDatabaseProvider: 'system'
setting, and plugin on some other platforms
- Truncation in case of argument value with UNICODE
- 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 extreme large query results may be slow, especially on iOS/macOS, due to the JSON implementation. Improvements for iOS/macOS are available in litehelpers / cordova-sqlite-evplus-ext-legacy-build-free and litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free (GPL or special commercial license terms). FUTURE (TODO) will be available in a newer evplus plugin version (GPL or special commercial license terms).
- ATTACH to another database file is not supported by this version branch. 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 (GPL or special commercial license terms). - UPDATE/DELETE with LIMIT or ORDER BY is not supported.
- WITH clause is not supported on some older Android platform versions in case the
androidDatabaseProvider: 'system'
setting 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.
- Issues have been reported with using this plugin together with Crosswalk for Android, especially on
x86_64
CPU (xpbrew/cordova-sqlite-storage#336). Please see xpbrew/cordova-sqlite-storage#336 (comment) for workaround on x64 CPU. In addition it may be helpful to install Crosswalk as a plugin instead of using Crosswalk to create a project that will use this plugin. - 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. - Does not support named parameters (
?NNN
/:AAA
/@AAAA
/$AAAA
parameter placeholders as documented in https://www.sqlite.org/lang_expr.html#varparam and https://www.sqlite.org/c3ref/bind_blob.html) ref: xpbrew/cordova-sqlite-storage#717 - User defined functions not supported, due to problems described in xpbrew/cordova-sqlite-storage#741
Additional limitations are tracked in open cordova-sqlite-storage doc-todo issues and open cordova-sqlite-evcore-extbuild-free doc-todo issues.
- Integration with PhoneGap developer app
- Use within InAppBrowser
- Use within an iframe (see xpbrew/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
- UNICODE characters not fully tested
- ORDER BY RANDOM() (ref: xpbrew/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: xpbrew/cordova-sqlite-storage#627
- More emojis and other 4-octet UTF-8 characters
- More database file names with some more control characters and multi-byte UTF-8 characters (including emojis and other 4-byte UTF-8 characters)
- Use of numbered parameters (
?1
,?2
, etc.) as documented in https://www.sqlite.org/c3ref/bind_blob.html - Use of
?NNN
/:AAA
/@AAAA
/$AAAA
parameter placeholders as documented in https://www.sqlite.org/lang_expr.html#varparam and https://www.sqlite.org/c3ref/bind_blob.html) (currently NOT supported by this plugin) ref: xpbrew/cordova-sqlite-storage#717 - Single-statement and SQL batch transaction calls with invalid arguments (TBD behavior subject to change)
- Plugin vs (WebKit) Web SQL transaction behavior in case of an error handler which returns various falsy vs truthy values
- Other open cordova-sqlite-storage testing issues and open cordova-sqlite-evcore-extbuild-free testing issues
- In case of issues with code that follows the asynchronous Web SQL transaction API, it is possible to test with a test database using
window.openDatabase
for comparison with (WebKit) Web SQL. - 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.
IMPORTANT: A number of tutorials and samples in search results suffer from the following pitfall:
- 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 thesqlBatch
call would not be available.
- Updates such as database schema changes, migrations from use of Web SQL, migration between data storage formats must be handled with extreme care. It is generally extremely difficult or impossible to predict when users will install application updates. Upgrades from old database schemas and formats must be supported for a very long time.
- 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 (DRAFT) 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. If no form of
VACUUM
orPRAGMA auto_vacuum
is used then sqlite will automatically reuse deleted data space for new data but the database file will never shrink. For reference: http://www.sqlite.org/pragma.html#pragma_auto_vacuum and xpbrew/cordova-sqlite-storage#646 - Transactions on a database are run sequentially. A large transaction could block smaller transactions requested afterwards.
- intent whitelist: blocked intent such as external URL intent may cause this and perhaps certain Cordova plugin(s) to misbehave (see xpbrew/cordova-sqlite-storage#396)
- Angular/ngCordova/Ionic controller/factory/service callbacks may be triggered before the 'deviceready' event is fired
- As discussed in xpbrew/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: xpbrew/cordova-sqlite-storage#613
- 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 plugin version. Visual Studio 2015 is now supported by
brodybits/cordova-sqlite-legacy
(for Windows 8.1, Windows Phone 8.1, and Windows 10 builds).
Documented in: brodybits / Avoiding-some-Cordova-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:
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.
- 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 xpbrew/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.
- More formal documentation of API, especially for non-standard functions
- IndexedDBShim adapter (possibly based on IndexedDBShim)
- Further cleanup of support section
- Resolve or document open cordova-sqlite-storage bug-general issues and open cordova-sqlite-evcore-extbuild-free bug-general issues
- Resolve cordova-sqlite-storage-help doc-todo issues, open cordova-sqlite-storage doc-todo issues, and open cordova-sqlite-evcore-extbuild-free doc-todo issues
- Resolve open cordova-sqlite-storage testing issues and open cordova-sqlite-evcore-extbuild-free testing issues
- Explicit auto-vacuum option ref: xpbrew/cordova-sqlite-storage#646
- Support for extremely large records in a plugin 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.
xpbrew/cordova-sqlite-storage
- core plugin version for Android/iOS/macOS/Windows (permissive license terms)brodybits/cordova-sqlite-ext
- plugin 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). Permissive license terms.brodybits/cordova-sqlite-legacy
- support for Windows 8.1/Windows Phone 8.1 along with Android/iOS/macOS/Windows 10, with support for 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). Limited updates. Permissive license terms.brodybits/cordova-sqlite-legacy-build-support
- maintenance of WP8 platform 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. Permissive license terms.brodybits/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 plugin version. Supports arbitrary database location on Android. Support for build environments such as PhoneGap Build and Intel XDK. Also includes REGEXP (Android/iOS/macOS) and SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows). GPL or commercial license terms.
- litehelpers / cordova-sqlite-evplus-ext-legacy-build-free - internal memory improvements to support larger transactions (Android/iOS/macOS) and fix to support all Unicode characters (iOS). (GPL or special commercial license terms).
- litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free - plugin version with support for ATTACH, includes internal memory improvements to support larger transactions (Android/iOS/macOS) and fix to support all Unicode characters (GPL or special commercial license terms).
- litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free - plugin version with support for web workers, includes internal memory improvements to support larger transactions (Android/iOS/macOS) and fix to support all Unicode characters (iOS). (GPL or special premium commercial license terms).
- Adaptation for React Native Android and iOS: andpor / react-native-sqlite-storage (permissive license terms)
- Original plugin version for iOS (with a non-standard, outdated transaction API): davibe / Phonegap-SQLitePlugin (permissive license terms)
- 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 (DRAFT 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.
- https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API available on newer Android/iOS/Windows versions, please see best practices at https://developers.google.com/web/fundamentals/instant-and-offline/web-storage/indexeddb-best-practices
- TheCocoaProject/ cordova-plugin-nativestorage - simpler "native storage of variables" (small data storage) for Android/iOS/macOS/Windows (TBD browser support?)
- 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 (Android and/or iOS)
- Standard HTML5 local storage
- Realm.io
- Other Cordova storage alternatives described at:
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).
- Drop-in replacement for HTML5/Web SQL (DRAFT) API: the only change should be to replace the static
window.openDatabase()
factory call withwindow.sqlitePlugin.openDatabase()
, with parameters as documented below. Some other known deviations are described throughout this document. 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 (DRAFT) 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 truthy value.
See the Sample section for a sample with detailed explanations.
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 different from the old default location used until March 2016 and would break an upgrade for an app that was using the old default setting (location: 0
, same as using iosDatabaseLocation: 'Documents'
) on iOS. The recommended solution is to continue to open the database from the same location, using iosDatabaseLocation: 'Documents'
.
WARNING 2: As described above: by default this plugin uses a non-standard android-sqlite-evcore-ndk-driver-free
sqlite database access implementation on Android. In case an application access the same database using multiple plugins there is a risk of data corruption (ref: storesafe/cordova-sqlite-storage#626) as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html. The workaround is to use the androidDatabaseProvider: 'system'
setting as described in the Android sqlite implementation section below.
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 iCloudLibrary
:Library
subdirectory - backed up by iCloud, NOT visible to iTunesDocuments
:Documents
subdirectory - visible to iTunes and backed up by iCloud
To specify a external or another custom Android database location (with help from cordova-plugin-file):
window.resolveLocalFileSystemURL(cordova.file.externalDataDirectory, function(externalDataDirectoryEntry) {
var db = window.sqlitePlugin.openDatabase({name: 'external.db', androidDatabaseLocation: externalDataDirectoryEntry.toURL()});
db.transaction(function(tx) {
tx.executeSql('CREATE TABLE IF NOT EXISTS MyTable (data)');
tx.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value']);
}, function(error) {
console.log('Populate database error: ' + error.message);
}, function() {
db.transaction(function(tx) {
tx.executeSql('SELECT data from MyTable', [], function(tx_ignored, resultSet) {
console.log('Record count: ' + resultSet.rows.length);
for (var i=0; i<resultSet.rows.length; ++i)
console.log('index: ' + i + ' value: ' + resultSet.rows.item(i).data);
});
}, function(error) {
console.log('Populate database error: ' + error.message);
});
});
});
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.
DEPRECATED ALTERNATIVE to be removed in an upcoming release:
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 iCloud1
:Library
- backed up by iCloud, NOT visible to iTunes2
: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 on any platform. - Database file names with ASCII control characters such as tab, vertical tab, carriage return, line feed, form feed, and backspace are NOT RECOMMENDED, with known issue on Windows.
- Some other ASCII characters NOT RECOMMENDED, with known issue on Windows:
*
<
>
?
\
"
|
- Database file names with multi-byte UTF-8 characters are currently not recommended due to very limited testing.
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'
});
};
As documented in the "A User’s iCloud Storage Is Limited" section of iCloudFundamentals in Mac Developer Library iCloud Design Guide (near the beginning):
- iCloudFundamentals in Mac Developer Library iCloud Design Guide
- DO store the following in iCloud:
- [other items omitted]
- Change log files for a SQLite database (a SQLite database’s store file must never be stored in iCloud)
- DO NOT store the following in iCloud:
- [items omitted]
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)
By default, this plugin uses android-sqlite-evcore-ndk-driver-free
with the performance and memory usage enhancements. To use the built-in Android system database provider implementation instead:
var db = window.sqlitePlugin.openDatabase({
name: 'my.db',
location: 'default',
androidDatabaseProvider: 'system'
});
(Use of the androidDatabaseImplementation: 2
setting which is now replaced by androidDatabaseProvider: 'system'
is now deprecated and may be removed in the near future.)
IMPORTANT:
- As described above: by default this plugin uses a non-standard
android-sqlite-evcore-ndk-driver-free
database access implementation on Android. In case an application access the same database using multiple plugins there is a risk of data corruption ref: storesafe/cordova-sqlite-storage#626 as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html. The workaround is to use theandroidDatabaseProvider: 'system'
setting as described here. - In case of the
androidDatabaseProvider: 'system'
setting, xpbrew/cordova-sqlite-storage#193 reported (as observed by a number of app developers in the past) that in certain Android versions, if the app is stopped or aborted without closing the database then there is an unexpected database lock and the data that was inserted is lost. The workaround is described below.
xpbrew/cordova-sqlite-storage#193 reported (as observed by a number of app developers in the past) that when using the Android system database provider (using the androidDatabaseProvider: 'system'
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-evcore-ndk-driver-free
database implementation is used, which is the case when no androidDatabaseProvider
or 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',
androidDatabaseProvider: 'system'
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.
The following types of SQL transactions are supported by this plugin version:
- Single-statement transactions
- SQL batch transactions
- DRAFT Standard asynchronous transactions
NOTE: Transaction requests are kept in one queue per database and executed in sequential order, according to the HTML5/Web SQL (DRAFT) 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: xpbrew/cordova-sqlite-storage#551
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);
});
or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:
db.executeSql('INSERT INTO MyTable VALUES (?1)', ['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);
});
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);
});
or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:
db.sqlBatch([
'CREATE TABLE MyTable IF NOT EXISTS (name STRING, balance INTEGER)',
[ 'INSERT INTO MyTable VALUES (?1,?2)', ['Alice', 100] ],
[ 'INSERT INTO MyTable VALUES (?1,?2)', ['Betty', 200] ],
], function() {
console.log('MyTable is now populated.');
}, 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.
DRAFT standard asynchronous transactions follow the HTML5/Web SQL (DRAFT) 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 error: ' + error.message);
});
}, function(error) {
console.log('transaction error: ' + error.message);
}, function() {
console.log('transaction ok');
});
or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:
db.transaction(function(tx) {
tx.executeSql('DROP TABLE IF EXISTS MyTable');
tx.executeSql('CREATE TABLE MyTable (SampleColumn)');
tx.executeSql('INSERT INTO MyTable VALUES (?1)', ['test-value'], function(tx, resultSet) {
console.log('resultSet.insertId: ' + resultSet.insertId);
console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
}, function(tx, error) {
console.log('INSERT error: ' + error.message);
});
}, function(error) {
console.log('transaction error: ' + error.message);
}, function() {
console.log('transaction ok');
});
In case of a read-only transaction, it is possible to use readTransaction
which will not use BEGIN, COMMIT, or ROLLBACK:
db.readTransaction(function(tx) {
tx.executeSql("SELECT UPPER('Some US-ASCII text') AS uppertext", [], function(tx, resultSet) {
console.log("resultSet.rows.item(0).uppertext: " + resultSet.rows.item(0).uppertext);
}, function(tx, error) {
console.log('SELECT error: ' + error.message);
});
}, function(error) {
console.log('transaction error: ' + error.message);
}, function() {
console.log('transaction ok');
});
WARNING: It is NOT allowed to execute sql statements on a transaction after it has finished. Here is an example from the Populating Cordova SQLite storage with the JQuery API post at http://www.brodybits.com/cordova/sqlite/api/jquery/2015/10/26/populating-cordova-sqlite-storage-with-the-jquery-api.html:
// BROKEN SAMPLE:
var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'});
db.executeSql("DROP TABLE IF EXISTS tt");
db.executeSql("CREATE TABLE tt (data)");
db.transaction(function(tx) {
$.ajax({
url: 'https://api.github.com/users/litehelpers/repos',
dataType: 'json',
success: function(res) {
console.log('Got AJAX response: ' + JSON.stringify(res));
$.each(res, function(i, item) {
console.log('REPO NAME: ' + item.name);
tx.executeSql("INSERT INTO tt values (?)", JSON.stringify(item.name));
});
}
});
}, function(e) {
console.log('Transaction error: ' + e.message);
}, function() {
// Check results:
db.executeSql('SELECT COUNT(*) FROM tt', [], function(res) {
console.log('Check SELECT result: ' + JSON.stringify(res.rows.item(0)));
});
});
You can find more details and a step-by-step description how to do this right in the Populating Cordova SQLite storage with the JQuery API post at: http://www.brodybits.com/cordova/sqlite/api/jquery/2015/10/26/populating-cordova-sqlite-storage-with-the-jquery-api.html
NOTE/minor bug: Just like the single-statement transaction described above, 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.readTransaction(function(tx) {
tx.executeSql("SELECT UPPER('First') AS uppertext", [], function(tx, 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);
});
});
FUTURE TBD: It should be possible to get a row result object using resultSet.rows[rowNumber]
, also in case of a single-statement transaction. This is non-standard but is supported by the Chrome desktop browser.
db.readTransaction(function(tx) {
tx.executeSql("SELECT BASE64(data) AS base64_data FROM MyTable", [], function(tx, resultSet) {
console.log('BLOB data (base64): ' + resultSet.rows.item(0).base64_data);
});
});
db.transaction(function(tx) {
tx.executeSql("INSERT INTO MyTable (data) VALUES (BLOBFROMBASE64(?))", ["AQID"], function(tx, resultSet) {
console.log("insertId: " + resultSet.insertId + " -- probably 1");
console.log("rowsAffected: " + resultSet.rowsAffected + " -- should be 1");
});
});
The threading model depends on which platform version is used:
- For Android, one background thread per db;
- for iOS/macOS, background processing using a very limited thread pool (only one thread working at a time);
- for Windows, no background processing.
Creates a table, adds a single entry, then queries the count to check if the item was inserted as expected. Note that a new transaction is created in the middle of the first callback.
// 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'});
db.transaction(function(tx) {
tx.executeSql('DROP TABLE IF EXISTS test_table');
tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');
// demonstrate PRAGMA:
db.executeSql("pragma table_info (test_table);", [], function(res) {
console.log("PRAGMA res: " + JSON.stringify(res));
});
tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
console.log("insertId: " + res.insertId + " -- probably 1");
console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");
db.transaction(function(tx) {
tx.executeSql("select count(id) as cnt from test_table;", [], function(tx, res) {
console.log("res.rows.length: " + res.rows.length + " -- should be 1");
console.log("res.rows.item(0).cnt: " + res.rows.item(0).cnt + " -- should be 1");
});
});
}, function(e) {
console.log("ERROR: " + e.message);
});
});
}
NOTE: PRAGMA statements must be executed in executeSql()
on the database object (i.e. db.executeSql()
) and NOT within a transaction.
In this case, the same transaction in the first executeSql() callback is being reused to run executeSql() again.
// 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'});
db.transaction(function(tx) {
tx.executeSql('DROP TABLE IF EXISTS test_table');
tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');
tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
console.log("insertId: " + res.insertId + " -- probably 1");
console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");
tx.executeSql("select count(id) as cnt from test_table;", [], function(tx, res) {
console.log("res.rows.length: " + res.rows.length + " -- should be 1");
console.log("res.rows.item(0).cnt: " + res.rows.item(0).cnt + " -- should be 1");
});
}, function(tx, e) {
console.log("ERROR: " + e.message);
});
});
}
This case will also works with Safari (WebKit), assuming you replace window.sqlitePlugin.openDatabase
with window.openDatabase
.
This will invalidate all handle access handle objects for the database that is closed:
db.close(successcb, errorcb);
It is OK to close the database within a transaction callback but NOT within a statement callback. The following example is OK:
db.transaction(function(tx) {
tx.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function(tx, res) {
console.log('got stringlength: ' + res.rows.item(0).stringlength);
});
}, function(error) {
// OK to close here:
console.log('transaction error: ' + error.message);
db.close();
}, function() {
// OK to close here:
console.log('transaction ok');
db.close(function() {
console.log('database is closed ok');
});
});
The following example is NOT OK:
// BROKEN:
db.transaction(function(tx) {
tx.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function(tx, res) {
console.log('got stringlength: ' + res.rows.item(0).stringlength);
// BROKEN - this will trigger the error callback:
db.close(function() {
console.log('database is closed ok');
}, function(error) {
console.log('ERROR closing database');
});
});
});
BUG: It is currently NOT possible to close a database in a db.executeSql
callback. For example:
// BROKEN DUE TO BUG:
db.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function (res) {
var stringlength = res.rows.item(0).stringlength;
console.log('got stringlength: ' + res.rows.item(0).stringlength);
// BROKEN - this will trigger the error callback DUE TO BUG:
db.close(function() {
console.log('database is closed ok');
}, function(error) {
console.log('ERROR closing database');
});
});
SECOND BUG: When a database connection is closed, any queued transactions are left hanging. TODO: All pending transactions should be errored whenever a database connection is closed.
NOTE: As described above, if multiple database access handle objects are opened for the same database and one database handle access object is closed, the database is no longer available for the other database handle objects. Possible workarounds:
- It is still possible to open one or more new database handle objects on a database that has been closed.
- It should be OK not to explicitly close a database handle since database transactions are ACID compliant and the app's memory resources are cleaned up by the system upon termination.
FUTURE TBD: dispose
method on the database access handle object, such that a database is closed once all access handle objects are disposed.
window.sqlitePlugin.deleteDatabase({name: 'my.db', location: 'default'}, successcb, errorcb);
with location
or iosDatabaseLocation
parameter required as described above for openDatabase
(affects iOS/macOS only)
BUG: When a database is deleted, any queued transactions for that database are left hanging. TODO: All pending transactions should be errored when a database is deleted.
The transactional nature of the API makes it relatively straightforward to manage a database schema that may be upgraded over time (adding new columns or new tables, for example). Here is the recommended procedure to follow upon app startup:
- Check your database schema version number (you can use
db.executeSql
since it should be a very simple query) - If your database needs to be upgraded, do the following within a single transaction to be failure-safe:
- Create your database schema version table (single row single column) if it does not exist (you can check the
sqlite_master
table as described at: http://stackoverflow.com/questions/1601151/how-do-i-check-in-sqlite-whether-a-table-exists) - Add any missing columns and tables, and apply any other changes necessary
- Create your database schema version table (single row single column) if it does not exist (you can check the
IMPORTANT: Since we cannot be certain when the users will actually update their apps, old schema versions will have to be supported for a very long time.
- https://medium.com/@tintin301/ionic-sqlite-storage-setting-up-for-browser-development-and-testing-67c0f17fc7af
- https://www.techiediaries.com/mocking-native-sqlite-plugin/
- https://www.techiediaries.com/ionic-sqlite-pouchdb/
- https://github.com/didinj/ionic3-angular4-cordova-sqlite-example
- https://www.djamware.com/post/59c53a1280aca768e4d2b143/ionic-3-angular-4-and-sqlite-crud-offline-mobile-app
Tutorials with Ionic 2:
- https://www.thepolyglotdeveloper.com/2016/08/using-sqlstorage-instead-sqlite-ionic-2-app/ (title is somewhat misleading, "SQL storage" does use this sqlite plugin)
- https://www.thepolyglotdeveloper.com/2015/12/use-sqlite-in-ionic-2-instead-of-local-storage/ (older tutorial)
Sample on Ionic 2:
Tutorial with Ionic 1: https://blog.nraboy.com/2014/11/use-sqlite-instead-local-storage-ionic-framework/
A sample for Ionic 1 is provided at: litehelpers / Ionic-sqlite-database-example
Documentation at: http://ngcordova.com/docs/plugins/sqlite/
Other resource (apparently for Ionic 1): https://www.packtpub.com/books/content/how-use-sqlite-ionic-store-data
NOTE: Some Ionic and other Angular pitfalls are described above.
cordova plugin add cordova-sqlite-evcore-extbuild-free # --save option *recommended* for Cordova CLI pre-7.0
Additional Cordova CLI NOTES:
- As stated above:
- In case of Cordova CLI pre-7.0 it is recommended to add plugins including standard plugins such as
cordova-plugin-whitelist
with the--save
flag to track these inconfig.xml
(automatically saved inconfig.xml
/package.json
starting with Cordova CLI 7.0). - In general there is no need to keep the Cordova
platforms
subdirectory tree in source code control (such as git). In case ALL plugins are tracked inconfig.xml
orpackage.json
(automatic starting with Cordova CLI 7.0,--save
flag needed for Cordova CLI pre-7.0) then there is no need to keep theplugins
subdirectory tree in source code control either.
- In case of Cordova CLI pre-7.0 it is recommended to add plugins including standard plugins such as
- It may be necessary to use
cordova prepare
in case ofcordova-ios
older than4.3.0
(Cordova CLI6.4.0
) orcordova-osx
. - In case of problems with building and running it is recommended to try again after
cordova prepare
. - If you cannot build for a platform after
cordova prepare
, you may have to remove the platform and add it again, such as:
cordova platform rm ios
cordova platform add ios
or more drastically:
rm -rf platforms
cordova platform add ios
- https://github.com/litehelpers/Cordova-sqlite-evcore-extbuild-free - latest version
cordova-sqlite-evcore-extbuild-free
- stable npm package version
This plugin can be non-intuitive to use on Windows since it includes a native SQLite3 library that is built as a part of the Cordova app. Here are some requirements:
- It is not possible to use this plugin with the default "Any CPU" target. A specific CPU target must be selected.
- It is not allowed to manually change the app id in the Windows platform. The Windows app ID may be declared:
- using a
windows-identity-name
attribute (ref: http://phonegap.com/blog/2016/04/25/windows-10-and-phonegap-cli-6_1-now-on-build/); - "WindowsStoreIdentityName" setting (ref: https://cordova.apache.org/docs/en/latest/config_ref/).
- using a
Use window.sqlitePlugin.echoTest
and/or window.sqlitePlugin.selfTest
as described above (please wait for the deviceready
event).
Assuming your app has a recent template as used by the Cordova create script, add the following code to the onDeviceReady
function, after app.receivedEvent('deviceready');
:
window.sqlitePlugin.openDatabase({ name: 'hello-world.db', location: 'default' }, function (db) {
db.executeSql("select length('tenletters') as stringlength", [], function (res) {
var stringlength = res.rows.item(0).stringlength;
console.log('got stringlength: ' + stringlength);
document.getElementById('deviceready').querySelector('.received').innerHTML = 'stringlength: ' + stringlength;
});
});
Free support is provided on a best-effort basis and is only available in public forums. Please follow the steps below to be sure you have done your best before requesting help.
Professional support is available by contacting: sales@xpbrew.consulting
For more information: https://xpbrew.consulting
First steps:
- Verify that you have followed the steps in brodybits / Cordova-quick-start-checklist
- Try the self-test functions as described above
- Check the pitfalls and troubleshooting steps in the pitfalls section and brodybits / Avoiding-some-Cordova-pitfalls for possible troubleshooting
and check the following:
- You are using the latest version of the Plugin (Javascript and platform-specific part) from this repository.
- The plugin is installed correctly.
- You have included the correct version of
cordova.js
. - You have registered the plugin properly in
config.xml
.
If you still cannot get something to work:
- create a fresh, clean Cordova project, ideally based on brodybits / cordova-sqlite-test-app;
- add this plugin according to the instructions above;
- double-check that you follwed the steps in brodybits / Cordova-quick-start-checklist;
- try a simple test program;
- double-check the pitfalls in brodybits / Avoiding-some-Cordova-pitfalls
General: As documented above with a negative example the application must wait for the AJAX query to finish before starting a transaction and adding the data elements.
In case of issues it is recommended to rework the reproduction program insert the data from a JavaScript object after a delay. There is already a test function for this in brodybits / cordova-sqlite-test-app.
FUTURE TBD examples
If you continue to see the issue: please make the simplest test program possible based on brodybits / cordova-sqlite-test-app to demonstrate the issue with the following characteristics:
- it completely self-contained, i.e. it is using no extra libraries beyond cordova & SQLitePlugin.js;
- if the issue is with adding data to a table, that the test program includes the statements you used to open the database and create the table;
- if the issue is with retrieving data from a table, that the test program includes the statements you used to open the database, create the table, and enter the data you are trying to retrieve.
It is recommended to make a small, self-contained test program based on brodybits / cordova-sqlite-test-app that can demonstrate your problem and post it. Please do not use any other plugins or frameworks than are absolutely necessary to demonstrate your problem.
In case of a problem with a pre-populated database, please post your entire project.
- Debugging, optimization, and other help with application code.
Please include the following:
- Which platform(s) (Android/iOS/macOS/Windows)
- Clear description of the issue
- A small, complete, self-contained program that demonstrates the problem, preferably as a Github project, based on brodybits / cordova-sqlite-test-app. ZIP/TGZ/BZ2 archive available from a public link is OK. No RAR or other such formats please.
- In case of a Windows build problem please capture the entire compiler output.
- screen casts or videos
- RAR or similar archive formats
- Intel, MS IDE, or similar project formats unless absolutely necessary
- litehelpers / Cordova-sqlite-evcore-extbuild-free / issues
- litehelpers / Cordova-sqlite-help / issues
Please include the information described above otherwise.
Unit testing is done in spec
.
To run the tests from *nix shell, simply do either:
./bin/test.sh ios
or for Android:
./bin/test.sh android
To run from a windows powershell (here is a sample for android target):
.\bin\test.ps1 android
GENERAL: The adapters described here are community maintained.
- IndexedDBShim adapter (possibly based on IndexedDBShim)
Contributed by @Mikejo5000 (Mike Jones) from Microsoft.
The SQLite storage plugin sample allows you to execute SQL statements to interact with the database. The code snippets in this section demonstrate simple plugin tasks including:
- Open the database and create a table
- Add a row (record) to the database
- Read rows from the database that match a column value
- Remove a row from the database that matches a column value
- Update rows in the database that match a column value
- Close the database
Call the openDatabase()
function to get started, passing in the name and location for the database.
var db = window.sqlitePlugin.openDatabase({ name: 'my.db', location: 'default' }, function (db) {
// Here, you might create or open the table.
}, function (error) {
console.log('Open database ERROR: ' + JSON.stringify(error));
});
Create a table with three columns for first name, last name, and a customer account number. If the table already exists, this SQL statement opens the table.
db.transaction(function (tx) {
// ...
tx.executeSql('CREATE TABLE customerAccounts (firstname, lastname, acctNo)');
}, function (error) {
console.log('transaction error: ' + error.message);
}, function () {
console.log('transaction ok');
});
By wrapping the previous executeSql()
function call in db.transaction()
, we will make these tasks asynchronous. If you want to, you can use multiple executeSql()
statements within a single transaction (not shown).
Add a row to the database using the INSERT INTO SQL statement.
function addItem(first, last, acctNum) {
db.transaction(function (tx) {
var query = "INSERT INTO customerAccounts (firstname, lastname, acctNo) VALUES (?,?,?)";
tx.executeSql(query, [first, last, acctNum], function(tx, res) {
console.log("insertId: " + res.insertId + " -- probably 1");
console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");
},
function(tx, error) {
console.log('INSERT error: ' + error.message);
});
}, function(error) {
console.log('transaction error: ' + error.message);
}, function() {
console.log('transaction ok');
});
}
To add some actual rows in your app, call the addItem
function several times.
addItem("Fred", "Smith", 100);
addItem("Bob", "Yerunkle", 101);
addItem("Joe", "Auzomme", 102);
addItem("Pete", "Smith", 103);
Add code to read from the database using a SELECT statement. Include a WHERE condition to match the resultSet to the passed in last name.
function getData(last) {
db.transaction(function (tx) {
var query = "SELECT firstname, lastname, acctNo FROM customerAccounts WHERE lastname = ?";
tx.executeSql(query, [last], function (tx, resultSet) {
for(var x = 0; x < resultSet.rows.length; x++) {
console.log("First name: " + resultSet.rows.item(x).firstname +
", Acct: " + resultSet.rows.item(x).acctNo);
}
},
function (tx, error) {
console.log('SELECT error: ' + error.message);
});
}, function (error) {
console.log('transaction error: ' + error.message);
}, function () {
console.log('transaction ok');
});
}
Add a function to remove a row from the database that matches the passed in customer account number.
function removeItem(acctNum) {
db.transaction(function (tx) {
var query = "DELETE FROM customerAccounts WHERE acctNo = ?";
tx.executeSql(query, [acctNum], function (tx, res) {
console.log("removeId: " + res.insertId);
console.log("rowsAffected: " + res.rowsAffected);
},
function (tx, error) {
console.log('DELETE error: ' + error.message);
});
}, function (error) {
console.log('transaction error: ' + error.message);
}, function () {
console.log('transaction ok');
});
}
Add a function to update rows in the database for records that match the passed in customer account number. In this form, the statement will update multiple rows if the account numbers are not unique.
function updateItem(first, id) {
// UPDATE Cars SET Name='Skoda Octavia' WHERE Id=3;
db.transaction(function (tx) {
var query = "UPDATE customerAccounts SET firstname = ? WHERE acctNo = ?";
tx.executeSql(query, [first, id], function(tx, res) {
console.log("insertId: " + res.insertId);
console.log("rowsAffected: " + res.rowsAffected);
},
function(tx, error) {
console.log('UPDATE error: ' + error.message);
});
}, function(error) {
console.log('transaction error: ' + error.message);
}, function() {
console.log('transaction ok');
});
}
To call the preceding function, add code like this in your app.
updateItem("Yme", 102);
When you are finished with your transactions, close the database. Call closeDB
within the transaction success or failure callbacks (rather than the callbacks for executeSql()
).
function closeDB() {
db.close(function () {
console.log("DB closed!");
}, function (error) {
console.log("Error closing DB:" + error.message);
});
}
SQLitePlugin.coffee.md
: platform-independent (Literate CoffeeScript, can be compiled with a recent CoffeeScript (1.x) compiler)www
: platform-independent Javascript as generated fromSQLitePlugin.coffee.md
usingcoffeescript@1
(and committed!)src
: platform-specific source codenode_modules
: placeholder for external dependenciesscripts
: installation hook script to fetch the external dependencies vianpm
spec
: test suite using Jasmine (2.5.2
), also passes on (WebKit) Web SQL on Android, iOS, Safari desktop browser, and Chrome desktop browsertests
: very simple Jasmine test suite that is run on Circle CI (Android platform) and Travis CI (iOS platform) (used as a placeholder)
- Testimonials of apps that are using this plugin would be especially helpful.
- Reporting issues can help improve the quality of this plugin.
NOTE: As stated above, patches will not be accepted on this project due to some possible licensing issues. Issues with reproduction scenarios will help maintain and improve the quality of this plugin for future users. (Any pointers to the code may be causing the issue would also be helpful.)