Native SQLite component with API based on HTML5/Web SQL (DRAFT) API for the following platforms:
and deprecated desktop platforms:
The browser platform is now supported with the following options:
storesafe/sql.js
(fork of sql-js/sql.js
), with no persistence and other limitations described below.LICENSE: MIT, with Apache 2.0 option for Android and Windows platforms (see LICENSE.md
for details, including third-party components used by this plugin)
storesafe/cordova-sqlite-storage#626
storesafe/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-ext - with extra features including BASE64 (SELECT BLOB in Base64 format), 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://storesafe.io/ or contact sales@storesafe.io |
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://storesafe.io/ or contact sales@storesafe.io |
cordova-sqlcipher-adapter - includes encryption functionality using SQLCipher for Android/iOS/macOS |
Permissive (see cordova-sqlcipher-adapter for details) |
available - contact sales@storesafe.io |
cordova-sqlite-express-build-support - using built-in SQLite libraries on Android, iOS, and macOS - may be missing some important SQLite updates |
MIT (or Apache 2.0 on Android & Windows) | available - contact sales@storesafe.io |
New SQLite plugin design with a simpler API with a working demo - see brodybits/ask-me-anything#3
in an upcoming major release - see storesafe/cordova-sqlite-storage#922
some highlights:
code
will always be 0
(which is already the case on browser and Windows); actual SQLite3 error code will be part of the error message
member whenever possible (see storesafe/cordova-sqlite-storage#821
)location: 'default'
or iosDatabaseLocation
setting in openDatabase as documented below)androidDatabaseImplementation: 2
setting which is now superseded by androidDatabaseProvider: 'system'
settingunder consideration:
androidLockWorkaround: 1
option if not needed any longer - storesafe/cordova-sqlite-storage#925
This is a common plugin version branch which supports the most widely used features and serves as the basis for other plugin versions.
This version branch uses a before_plugin_install
hook to install sqlite3 library dependencies from cordova-sqlite-storage-dependencies
via npm.
This plugin uses non-standard android-sqlite-native-ndk-connector
implementation with android-sqlite-ndk-native-driver
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);
});
});
NOTE: These samples will not work with alternative 3 for browser platform support discussed in the alternative browser platform usage notes section below.
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 below for a sample with a more detailed explanation (using the DRAFT standard transaction API).
before_plugin_install
hook to install sqlite3 library dependencies from cordova-sqlite-storage-dependencies
via npm.before_plugin_install
hook. The supported solution is to use storesafe/cordova-sqlite-evcore-extbuild-free
(GPL v3 or commercial license terms); deprecated alternative with permissive license terms is available at: brodybits/cordova-sqlite-legacy-build-support
(very limited testing, very limited updates).3.40.0
included when building (all platforms), with the following compile-time definitions:
SQLITE_THREADSAFE=1
(SQLITE_THREADSAFE=0
for sql.js on browser platform)SQLITE_DEFAULT_SYNCHRONOUS=3
(EXTRA DURABLE build setting) ref: storesafe/cordova-sqlite-storage#736
(except for sql.js on browser platform)SQLITE_DEFAULT_MEMSTATUS=0
(except for sql.js on browser platform)SQLITE_OMIT_DECLTYPE
(except for sql.js on browser platform)SQLITE_OMIT_DEPRECATED
(except for sql.js on browser platform)SQLITE_OMIT_PROGRESS_CALLBACK
(except for sql.js on browser platform)SQLITE_OMIT_SHARED_CACHE
(except for sql.js on browser platform)SQLITE_TEMP_STORE=2
(except for sql.js on browser platform)SQLITE_OMIT_LOAD_EXTENSION
SQLITE_ENABLE_FTS3
SQLITE_ENABLE_FTS3_PARENTHESIS
SQLITE_ENABLE_FTS4
SQLITE_ENABLE_RTREE
SQLITE_DEFAULT_PAGE_SIZE=4096
- new default page size ref: http://sqlite.org/pgszchng2016.htmlSQLITE_DEFAULT_CACHE_SIZE=-2000
(Android only) new default cache size ref: http://sqlite.org/pgszchng2016.htmlSQLITE_OS_WINRT
(Windows only)NDEBUG
on Windows (Release build only)SQLITE_DISABLE_LFS
for sql.js on browser platform onlySQLITE_DBCONFIG_DEFENSIVE
flag is used for extra SQL safety on all platforms Android/iOS/macOS/Windows ref:
android-sqlite-native-ndk-connector
, using SQLite3 NDK component built from github:brodybits/android-sqlite-ndk-native-driver
- sqlite-storage-ndk-native-driver
branch and brodybits/android-sqlite-native-ndk-connector
androidDatabaseProvider: 'system'
setting in sqlitePlugin.openDatabase()
call as described in the Android database provider section below.brodybits/cordova-sqlite-legacy-build-support
brodybits/cordova-sqlite-ext
:
sql-asm-memory-growth.js
built from storesafe/sql.js
(fork of sql-js/sql.js
) has the following major limitations:
\u0000
character (same as \0
)doo/SQLite3-WinRT
C++ component, based on brodybits/SQLite3-WinRT
- sync-api-fix
branch, with the following known limitations:
storesafe/cordova-sqlite-storage#580
. (Visual Studio 2019 is not supported with cordova-windows, see apache/cordova-windows#327
.) Visual Studio 2015 is now supported by brodybits/cordova-sqlite-legacy
(permissive license terms, no performance enhancements for Android) and brodybits/cordova-sqlite-evcore-legacy-ext-common-free
(GPL v3 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.)SQLite3-WinRT
component in src/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.\u0000
character (same as \0
)storesafe/cordova-sqlite-storage#539
brodybits/cordova-sqlite-ext
(permissive license terms) and storesafe/cordova-sqlite-evcore-extbuild-free
(GPL v3 or commercial license terms).UTF-16le
internal database encoding while the other platform versions use UTF-8
internal encoding. (UTF-8
internal encoding is preferred ref: storesafe/cordova-sqlite-storage#652
)cordova prepare osx
is needed before building and running from Xcodecordova-osx
and Cordova CLI 10.0.0(+): https://github.com/apache/cordova-osx/issues/106PRAGMA journal_mode
setting (tested):
androidDatabaseProvider: 'system'
setting: persist
(pre-8.0) / truncate
(Android 8.0, 8.1, 10(+)) / wal
(Android 9.0 Pie)delete
VACUUM
or PRAGMA 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 storesafe/cordova-sqlite-storage#646
storesafe/cordova-sqlite-evcore-extbuild-free
(GPL v3 or commercial license terms).storesafe/sql.js
(fork of sql-js/sql.js
), with no persistence and other limitations described below.SQLITE_DEFAULT_SYNCHRONOUS=3
(EXTRA DURABLE) build setting to be extra robust against possible database corruption ref: storesafe/cordova-sqlite-storage#736
SQLITE_DBCONFIG_DEFENSIVE
flag is used for extra SQL safety, as described abovePSPDFThreadSafeMutableDictionary.m
to avoid threading issue, custom version to avoid potential conflicts with custom iOS/macOS plugins ref: storesafe/cordova-sqlite-storage#716
, storesafe/cordova-sqlite-storage#861
SYNTAX_ERR
when using some other plugins ref: storesafe/cordova-sqlite-storage#868
TheCocoaProject/cordova-plugin-nativestorage
- simpler "native storage of variables" for Android/iOS/Windowsstoresafe/cordova-sqlite-storage#726
, thanks to pointer by @NeoLSN (Jason Yang/楊朝傑) in storesafe/cordova-sqlite-storage#727
.storesafe/cordova-sqlite-storage#666
(possible transaction issue after window.location change with possible data loss): close database if already open before opening again/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-handlersstoresafe/cordova-sqlite-storage#580
.storesafe/cordova-sqlite-storage-starter-app
project is a CC0 (public domain) starting point and may also be used to reproduce issues with this plugin. In addition brodybits/cordova-sqlite-test-app
may be used to reproduce issues with other versions of this plugin.brodybits/cordova-sqlite-community-lawnchair-adapter
.brodybits/cordova-sqlite-ext
now supports SELECT BLOB data in Base64 format on Android/iOS/macOS/Windows in addition to REGEXP (Android/iOS/macOS) and pre-populated databases (Android/iOS/macOS/Windows).brodybits/sql-promise-helper
provides a Promise-based API wrapper.pouchdb-community/pouchdb-adapter-cordova-sqlite
supports this plugin along with other implementations such as nolanlawson/sqlite-plugin-2
and Microsoft/cordova-plugin-websql
.storesafe/cordova-sqlite-evcore-extbuild-free
plugin version with Android JSON and SQL statement handling implemented in C, as well as support for Intel XDK, PhoneGap Build, etc. (GPL v3 or commercial license terms) - handles large SQL batches in less than half the time as this plugin version. Also supports arbitrary database location on Android.brodybits/Cordova-quick-start-checklist
and brodybits/Avoiding-some-Cordova-pitfalls
.android-sqlite-native-ndk-connector
by default configuration (may be changed as described below).openDatabase
and deleteDatabase
iosDatabaseLocation
optionMetaMemoryT/websql-promise
now provides a Promises-based interface to both (WebKit) Web SQL and this pluginbrodybits/cordova-sqlcipher-adapter
window.openDatabase()
factory call with window.sqlitePlugin.openDatabase()
, with parameters as documented below. Known deviations are documented in the deviations section below.doo/SQLite3-WinRT
C++ component.brodybits/cordova-sqlcipher-adapter
TIP: It is possible to migrate from Cordova to a pure native solution and continue using the data stored by this plugin.
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:
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:
--save
flag when installing plugins to add them to config.xml
/ package.json
. (This is automatic starting with Cordova CLI 7.0.)config.xml
or package.json
, there is no need to commit the plugins
subdirectory tree into the source repository.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.
As stated above the browser platform is now supported with features such as numbered parameters now working using storesafe/sql.js
(fork of sql-js/sql.js
), with no actual persistence.
Here are some alternative solutions for now that do support persistence, with features such as numbered paramters (?1
, ?2
, etc.) not supported:
brodybits/sql-promise-helper
as described in brodybits/sql-promise-helper#4
if (window.cordova.platformId === 'browser') db = window.openDatabase('MyDatabase', '1.0', 'Data', 2*1024*1024);
else db = window.sqlitePlugin.openDatabase({name: 'MyDatabase.db', location: 'default'});
or more compactly:
db = (window.cordova.platformId === 'browser') ?
window.openDatabase('MyDatabase', '1.0', 'Data', 2*1024*1024) :
window.sqlitePlugin.openDatabase({name: 'MyDatabase.db', location: 'default'});
(lower limit needed to avoid extra permission request popup on Safari)
and limit database access to DRAFT standard transactions, no plugin-specific API calls:
executeSql
calls outside DRAFT standard transactionssqlBatch
callsechoTest
or selfTest
possibledeleteDatabase
callsThis kind of usage on Safari and Chrome desktop browser (with (WebKit) Web SQL) is now covered by the spec
test suite.
It would be ideal for the application code to abstract the part with the openDatabase()
call away from the rest of the database access code.
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:
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-storage # --save 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 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@storesafe.io
Simple example:
storesafe/cordova-sqlite-storage-starter-app
(using cordova-sqlite-storage
plugin version)Tutorials:
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: storesafe/cordova-sqlite-storage#795
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.
window.sqlitePlugin.openDatabase
static factory call takes a different set of parameters than the standard Web SQL window.openDatabase
static factory call. In case you have to use existing Web SQL code with no modifications please see the Web SQL replacement tip below.storesafe/cordova-sqlite-storage#551
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.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-syntaxInfinity
SQL parameter argument values are treated like null
by this plugin on Android and iOS ref: storesafe/cordova-sqlite-storage#405
Infinity
result values cause a crash on iOS/macOS cases ref: storesafe/cordova-sqlite-storage#405
true
and false
values are handled by converting them to the "true" and "false" TEXT string values, same as WebKit Web SQL on Android and iOS. This does not seem to be 100% correct as discussed in: storesafe/cordova-sqlite-storage#545
5
(SQLError.SYNTAX_ERR
) on Android/iOS/macOS by both (WebKit) Web SQL and this plugin.0
on Windows as well as Android with the androidDatabaseProvider: 'system'
setting described below.0
(SQLError.UNKNOWN_ERR
) in the exception while the plugin includes no such code member.SELECT LOWER(X'40414243') AS myresult
, SELECT X'40414243' AS myresult
, or SELECT of data stored by INSERT INTO MyTable VALUES (X'40414243')
returns nonsense results on browser and results in an error on Android with use of androidDatabaseProvider: 'system'
setting and Windows. (These work with Android/iOS WebKit Web SQL and have been supported by SQLite for a number of years.)42
, -101
, or 1234567890123
are handled as INTEGER values by this plugin on browser, Android, iOS (cordova-ios pre-6.0), and Windows while they are handled as REAL values by (WebKit) Web SQL and by this plugin on iOS with WKWebView (cordova-ios 6.0(+)) or macOS ("osx"). This is evident in certain test operations such as SELECT ? as myresult
or SELECT TYPEOF(?) as myresult
and storage in a field with TEXT affinity.Infinity
, NaN
, null
, undefined
parameter argument values are handled as TEXT string values on Android with use of the androidDatabaseProvider: 'system'
setting. (This is evident in certain test operations such as SELECT ? as myresult
or SELECT TYPEOF(?) as myresult
and storage in a field with TEXT affinity.)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.transaction.executeSql(null)
or transaction.executeSql(undefined)
the plugin throws an exception while (WebKit) Web SQL indicates a transaction failure.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.Array
subclass object where the constructor
does not point to Array
then the SQL arguments are ignored by the plugin.?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.insertId
with the result of sqlite3_last_insert_rowid()
(except for Android with androidDatabaseProvider: 'system'
setting) while attempt to access insertId
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.
storesafe/cordova-sqlite-storage#564
(this is not an issue when using the androidDatabaseProvider: 'system'
setting)storesafe/cordova-sqlite-storage#551
androidDatabaseProvider: 'system'
setting.storesafe/cordova-sqlite-evcore-extbuild-free
(GPL v3 or commercial license terms)storesafe/cordova-sqlite-storage#405
pusher/pusher-js
at the same time (see storesafe/cordova-sqlite-storage#196
). The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).storesafe/cordova-sqlite-storage#539
.PRAGMA database_list
reports nonsense database file name on browser platform.Some additional issues are tracked in open cordova-sqlite-storage bug-general issues.
storesafe/cordova-plugin-sqlite-evplus-ext-common-free
(GPL v3 or commercial license terms).litehelpers/cordova-sqlite-evmax-ext-workers-legacy-build-free
(GPL v3 or special premium commercial license terms).db=window.sqlitePlugin.openDatabase({name: ':memory:', ...})
is currently not supported.\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 apache/cordova-ios#402
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 v3 or special commercial license terms) as well as litehelpers/cordova-sqlite-evmax-ext-workers-legacy-build-free
(GPL v3 or premium commercial license terms).brodybits/cordova-sqlite-ext
(permissive license terms) and storesafe/cordova-sqlite-evcore-extbuild-free
(GPL v3 or commercial license options).\u0000
character (same as \0
):
android-sqlite-native-ndk-connector
implementation with android-sqlite-ndk-native-driver
, using Android NDK)\u0000
character reproduced on (WebKit) Web SQL as well as plugin on Android (default android-sqlite-native-ndk-connector
implementation with android-sqlite-ndk-native-driver
, using Android NDK), browser, and Windows\u0000
character on (WebKit) Web SQL, plugin on Android with use of the androidDatabaseProvider: 'system'
setting, and plugin on some other platforms\u2028
line separator / \u2029
paragraph separator fixes) in litehelpers/Cordova-sqlite-evplus-legacy-attach-detach-free
(GPL v3 or special commercial license terms).androidDatabaseProvider: 'system'
setting is used.x86_64
CPU (storesafe/cordova-sqlite-storage#336
). Please see storesafe/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.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.?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: storesafe/cordova-sqlite-storage#717
storesafe/cordova-sqlite-storage#741
Additional limitations are tracked in marked cordova-sqlite-storage doc-todo issues.
storesafe/cordova-sqlite-storage#334
)storesafe/cordova-sqlite-storage#627
?1
, ?2
, etc.) as documented in https://www.sqlite.org/c3ref/bind_blob.html?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: storesafe/cordova-sqlite-storage#717
window.openDatabase
for comparison with (WebKit) Web SQL.IMPORTANT: A number of tutorials and samples in search results suffer from the following pitfall:
window.openDatabase
call it will not have any of the benefits of this plugin and features such as the sqlBatch
call would not be available.sqlitePlugin
object name starts with "sql" in small letters.VACUUM
or PRAGMA 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 storesafe/cordova-sqlite-storage#646
storesafe/cordova-sqlite-storage#396
)storesafe/cordova-sqlite-storage#355
, it may be necessary to install ionic-plugin-keyboardstoresafe/cordova-sqlite-storage#613
windows-identity-name
attribute or "WindowsStoreIdentityName" setting.SQLite3.md
generally means that there was a problem building the C++ library.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:
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.However there are some possible gotchas:
From https://www.sqlite.org/datatype3.html#section_3_2:
Note that a declared type of "FLOATING POINT" would give INTEGER affinity, not REAL affinity, due to the "INT" at the end of "POINT". And the declared type of "STRING" has an affinity of NUMERIC, not TEXT.
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 storesafe/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.
storesafe/cordova-sqlite-storage#646
storesafe/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 (permissive license terms)storesafe/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 v3 or commercial license terms.storesafe/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 or commercial license terms.litehelpers/cordova-sqlite-evplus-ext-legacy-build-free
- internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS). (GPL v3 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) and fix to support all Unicode characters (GPL v3 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) and fix to support all Unicode characters (iOS). (GPL v3 or special premium commercial license terms).andpor/react-native-sqlite-storage
(permissive license terms)davibe/Phonegap-SQLitePlugin
(permissive license terms)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).
window.openDatabase()
factory call with window.sqlitePlugin.openDatabase()
, with parameters as documented below. Some other known deviations are described throughout this document. Reports of any other deviations would be appreciated.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-native-ndk-connector
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 iCloudWARNING: 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
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.
/
) character(s) are not supported and not expected to work on any platform.*
<
>
?
\
"
|
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-native-ndk-connector
, which is lightweight and should be more efficient than the Android system database provider. 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:
android-sqlite-native-ndk-connector
implementation with android-sqlite-ndk-native-driver
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 here.androidDatabaseProvider: 'system'
setting, storesafe/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.storesafe/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:
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-native-ndk-connector
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:
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: storesafe/cordova-sqlite-storage#551
NOTE: This call will not work with alternative 3 for browser platform support discussed in the alternative browser platform usage notes section above.
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);
});
NOTE: This call will not work with alternative 3 for browser platform support discussed in the alternative browser platform usage notes above.
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.
The threading model depends on which platform version is used:
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:
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:
db.executeSql
since it should be a very simple query)sqlite_master
table as described at: http://stackoverflow.com/questions/1601151/how-do-i-check-in-sqlite-whether-a-table-exists)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.
Tutorials with Ionic 2:
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.
npm install -g cordova # (in case you don't have cordova)
cordova create MyProjectFolder com.my.project MyProject && cd MyProjectFolder # if you are just starting
cordova plugin add cordova-sqlite-storage # --save RECOMMENDED for Cordova CLI pre-7.0
cordova platform add <desired platform> # repeat for all desired platform(s)
cordova prepare # OPTIONAL (MAY BE NEEDED cordova-ios pre-4.3.0 (Cordova CLI pre-6.4.0))
Additional Cordova CLI NOTES:
cordova-plugin-whitelist
with the --save
flag to track these in config.xml
(automatically saved in config.xml
/ package.json
starting with Cordova CLI 7.0).platforms
subdirectory tree in source code control (such as git). In case ALL plugins are tracked in config.xml
or package.json
(automatic starting with Cordova CLI 7.0, --save
flag needed for Cordova CLI pre-7.0) then there is no need to keep the plugins
subdirectory tree in source code control either.cordova prepare
in case of cordova-ios
older than 4.3.0
(Cordova CLI 6.4.0
) or cordova-osx
.cordova prepare
.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
cordova-sqlite-storage
- stable npm package versionThis plugin can be challenging 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:
windows-identity-name
attribute (ref: http://phonegap.com/blog/2016/04/25/windows-10-and-phonegap-cli-6_1-now-on-build/);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@storesafe.io
For more information: https://storesafe.io
First steps:
brodybits/Cordova-quick-start-checklist
brodybits/Avoiding-some-Cordova-pitfalls
for possible troubleshootingand check the following:
cordova.js
.config.xml
.If you still cannot get something to work:
brodybits/cordova-sqlite-test-app
;brodybits/Cordova-quick-start-checklist
;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 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.
Please include the following:
brodybits/cordova-sqlite-test-app
. ZIP/TGZ/BZ2 archive available from a public link is OK. No RAR or other such formats please.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.
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:
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 from SQLitePlugin.coffee.md
using coffeescript@1
(and committed!)src
: platform-specific source codenode_modules
: placeholder for external dependenciesscripts
: installation hook script to fetch the external dependencies via npm
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)WARNING: Please do NOT propose changes from your default branch. Contributions may be rebased using git rebase
or git cherry-pick
and not merged.
git mv
to move files & directories;