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 Circle-CI (full suite) | iOS Travis-CI (very limited suite) |
---|---|
By default the iOS version stores the database in Documents
which is visible to iTunes and backed up by iCloud. (This is changed using the location
option in sqlitePlugin.openDatabase()
as described below.) @brodybits would like to change the default behavior to store the database in Library/LocalDatabase
which is NOT visible to iTunes and NOT backed up by iCloud.
This would be a BREAKING CHANGE and existing iOS apps that do not use the location
option would need to introduce this option in order to preserve a working upgrade. Issue litehelpers/Cordova-sqlite-storage#430 was raised to collect comments from the community. Please read litehelpers/Cordova-sqlite-storage#430 very carefully and leave a comment whether or not you like this idea.
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
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). Ref: phonegap/build#338 (comment)
@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.
- Android version in this version branch is now using the built-in Android SQLite database classes. Integration with the lightweight Android-sqlite-connector is available in litehelpers / cordova-sqlite-ext and litehelpers / Cordova-sqlite-legacy.
- Windows 8.1/Windows Phone 8.1 version is removed from this project, available in litehelpers / cordova-sqlite-ext and litehelpers / Cordova-sqlite-legacy.
- WP(7/8) is not supported by this version branch, moved to litehelpers / Cordova-sqlite-legacy.
- The following features are moved to litehelpers / cordova-sqlite-ext and removed from this project:
- REGEXP support
- Pre-populated database
- Amazon Fire-OS is dropped due to lack of support by Cordova. Android version should be used to deploy to Fire-OS 5.0(+) devices ref: cordova/cordova-discuss#32 (comment)
- FTS3, FTS4, and R-Tree support is tested working OK in this version (for all target platforms in this version branch Android/iOS)
- Android is supported back to SDK 10 (a.k.a. Gingerbread, Android 2.3.3); support for older versions is available upon request.
- API to open the database may be changed somewhat to be more streamlined. Transaction and single-statement query API will NOT be changed.
- In case of memory issues please use smaller transactions or use the version (with a different licensing scheme) at: litehelpers / Cordova-sqlite-enterprise-free or litehelpers / cordova-sqlite-workers-evfree
- Added simple sql batch query function
- Added echo test function to verify installation of this plugin
- Published litehelpers / Cordova-sqlite-legacy for maintenance of WP(7/8) version, working with the other supported platforms Android/iOS/Windows 8.1(+)/Windows Phone 8.1(+)
- All iOS operations are now using background processing (reported to resolve intermittent problems with cordova-ios@4.0.1)
- Published brodybits / Cordova-quick-start-checklist and brodybits / Cordova-troubleshooting-guide
- A version with support for web workers is available (with a different licensing scheme) at: litehelpers / cordova-sqlite-workers-evfree
- A version with pre-populated database support added for Windows "Universal" and REGEXP support added for Android is available at: litehelpers / cordova-sqlite-ext
- PhoneGap Build is now supported through the npm package: http://phonegap.com/blog/2015/05/26/npm-plugins-available/
- MetaMemoryT / websql-promise now provides a Promises-based interface to both Web SQL and this plugin
- iOS version is now fixed to override the correct pluginInitialize method and should work with recent versions of iOS
- SQLCipher for Windows (8.1) in addition to Android & iOS is now supported by litehelpers / Cordova-sqlcipher-adapter
- New
openDatabase
anddeleteDatabase
location
option to select database location (iOS only) and disable iCloud backup
- Drop-in replacement for HTML5/Web SQL API, the only change should be
window.openDatabase()
-->sqlitePlugin.openDatabase()
- Failure-safe nested transactions with batch processing optimizations
- As described in this posting:
- Keeps sqlite database in a user data location that is known; can be reconfigured (iOS version); and synchronized to iCloud by default (iOS version; can be disabled as described below).
- No 5MB maximum, more information at: http://www.sqlite.org/limits.html
- Traiforks Mountain Bike Trail Map App with a couple of nice videos at: http://www.pinkbike.com/news/trailforks-app-released.html
- Get It Done app by marcucio.com
- KAAHE Health Encyclopedia: Official health app of the Kingdom of Saudi Arabia.
- Larkwire (iOS version): Learn bird songs the fun way
- Tangorin (Android) Japanese Dictionary at tangorin.com
- iOS version does not support certain rapidly repeated open-and-close or open-and-delete test scenarios due to how the implementation handles background processing
- As described below, auto-vacuum is NOT enabled by default.
- INSERT statement that affects multiple rows (due to SELECT cause or using TRIGGER(s), for example) does not report proper rowsAffected on Android
- Memory issue observed when adding a large number of records due to the JSON implementation which is improved in litehelpers / Cordova-sqlite-enterprise-free (available with a different licensing scheme)
- A stability issue was reported on the iOS version when in use together with SockJS client such as pusher-js at the same time (see litehelpers/Cordova-sqlite-storage#196). The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).
- If a sql statement fails for which there is no error handler or the error handler does not return
false
to signal transaction recovery, the plugin fires the remaining sql callbacks before aborting the transaction. - In case of an error, the error
code
member is bogus on Android (fixed for Android in litehelpers / Cordova-sqlite-enterprise-free). - Possible crash on Android when using Unicode emoji characters due to Android bug 81341, which should be fixed in Android 6.x
- In-memory database
db=window.sqlitePlugin.openDatabase({name: ":memory:"})
is currently not supported. - Close database bugs described below.
- When a database is opened and deleted without closing, the iOS version is known to leak resources.
- It is NOT possible to open multiple databases with the same name but in different locations (iOS version).
- Problems reported with PhoneGap Build in the past:
- PhoneGap Build Hydration.
- Apparently FIXED:
PhoneGap Build may fail to build the iOS version unless the name of the app starts with an uppercase and contains no spaces (see litehelpers/Cordova-sqlite-storage#243; Wizcorp/phonegap-facebook-plugin#830; phonegap/build#431).
- The db version, display name, and size parameter values are not supported and will be ignored.
- 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.)
- This version will not work within a web worker (not properly supported by the Cordova framework).
- In-memory database
db=window.sqlitePlugin.openDatabase({name: ":memory:"})
is currently not supported. - The Android version cannot work with more than 100 open db files (due to the threading model used).
- UNICODE line separator (
\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) - Blob type is currently not supported and known to be broken on multiple platforms.
- 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.
- iOS version uses a thread pool but with only one thread working at a time due to "synchronized" database access
- Large query result can be slow, also due to JSON implementation
- ATTACH to another database file is not supported (due to path specifications, which work differently depending on the target platform)
- User-defined savepoints are not supported and not expected to be compatible with the transaction locking mechanism used by this plugin. In addition, the use of BEGIN/COMMIT/ROLLBACK statements is not supported.
- Problems have been reported when using this plugin with Crosswalk (for Android). It may help to install Crosswalk as a plugin instead of using Crosswalk to create the project.
- Does not work with axemclion / react-native-cordova-plugin since the
window.sqlitePlugin
object exported (ES5 feature). It is recommended to use andpor / react-native-sqlite-storage for SQLite database access with React Native Android/iOS instead.
- Integration with PhoneGap developer app
- Multi-page apps
- Use within InAppBrowser
- Use within an iframe (see litehelpers/Cordova-sqlite-storage#368 (comment))
- SAVEPOINT(s)
- R-Tree is not tested with some older releases of Android
- UNICODE characters not fully tested
- Use with TRIGGER(s), JOIN and ORDER BY RANDOM
- Integration with JXCore for Cordova (must be built without sqlite(3) built-in)
- Delete an open database inside a statement or transaction callback.
- If you run into problems and your code follows the asynchronous HTML5/Web SQL transaction API, you can try opening your database using
window.openDatabase
and see if you get the same problems. - In case your database schema may change, it is recommended to keep a table with one row and one column to keep track of your own shema version number. It is possible to add it later. The recommended schema update procedure is described below.
- It is NOT allowed to execute sql statements on a transaction following the HTML5/Web SQL API, as described below.
- 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.
- intent whitelist: blocked intent such as external URL intent may cause this and perhaps certain Cordova plugin(s) to misbehave (see litehelpers/Cordova-sqlite-storage#396)
- Angular/ngCordova/Ionic controller/factory/service callbacks may be triggered before the 'deviceready' event is fired
- As discussed in #355, it may be necessary to install ionic-plugin-keyboard
- Integrate with IndexedDBShim and some other libraries such as Sequelize, Squel.js, WebSqlSync, Persistence.js, Knex, etc.
- litehelpers / cordova-sqlite-ext - version with REGEXP support Android/iOS and pre-populated database support added for Windows 8.1(+)/Windows Phone 8.1(+)
- litehelpers / Cordova-sqlcipher-adapter - supports SQLCipher for Android, iOS, and Windows 8.1(+)/Windows Phone 8.1(+)
- litehelpers / Cordova-sqlite-legacy - maintenance of WP(7/8) version-working with the other supported platforms Android/iOS/Windows 8.1(+)/Windows Phone 8.1(+)
- litehelpers / Cordova-sqlite-enterprise-free - internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS) - with a different licensing scheme
- litehelpers / cordova-sqlite-workers-evfree - version with support for web workers, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS) - with a different licensing scheme
- Adaptation for React Native Android and iOS: andpor / react-native-sqlite-storage
- Original version for iOS (with a slightly different transaction API): davibe / Phonegap-SQLitePlugin
- object-layer / AnySQL - Unified SQL API over multiple database engines
- Simpler sqlite plugin with a simpler API: samikrc / CordovaSQLite
- 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
- MSOpenTech / cordova-plugin-websql - Windows 8(+) and Windows Phone 8(+) WebSQL plugin versions in C#
- Thinkwise / cordova-plugin-websql - fork of MSOpenTech / cordova-plugin-websql that supports asynchronous execution
- MetaMemoryT / websql-client - provides the same API and connects to websql-server through WebSockets.
- 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)
- Another sqlite binding for React-Native (iOS version): almost/react-native-sqlite
- Use NativeScript with its web view and [NathanaelA / nativescript-sqlite](https://github.com/Natha naelA/nativescript-sqlite) (Android and/or iOS)
- Standard HTML5 local storage
- Realm.io
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:
- Recommended:
var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 1}, successcb, errorcb);
- Classical:
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 iCloud
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"});
// ...
}
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:
- The database file name should include the extension, if desired.
- It is possible to open multiple database access objects for the same database.
- The database access object can be closed as described below.
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:
- (sometimes) there is an unexpected database lock
- the data that was inserted is lost.
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:
- Single-statement transactions
- SQL batch query transactions
- Standard asynchronous transactions
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:
BUG: If a row item object is retrieved twice, they should be safe from each other. But this is not the case. This sample program demonstrates the bug:
var db = window.sqlitePlugin.openDatabase({name: "my.db"});
var res1 = null,
res2 = null;
db.transaction(function(tx) {
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', 101], function(tx, res) {
tx.executeSql('SELECT * FROM test_table;', [], function(tx, res) {
res1 = res.rows.item(0);
res2 = res.rows.item(0);
res1.data = 'another';
// immediate check:
console.log('res1.data = ' + res1.data);
// output: res2.data = 'another'
console.log('res2.data = ' + res2.data);
});
}, function(e) {
console.log('Transaction error: ' + e.message);
}, function() {
// check stored info:
console.log('res1.data: ' + res1.data);
// output: res2.data = 'another';
console.log('res2.data: ' + res2.data);
});
The threading model depends on which version is used:
- For Android, one background thread per db;
- for iOS, background processing using a very limited thread pool (only one thread working at a time).
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:
- It is still possible to open one or more new database access 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.
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:
- 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.
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.
- https://github.com/litehelpers/Cordova-sqlite-storage - latest version
cordova-sqlite-storage
- stable npm package version
SQLitePlugin.coffee.md
: platform-independent (Literate coffee-script, can be read by recent coffee-script compiler)www
:SQLitePlugin.js
platform-independent Javascript as generated fromSQLitePlugin.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 intest-www
subdirectory
Use 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:
- Verify that you have followed the steps in brodybits / Cordova-quick-start-checklist
- Try the new echo test as described above
- Check the troubleshooting steps and pitfalls in brodybits / Cordova-troubleshooting-guide
and check the following:
- You are using the latest version of the Plugin Javascript & platform-specific Java or Objective-C source from this repository.
- You have installed the Javascript & platform-specific Java or Objective-C correctly.
- You have included the correct version of the cordova Javascript and SQLitePlugin.js and got the path right.
- You have registered the plugin properly in
config.xml
.
If you still cannot get something to work:
- create a fresh, clean Cordova project;
- 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 troubleshooting steps and pitfalls in brodybits / Cordova-troubleshooting-guide
If you continue to see the issue in the fresh, clean Cordova project:
- Make the simplest test program you can to demonstrate the issue, including 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.
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.
- Make a fresh, clean ngCordova or Ionic project with a test program that demonstrates the issue and post it. Please do not use any other plugins or frameworks unless absolutely necessary to demonstrate your issue.
- Make another project without any form of Angular including ngCordova or Ionic, with the same test program to show that it will work outside Angular/"ngCordova"/Ionic.
Please include the following:
- Which platform(s) Android/iOS/WP8/Windows 8.1/Windows Phone 8.1
- Clear description of the issue
- A small, complete, self-contained program that demonstrates the problem, preferably as a Github project. ZIP/TGZ/BZ2 archive available from a public link is OK. No RAR or other such formats please!
- A Cordova project is highly preferred. Intel, MS IDE, or similar project formats should be avoided.
- screen casts or videos
- RAR or similar archive formats
- Intel, MS IDE, or similar project formats unless absolutely necessary
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 afterSQLitePlugin.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.
- Testimonials of apps that are using this plugin would be especially helpful.
- Reporting issues can help improve the quality of this plugin.
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.
- Patches with bug fixes are helpful, especially when submitted with test code.
- Other enhancements welcome for consideration, when submitted with test code and are working for all supported platforms. Increase of complexity should be avoided.
- All contributions may be reused by @brodybits (Chris Brody) under another license in the future. Efforts will be taken to give credit for major contributions but it will not be guaranteed.
- Project restructuring, i.e. moving files and/or directories around, should be avoided if possible.
- If you see a need for restructuring, it is better to first discuss it in new issue where alternatives can be discussed before reaching a conclusion. If you want to propose a change to the project structure:
- Remember to make (and use) a special branch within your fork from which you can send the proposed restructuring;
- Always use
git mv
to move files & directories; - Never mix a move/rename operation with any other changes in the same commit.
LinkedIn: https://www.linkedin.com/in/chrisbrody