cordova-sqlite-storage
Advanced tools
Readme
Native interface to sqlite in a Cordova/PhoneGap plugin for Android and iOS, with API similar to HTML5/Web SQL API.
License for Android version: MIT or Apache 2.0
License for iOS version: MIT only
This version contains the source code for the Android and iOS versions. This version does not contain any libraries or source code from www.sqlite.org. This version uses the built-in sqlite libraries on Android and iOS.
| Android CI ( | iOS CI (limited suite) |
|---|---|
 |  |
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]
There are two ways iCloud backup is configured:
config.xml and is unfortunately enabled by default as documented at: https://cordova.apache.org/docs/en/6.0.0/guide/platforms/ios/config.htmlDocuments subdirectory by default, which is backed up to iCloud. You can use the location option in sqlitePlugin.openDatabase() to store the database in a subdirectory that is NOT backed up to iCloud.Unless you want your app to use iCloud backup for some reason, it is recommended to turn it off as documented in: https://cordova.apache.org/docs/en/6.0.0/guide/platforms/ios/config.html
@brodybits reported Cordova bug CB-9830 to disable iCloud backup by default in config.xml.
@brodybits (Christopher J. Brody aka Chris Brody) dedicates a significant amout of working time to maintain and improve this project, and has turned down multiple full-time work opportunities in order to support this project. @brodybits is available for part-time work in areas related to this project including priority support, priority feature development, and higher-level application development. Such part-time assignments would help @brodybits keep this project alive.
openDatabase and deleteDatabase location option to select database location (iOS only) and disable iCloud backupwindow.openDatabase() --> sqlitePlugin.openDatabase()false to signal transaction recovery, the plugin fires the remaining sql callbacks before aborting the transaction.code member is bogus on Android (fixed for Android in litehelpers / Cordova-sqlite-enterprise-free).db=window.sqlitePlugin.openDatabase({name: ":memory:"}) is currently not supported.db=window.sqlitePlugin.openDatabase({name: ":memory:"}) is currently not supported.\u2028) and paragraph separator (\u2029) are currently not supported and known to be broken in iOS version due to Cordova bug CB-9435. There may be a similar issue with other UNICODE characters in the iOS version (needs further investigation). This is fixed in: litehelpers / Cordova-sqlite-enterprise-free (available with a different licensing scheme)window.sqlitePlugin object exported (ES5 feature). It is recommended to use andpor / react-native-sqlite-storage for SQLite database access with React Native Android/iOS instead.window.openDatabase and see if you get the same problems.sqlitePlugin object name starts with "sql" in small letters.To verify that both the Javascript and native part of this plugin are installed in your application:
window.sqlitePlugin.echoTest(successCallback, errorCallback);
IMPORTANT: Please wait for the 'deviceready' event (see below for an example).
The idea is to emulate the HTML5/Web SQL API as closely as possible. The only major change is to use window.sqlitePlugin.openDatabase() (or sqlitePlugin.openDatabase()) instead of window.openDatabase(). If you see any other major change please report it, it is probably a bug.
NOTE: If a sqlite statement in a transaction fails with an error, the error handler must return false in order to recover the transaction. This is correct according to the HTML5/Web SQL API standard. This is different from the WebKit implementation of Web SQL in Android and iOS which recovers the transaction if a sql error hander returns a non-true value.
There are two options to open a database access object:
var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 1}, successcb, errorcb);var db = window.sqlitePlugin.openDatabase("myDatabase.db", "1.0", "Demo", -1);The location option is used to select the database subdirectory location (iOS only) with the following choices:
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 iCloudIMPORTANT: 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"});
// ...
}
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"}, 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.
OTHER NOTES:
litehelpers/Cordova-sqlite-storage#193 was reported (as observed by several app developers) that on some newer versions of the Android database classes, if the app is stopped or aborted without closing the database then:
This issue is suspected to be caused by this Android sqlite commit, which references and includes the sqlite commit at: http://www.sqlite.org/src/info/6c4c2b7dba
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', androidLockWorkaround: 1});
IMPORTANT NOTE: This workaround is only applied when using db.transaction(), not applied when running executeSql() on the database object.
The following types of SQL transactions are supported by this version:
Sample:
db.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function (res) {
console.log('got stringlength: ' + res.rows.item(0).stringlength);
}, function(error) {
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 (res) {
console.log('Sample column value: ' + res.rows.item(0).SampleColumn);
});
}, function(error) {
console.log('Populate table error: ' + error.message);
});
In case of an error, all changes in a sql batch are automatically discarded using ROLLBACK.
Standard asynchronous transactions follow the HTML5/Web SQL API which is very well documented and uses BEGIN and COMMIT or ROLLBACK to keep the transactions failure-safe. Here is a very simple example from the test suite:
db.transaction(function(tx) {
tx.executeSql("SELECT UPPER('Some US-ASCII text') AS uppertext", [], function(tx, res) {
console.log("res.rows.item(0).uppertext: " + res.rows.item(0).uppertext);
}, function(error) {
console.log('SELECT 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, res) {
console.log("res.rows.item(0).uppertext: " + res.rows.item(0).uppertext);
}, function(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 my Populating Cordova SQLite storage with the JQuery API post:
// BROKEN SAMPLE:
var db = window.sqlitePlugin.openDatabase({name: "test.db"});
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:
The threading model depends on which 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"});
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("Database", "1.0", "Demo", -1);
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(e) {
console.log("ERROR: " + e.message);
});
});
}
This case will also works with Safari (WebKit), assuming you replace window.sqlitePlugin.openDatabase with window.openDatabase.
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 1: 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');
});
});
BUG 2: If multiple database access objects are opened for the same database and one database access object is closed, the database is no longer available for the other database access objects. Possible workarounds:
window.sqlitePlugin.deleteDatabase({name: "my.db", location: 1}, successcb, errorcb);
location as described above for openDatabase (iOS only)
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.
It is recommended to follow the tutorial at: https://blog.nraboy.com/2014/11/use-sqlite-instead-local-storage-ionic-framework/
Documentation at: http://ngcordova.com/docs/plugins/sqlite/
npm install -g cordova # if you don't have cordova
cordova create MyProjectFolder com.my.project MyProject && cd MyProjectFolder # if you are just starting
cordova plugin add https://github.com/litehelpers/Cordova-sqlite-storage
You can find more details at this writeup.
IMPORTANT: sometimes you have to update the version for a platform before you can build, like: cordova prepare ios
NOTE: 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
plugman install --platform MYPLATFORM --project path.to.my.project.folder --plugin https://github.com/litehelpers/Cordova-sqlite-storage
where MYPLATFORM is android, ios, or .windows
A posting how to get started developing on Windows host without the Cordova CLI tool (for Android target only) is available here.
cordova-sqlite-storage - stable npm package versionSQLitePlugin.coffee.md: platform-independent (Literate coffee-script, can be read by recent coffee-script compiler)www: SQLitePlugin.js platform-independent Javascript as generated from SQLitePlugin.coffee.md (and checked in!)src: platform-specific source code:
android - Java plugin code for Androidios - Objective-C plugin code for iOS;spec: test suite using Jasmine (2.2.0)tests: very simple Jasmine test suite that is run on Circle CI (Android version) and Travis CI (iOS version) (used as a placeholder)Lawnchair-adapter: Lawnchair adaptor, based on the version from the Lawnchair repository, with the basic Lawnchair test suite in test-www subdirectoryUse window.sqlitePlugin.echoTest 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' }, 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.
Commercial support is available by contacting: info@litehelpers.net
First steps:
and check the following:
config.xml.If you still cannot get something to work:
If you continue to see the issue in the fresh, clean Cordova project:
Please make a small, self-contained test program 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.
Free support for issues with Angular/"ngCordova"/Ionic will only be provided if you can demonstrate that you can do the same thing without such a framework.
Please include the following:
Once you have followed the directions above, you may request free support in the following location(s):
Please include the information described above otherwise.
Professional support is available, please contact: info@litehelpers.net
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
Please look at the Lawnchair-adapter tree that contains a common adapter, which should also work with the Android version, along with a test-www directory.
Include the following Javascript files in your HTML:
cordova.js (don't forget!)lawnchair.js (you provide)SQLitePlugin.js (in case of Cordova pre-3.0)Lawnchair-sqlitePlugin.js (must come after SQLitePlugin.js in case of Cordova pre-3.0)The name option determines the sqlite database filename, with no extension automatically added. Optionally, you can change the db filename using the db option.
In this example, you would be using/creating a database with filename kvstore:
kvstore = new Lawnchair({name: "kvstore"}, function() {
// do stuff
);
Using the db option you can specify the filename with the desired extension and be able to create multiple stores in the same database file. (There will be one table per store.)
recipes = new Lawnchair({db: "cookbook", name: "recipes", ...}, myCallback());
ingredients = new Lawnchair({db: "cookbook", name: "ingredients", ...}, myCallback());
KNOWN ISSUE: the new db options are not supported by the Lawnchair adapter. The workaround is to first open the database file using sqlitePlugin.openDatabase().
The adapter is now part of PouchDB thanks to @nolanlawson, see PouchDB FAQ.
WARNING: Please do NOT propose changes from your default branch. In general, contributions are rebased using git rebase or git cherry-pick and not merged.
git mv to move files & directories;LinkedIn: https://www.linkedin.com/in/chrisbrody
FAQs
Native interface to SQLite for PhoneGap / Cordova - cordova-sqlite-storage plugin version
The npm package cordova-sqlite-storage receives a total of 20,698 weekly downloads. As such, cordova-sqlite-storage popularity was classified as popular.
We found that cordova-sqlite-storage demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
A new report explores how advancements in LLMs are enhancing cyber threats, including polymorphic malware, personalized spearphishing, and the risk of hijacking customer service bots.
Security News
ESLint has approved an RFC that adds support for TypeScript configuration files, which is aimed at improving the developer experience and recognizing changes in the evolving JavaScript ecosystem.
Security News
The NVD is facing a significant backlog with over 12,500 CVEs awaiting analysis, and more than 50% of known exploited vulnerabilities (KEVs) left unenriched since mid-February.