Native interface to sqlite in a Cordova/PhoneGap plugin for Android, iOS, macOS, and Windows 8.1(+)/Windows Phone 8.1(+) with API similar to HTML5/Web SQL API.
This version is available under GPL v3 (http://www.gnu.org/licenses/gpl.txt) or premium commercial license.
TBD: no Circle CI or Travis CI working in this version branch.
NOTE: Commercial licenses for Cordova-sqlite-enterprise-free purchased before July 2016 are valid for this version. Commercial licenses for Cordova-sqlite-evcore versions are not valid for this version.
This version is in legacy maintenance status. Only security and extremely critical bug fixes will be considered.
The location
or iosDatabaseLocation
must be specified in the openDatabase
and deleteDatabase
calls, as documented below.
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)
\u0000
character (same as \0
)plugman
as described below.plugman
3.8.10.2
), with support for FTS3/FTS4 and R-Tree, and REGEXP support using PCRE 8.37 as built from liteglue / Android-sqlite-native-driver-regexp-pcre3.8.10.2
embeddedopenDatabase
and deleteDatabase
iosDatabaseLocation
optioncode
member and sqliteCode
as reported by the SQLite C library (Android/iOS)MAX_SQL_CHUNK
value in SQLitePlugin.jsopenDatabase
and deleteDatabase
location
option to select database location (iOS/macOS only) and disable iCloud backupwindow.openDatabase()
factory call with window.sqlitePlugin.openDatabase()
, with parameters as documented below. (NOTE: Some known deviations are described below).TBD your app here
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.false
, or the error handler throws an exception, the plugin will fire more sql statement callbacks before the transaction is aborted with ROLLBACK.false
to signal transaction recovery, the plugin fires the remaining sql callbacks before aborting the transaction.code
member is bogus on Windows (fixed for Android in this version).db=window.sqlitePlugin.openDatabase({name: ":memory:"})
is currently not supported.db=window.sqlitePlugin.openDatabase({name: ":memory:"})
is currently not supported.\u0000
(same as \0
) character not working in Android or Windows/Windows Phone (8.1/XX)window.sqlitePlugin
object is not proprly exported (ES5 feature). It is recommended to use andpor / react-native-sqlite-storage for SQLite database access with React Native Android/iOS instead.androidDatabaseImplementation
option in window.sqlitePlugin.openDatabase
)window.openDatabase
and see if you get the same problems.windows
platform or the wp8
platform. The windows
platform is highly recommended over wp8
whenever possible. Also, some plugins only support windows
and some plugins support only wp8
.sqlitePlugin
object name starts with "sql" in small letters.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()
) with parameters as documented below 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.
To open a database access handle object (in the new default location):
var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'}, successcb, errorcb);
WARNING: The new "default" location value is NOT the same as the old default location and would break an upgrade for an app that was using the old default value (0) on iOS.
To specify a different location (affects iOS/macOS only):
var db = window.sqlitePlugin.openDatabase({name: 'my.db', iosDatabaseLocation: 'Library'}, successcb, errorcb);
where the iosDatabaseLocation
option may be set to one of the following choices:
default
: Library/LocalDatabase
subdirectory - NOT visible to iTunes and NOT backed up by 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.
ALTERNATIVE (deprecated):
var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 1}, successcb, errorcb);
with the location
option set to one the following choices (affects iOS/macOS 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.
OTHER NOTES:
TIP:
To overwrite window.openDatabase
:
window.openDatabase = function(dbname, ignored1, ignored2, ignored3) {
return window.sqlitePlugin.openDatabase({name: dbname, location: 'default'});
};
Put the database file in the www
directory and open the database like (both database location and createFromLocation
items are required):
var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 'default', createFromLocation: 1});
IMPORTANT NOTES:
www
subdirectory. (This should work well the Cordova CLI.)openDatabase
. This plugin does not use an automatic extension.TIP: If you don't see the data from the pre-populated database file, completely remove your app and try it again!
Alternative: You can also use an-rahulpandey / cordova-plugin-dbcopy to install a pre-populated database
Samples and tutorials:
The following types of SQL transactions are supported by this version:
Sample (with both success and error callbacks):
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);
});
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 (with success and error callbacks):
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(tx, 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(tx, error) {
console.log('SELECT error: ' + error.message);
});
}, function(error) {
console.log('transaction error: ' + error.message);
}, function() {
console.log('transaction ok');
});
NOTICE: The tx.executeSql
success and error callbacks should take two parameters (first parameter for the transaction object). This is different from the single-statement success and error callbacks described above.
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:
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:
Sample (with success and error callbacks):
var tx = db.beginTransaction();
tx.executeSql("DROP TABLE IF EXISTS mytable");
tx.executeSql("CREATE TABLE mytable (myfield)");
tx.executeSql("INSERT INTO mytable values(?)", ['test value']);
tx.executeSql("SELECT * from mytable", [], function(tx, res) {
console.log("Got value: " + res.rows.item(0).myfield);
}, function(tx, e) {
console.log("Ignore unexpected error callback with message: " + e.message);
return false;
});
tx.end(function() {
console.log('Optional success callback fired');
}, function(e) {
console.log("Optional error callback fired with message: " + e.message);
});
Sample with abort:
var tx = db.beginTransaction();
tx.executeSql("INSERT INTO mytable values(?)", ['wrong data']);
tx.abort(function() {
console.log('Optional callback');
});
IMPORTANT NOTES:
tx.executeSql
call results in an error and it does not have an error callback or the error callback does NOT return false
, the transaction will be aborted immediately with a ROLLBACK tx.end
calltx.executeSql
call results in an error for which there is no error callback, the error callback does NOT return false
, or the error callback throws an exception, the transaction is silently aborted and no tx.end
callbacks will be fired.db.beginTransaction
call, all other transactions are blocked until the multi-part transaction is either completed successfully or aborted (with a ROLLBACK).The threading model depends on which version is used:
First we create a table and add a single entry, then query 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/macOS 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/
IMPORTANT: There are issues supporing certain Windows target platforms due to CB-8866:
plugman
Old workaround: As an alternative, which will support the ("Mixed Platforms") target, you can use plugman
instead with litehelpers / cordova-windows-nufix, as described here.
plugman
installed: npm install -g plugman
path.to.cordova-windows-nufix/bin/create.bat your_app_path your.app.id YourAppName
cd your_app_path
and install plugin using plugman
:
plugman install --platform windows --project . --plugin https://github.com/litehelpers/Cordova-sqlite-evplus-legacy-free
www
(don't forget to reference it from www\index.html
and wait for deviceready
event)Then your project in CordovaApp.sln
should work with "Mixed Platforms" on both Windows 8.1 and Windows Phone 8.1.
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-evplus-legacy-free
You can find more details at this writeup.
WARNING: for Windows target platform please read the section below.
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-evplus-legacy-free
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.
SQLitePlugin.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:
external
- placeholder for external dependencies - not needed in this version branchcommon
- common dependencies: sqlite3.[hc]
(needed to build iOS/macOS and Windows platform versions)android
- Java plugin code for Androidios
- Objective-C plugin code for iOS/macOS;windows
- Javascript proxy code and SQLite3-WinRT project for Windows "Universal" (8.1);spec
: test suite using Jasmine (2.2.0), ported from QUnit test-www
test suite, working on all platformstests
: very simple Jasmine test suite that is run on Circle CI (Android version) and Travis CI (iOS version)Lawnchair-adapter
: Lawnchair adaptor, based on the version from the Lawnchair repository, with the basic Lawnchair test suite in test-www
subdirectoryThese installation instructions are based on the Android example project from Cordova/PhoneGap 2.7.0, using the lib/android/example
subdirectory from the PhoneGap 2.7 zipball.
SQLitePlugin.js
from www
into assets/www
SQLitePlugin.java
from src/android/io/liteglue
into src/io/liteglue
subdirectorylibs
subtree from common
with sqlite-connector.jar
and sqlite-native-driver.jar
into your Android project<plugin name="SQLitePlugin" value="io.liteglue.SQLitePlugin"/>
to res/xml/config.xml
Sample change to res/xml/config.xml
for Cordova/PhoneGap 2.x:
--- config.xml.orig 2015-04-14 14:03:05.000000000 +0200
+++ res/xml/config.xml 2015-04-14 14:08:08.000000000 +0200
@@ -36,6 +36,7 @@
<preference name="useBrowserHistory" value="true" />
<preference name="exit-on-suspend" value="false" />
<plugins>
+ <plugin name="SQLitePlugin" value="io.liteglue.SQLitePlugin"/>
<plugin name="App" value="org.apache.cordova.App"/>
<plugin name="Geolocation" value="org.apache.cordova.GeoBroker"/>
<plugin name="Device" value="org.apache.cordova.Device"/>
Before building for the first time, you have to update the project with the desired version of the Android SDK with a command like:
android update project --path $(pwd) --target android-19
(assuming Android SDK 19, use the correct desired Android SDK number here)
NOTE: using this plugin on Cordova pre-3.0 requires the following changes to SQLitePlugin.java
:
diff -u Cordova-sqlite-storage/src/android/io/liteglue/SQLitePlugin.java src/io/liteglue/SQLitePlugin.java
--- Cordova-sqlite-storage/src/android/io/liteglue/SQLitePlugin.java 2015-04-14 14:05:01.000000000 +0200
+++ src/io/liteglue/SQLitePlugin.java 2015-04-14 14:10:44.000000000 +0200
@@ -22,8 +22,8 @@
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import org.apache.cordova.CallbackContext;
-import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.api.CallbackContext;
+import org.apache.cordova.api.CordovaPlugin;
import org.json.JSONArray;
import org.json.JSONException;
In the Project "Build Phases" tab, select the first "Link Binary with Libraries" dropdown menu and add the library libsqlite3.dylib
or libsqlite3.0.dylib
.
NOTE: In the "Build Phases" there can be multiple "Link Binary with Libraries" dropdown menus. Please select the first one otherwise it will not work.
SQLitePlugin.[hm]
from src/ios
into your project Plugins folder and add them in XCode (I always just have "Create references" as the option selected).SQLitePlugin.js
from www
into your project www
folderconfig.xml
Sample change to config.xml
for Cordova/PhoneGap 2.x:
--- config.xml.old 2013-05-17 13:18:39.000000000 +0200
+++ config.xml 2013-05-17 13:18:49.000000000 +0200
@@ -39,6 +39,7 @@
<content src="https://github.com/litehelpers/cordova-sqlite-evplus-ext-legacy-build-free/raw/master/index.html" />
<plugins>
+ <plugin name="SQLitePlugin" value="SQLitePlugin" />
<plugin name="Device" value="CDVDevice" />
<plugin name="Logger" value="CDVLogger" />
<plugin name="Compass" value="CDVLocation" />
Described above.
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;
});
});
Make a change like this to index.html (or use the sample code) verify proper installation:
--- index.html.old 2012-08-04 14:40:07.000000000 +0200
+++ assets/www/index.html 2012-08-04 14:36:05.000000000 +0200
@@ -24,7 +24,35 @@
<title>PhoneGap</title>
<link rel="stylesheet" href="https://github.com/litehelpers/cordova-sqlite-evplus-ext-legacy-build-free/blob/master/master.css" type="text/css" media="screen" title="no title">
<script type="text/javascript" charset="utf-8" src="https://github.com/litehelpers/cordova-sqlite-evplus-ext-legacy-build-free/raw/master/cordova-2.0.0.js"></script>
- <script type="text/javascript" charset="utf-8" src="https://github.com/litehelpers/cordova-sqlite-evplus-ext-legacy-build-free/raw/master/main.js"></script>
+ <script type="text/javascript" charset="utf-8" src="https://github.com/litehelpers/cordova-sqlite-evplus-ext-legacy-build-free/raw/master/SQLitePlugin.js"></script>
+
+
+ <script type="text/javascript" charset="utf-8">
+ document.addEventListener("deviceready", onDeviceReady, false);
+ 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"); // check #18/#38 is fixed
+ alert("insertId: " + res.insertId + " -- should be valid");
+
+ db.transaction(function(tx) {
+ tx.executeSql("SELECT data_num from test_table;", [], function(tx, res) {
+ console.log("res.rows.length: " + res.rows.length + " -- should be 1");
+ alert("res.rows.item(0).data_num: " + res.rows.item(0).data_num + " -- should be 100");
+ });
+ });
+
+ }, function(e) {
+ console.log("ERROR: " + e.message);
+ });
+ });
+ }
+ </script>
</head>
<body onload="init();" id="stage" class="theme">
If you have an issue with the plugin please check the following first:
config.xml
.If you still cannot get something to work, please create a fresh, clean Cordova project, add this plugin according to the instructions above, and try a simple test program.
If you continue to see the issue in a new, clean Cordova project:
Then you can raise the new issue.
You may 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
BROKEN: The Lawnchair adapter does not support the openDatabase
options such as location
or iosDatabaseLocation
options and is therefore not expected to work with this plugin.
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.
NOTE: The PouchDB adapter has not been tested with the Android version which is using the new Android-sqlite-connector.
NOTE: As stated above, patches will NOT be accepted on this project due to potential licensing issues. Issues with reproduction scenarios will help maintain and improve the quality of this plugin for future users. (It is also helpful if you have a pointer to the code that is causing the issue.)
info@litehelpers.net