Legacy version of Cordova/PhoneGap plugin to open and use sqlite databases on Android/iOS/Windows/WP8 with HTML5/Web SQL API
C C# JavaScript C++ Java CoffeeScript Other

README.md

Cordova/PhoneGap sqlite legacy build support

Native interface to sqlite in a Cordova/PhoneGap plugin for Android, iOS, WP8, Windows 8.1, Windows Phone 8.1, and Windows 10 UWP (Universal Windows Platform), with API similar to HTML5/Web SQL API.

License for Android, WP8, and Windows versions: MIT or Apache 2.0

License for iOS version: MIT only

Android CI (full suite) iOS CI (very limited suite)
Circle CI Build Status

BREAKING CHANGE: Database location parameter is now mandatory

The location or iosDatabaseLocation must be specified in the openDatabase and deleteDatabase calls, as documented below.

IMPORTANT: iCloud backup of SQLite database is NOT allowed

As documented in the "A User’s iCloud Storage Is Limited" section of iCloudFundamentals in Mac Developer Library iCloud Design Guide (near the beginning):

  • 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]
- iCloudFundamentals in Mac Developer Library iCloud Design Guide

How to disable iCloud backup

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)

Available for hire

The primary author and maintainer @brodybits (Christopher J. Brody aka Chris Brody) is available for contracting assignments. Areas of interest include: customization, frontend development, backend development, mentoring, and training. Part-time assignments would really help keep this project alive. (@brodybits dedicates a significant amount of working time and has turned down multiple full-time work opportunities to maintain and improve this project.)

@brodybits can be contacted at:

Some other projects by @brodybits:

Status

  • A recent version of the Cordova CLI (such as 6.2.0) is recommended. Cordova versions older than 6.0.0 are missing the cordova-ios@4.0.0 security fixes.
  • Testing with PhoneGap Build is very limited. PhoneGap Build is actively supported for litehelpers / Cordova-sqlite-evcore-extbuild-free (available with GPL or commercial license options). The following resource describes how to use this plugin from git in PhoneGap Build: http://phonegap.com/blog/2016/02/16/git-plugins/
  • The iOS database location is now mandatory, as documented below.
  • SQLite version 3.8.10.2 is supported for all supported platforms Android/iOS/Windows.
  • This version supports the use of two (2) possible Android sqlite database implementations:
  • The following features are available in litehelpers / cordova-sqlite-ext:
    • REGEXP support (Android/iOS)
    • Pre-populated database (Android/iOS/Windows)
  • Windows version using the performant C++ doo / SQLite3-WinRT component and has the following limitations:
    • Issue with UNICODE \u0000 character (same as \0)
    • No background processing
  • Status for the other target platforms:
    • Android: now using Android-sqlite-connector (with sqlite 3.8.10.2 embedded in Android-sqlite-native-driver), with support for FTS3/FTS4 and R-Tree
    • iOS: sqlite 3.8.10.2 embedded
    • WP8: performance/stability issues have been reported with the CSharp-SQLite library. Windows (UWP) platform is recommended for the future. FTS3/FTS4/R-Tree are NOT supported for WP8.
  • FTS3, FTS4, and R-Tree are not supported for WP8
  • Android is supported back to SDK 10 (a.k.a. Gingerbread, Android 2.3.3); support for older versions is available upon request.
  • iOS versions supported: 7.x/8.x/9.x
  • In case of memory issues please use smaller transactions or use the version (with GPL or commercial license options) at: litehelpers / Cordova-sqlite-evcore-extbuild-free

Announcements

Highlights

  • Drop-in replacement for HTML5/Web SQL API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below.
  • Failure-safe nested transactions with batch processing optimizations (according to HTML5/Web SQL API)
  • As described in this posting:
    • Keeps sqlite database in a user data location that is known; can be reconfigured (iOS version); and may be synchronized to iCloud by default (iOS version).
    • No 5MB maximum, more information at: http://www.sqlite.org/limits.html
  • This project is self-contained (with sqlite3 dependencies auto-fetched by npm); no dependencies on other plugins such as cordova-plugin-file
  • Windows 8.1/Windows Phone 8.1/Windows 10 version uses the performant C++ doo / SQLite3-WinRT component.
  • SQLCipher support for Android/iOS/Windows is available at: litehelpers / Cordova-sqlcipher-adapter
  • Intellectual property:
    • All source code is tracked to the original author in git
    • Major authors are tracked in AUTHORS.md
    • Licensing of each component is tracked in LICENSE.md
    • History of this project is also described in HISTORY.md

Some apps using this plugin

Some known deviations from the Web SQL database standard

  • The 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.
  • This plugin does not support the database creation callback or standard database versions. Please read the Database schema versions section below for tips on how to support database schema versioning.
  • This plugin does not support the synchronous Web SQL interfaces.
  • Error reporting is not 100% compliant, with some issues described below.
  • In case of a transaction with an sql statement error for which there is no error handler, the error handler does not return false, or the error handler throws an exception, the plugin will fire more sql statement callbacks before the transaction is aborted with ROLLBACK.
  • Known issues with handling of certain ASCII/UNICODE characters as described below.
  • This plugin supports some non-standard features as described below.

Known issues

  • 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 in case the built-in Android database used (using the androidDatabaseImplementation option in window.sqlitePlugin.openDatabase)
  • Memory issue observed when adding a large number of records due to the JSON implementation which is improved in litehelpers / Cordova-sqlite-evcore-extbuild-free (available with GPL or commercial license options)
  • 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, WP8, and Windows (fixed for Android in litehelpers / Cordova-sqlite-evplus-legacy-free, GPL or special commercial license options).
  • Possible crash on Android when using Unicode emoji characters due to Android bug 81341, which should be fixed in Android 6.x
  • Close/delete 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).
  • Incorrect or missing insertId/rowsAffected in results for INSERT/UPDATE/DELETE SQL statements with extra semicolon(s) in the beginning for Android (in case the androidDatabaseImplementation: 2 option is used) and WP8.
  • Within a readTransaction the plugin executes SQL write statements that start with extra semicolon(s).
  • Unlike the HTML5/Web SQL API this plugin handles executeSql calls with too few parameters without error reporting and the iOS version handles executeSql calls with too many parameters without error reporting.

Other limitations

  • The db version, display name, and size parameter values are not supported and will be ignored. (No longer supported by the API)
  • Absolute and relative subdirectory path(s) are not tested or supported.
  • This plugin will not work before the callback for the 'deviceready' event has been fired, as described in Usage. (This is consistent with the other Cordova plugins.)
  • This version will not work within a web worker (not properly supported by the Cordova framework). Use within a web worker is supported for Android and iOS in: litehelpers / Cordova-sqlite-evplus-legacy-workers-free (available with GPL or premium commercial license options)
  • 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).
  • Certain US-ASCII and Unicode characters are not working in WP8 version, including: vertical tab, form feed, backspace, \u2028 (UNICODE line separator) and \u2029 (UNICODE paragraph separator) (further testing needed)
  • UNICODE \u2028 (line separator) and \u2029 (paragraph separator) characters 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 certain other UNICODE characters in the iOS version (needs further investigation). This is fixed in: litehelpers / Cordova-sqlite-evplus-legacy-free (available with GPL or special commercial license options)
  • BLOB type is not supported in this version branch (reading of BLOBs is supported by litehelpers / cordova-sqlite-ext for Android/iOS)
  • UNICODE \u0000 (same as \0) character not working in Android (default Android-sqlite-connector database implentation), WP8, or Windows
  • 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 by this version. Attach/detach is supported (along with the memory and iOS UNICODE \u2028 line separator / \u2029 paragraph separator fixes) in: litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free (available with GPL or special commercial license options)
  • UPDATE/DELETE with LIMIT or ORDER BY is not supported.
  • WITH clause is not supported by older Android versions in case the androidDatabaseImplementation: 2 (built-in android.database implementation) option is used.
  • User-defined savepoints are not supported and not expected to be compatible with the transaction locking mechanism used by this plugin. In addition, the use of BEGIN/COMMIT/ROLLBACK statements is not supported.
  • 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 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.

Further testing needed

  • Integration with PhoneGap developer app
  • Multi-page apps
  • Use within InAppBrowser
  • Use within an iframe (see litehelpers/Cordova-sqlite-storage#368 (comment))
  • Actual behavior when using SAVEPOINT(s)
  • FTS3/FTS4 and R-Tree are not fully tested or supported for WP8
  • R-Tree is not fully tested with Android
  • UNICODE characters not fully tested
  • Use with TRIGGER(s), JOIN and ORDER BY RANDOM
  • UPDATE/DELETE with LIMIT or ORDER BY (newer Android/iOS versions)
  • Integration with JXCore for Cordova (must be built without sqlite(3) built-in)
  • Delete an open database inside a statement or transaction callback.
  • WITH clause (not supported by some older sqlite3 versions)

Some tips and tricks

  • If you run into problems and your code follows the asynchronous HTML5/Web SQL transaction API, you can try opening a test 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 schema version number. It is possible to add it later. The recommended schema update procedure is described below.

Common pitfall(s)

  • It is possible to make a Windows Phone 8.1 project using either the 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.
  • It is NOT allowed to execute sql statements on a transaction that has already finished, as described below. This is consistent with the HTML5/Web SQL API.
  • The plugin class name starts with "SQL" in capital letters, but in Javascript the sqlitePlugin object name starts with "sql" in small letters.
  • Attempting to open a database before receiving the 'deviceready' event callback.
  • Inserting STRING into ID field
  • Auto-vacuum is NOT enabled by default. It is recommended to periodically VACUUM the database.

Weird pitfall(s)

Angular/ngCordova/Ionic-related pitfalls

  • Angular/ngCordova/Ionic controller/factory/service callbacks may be triggered before the 'deviceready' event is fired
  • As discussed in litehelpers/Cordova-sqlite-storage#355, it may be necessary to install ionic-plugin-keyboard

Major TODOs

  • Integrate with IndexedDBShim and some other libraries such as Sequelize, Squel.js, WebSqlSync, Persistence.js, Knex, etc.
  • Version with proper BLOB support

For future considertion

  • Auto-vacuum option
  • Browser platform

Alternatives

Other versions

Other SQLite adapter projects

Alternative solutions

Usage

Self-test functions

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, populate, read, update, and delete a test database (named ___$$$___litehelpers___$$$___test___$$$___.db) properly:

window.sqlitePlugin.selfTest(successCallback, errorCallback);

IMPORTANT: Please wait for the 'deviceready' event (see below for an example).

General

  • Drop-in replacement for HTML5/Web SQL API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below. Some other known deviations are documented below. Please report if you find any other possible deviations.

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.

For some basic examples, see the Sample section.

Opening a database

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 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 iCloud
  • Library: Library subdirectory - backed up by iCloud, NOT visible to iTunes
  • Documents: Documents subdirectory - visible to iTunes and backed up by iCloud

WARNING: Again, the new "default" iosDatabaseLocation value is NOT the same as the old default location and would break an upgrade for an app using the old default value (0) on iOS.

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 only):

  • 0 (default): Documents - visible to iTunes and backed up by iCloud
  • 1: Library - backed up by iCloud, NOT visible to iTunes
  • 2: 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:

  • The database file name should include the extension, if desired.
  • It is possible to open multiple database access handle objects for the same database.
  • The database handle access object can be closed as described below.

Web SQL replacement tip:

To overwrite window.openDatabase:

window.openDatabase = function(dbname, ignored1, ignored2, ignored3) {
  return window.sqlitePlugin.openDatabase({name: dbname, location: 'default'});
};

Android sqlite implementation

By default, this plugin uses Android-sqlite-connector, which is lightweight and should be more efficient than the built-in Android database classes. To use the built-in Android database classes instead:

var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default', androidDatabaseImplementation: 2});

Workaround for Android db locking issue

litehelpers/Cordova-sqlite-storage#193 was reported (as observed by several app developers) that certain 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

This is not an issue when default Android-sqlite-connector database implementation.

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', 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.

SQL transactions

The following types of SQL transactions are supported by this version:

  • Single-statement transactions
  • SQL batch query transactions
  • Standard asynchronous transactions

Single-statement transactions

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);
});

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);
});

SQL batch query transactions

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);
});

In case of an error, all changes in a sql batch are automatically discarded using ROLLBACK.

Standard asynchronous transactions

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 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');
});

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: "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 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.

Background processing

The threading model depends on which version is used:

  • For Android and WP8, one background thread per db;
  • for iOS, background processing using a very limited thread pool (only one thread working at a time);
  • for Windows, no background processing.

Sample with PRAGMA feature

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.

Sample with transaction-level nesting

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.

Close a database object

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. All pending transactions should be errored when a database connection is closed.

NOTE: As described above, if multiple database access handle objects are opened for the same database and one database handle access object is closed, the database is no longer available for the other database handle objects. Possible workarounds:

  • It is still possible to open one or more new database handle objects on a database that has been closed.
  • It should be OK not to explicitly close a database handle since database transactions are ACID compliant and the app's memory resources are cleaned up by the system upon termination.

FUTURE TBD: dispose method on the database access handle object, such that a database is closed once all access handle objects are disposed.

Delete a database

window.sqlitePlugin.deleteDatabase({name: 'my.db', location: 'default'}, successcb, errorcb);

with location or iosDatabaseLocation parameter required as described above for openDatabase (affects iOS only)

BUG: When a database is deleted, any queued transactions for that database are left hanging. All pending transactions should be errored when a database is deleted.

Database schema versions

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:

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.

Use with Ionic/ngCordova/Angular

It is recommended to follow the tutorial at: https://blog.nraboy.com/2014/11/use-sqlite-instead-local-storage-ionic-framework/

A sample is provided at: litehelpers / Ionic-sqlite-database-example

Documentation at: http://ngcordova.com/docs/plugins/sqlite/

Installing

Easy install with Cordova CLI tool

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 https://github.com/litehelpers/Cordova-sqlite-legacy-build-support

CLI NOTES:

  • You may have to update the platform and plugin version(s) before you can build: cordova prepare (or for a specific platform such as iOS: cordova prepare ios)
  • 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

CLI NOTES:

  • You may have to update the platform and plugin version(s) before you can build: cordova prepare (or for a specific platform such as iOS: cordova prepare ios)
  • 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

You can find some more details in a nice writeup (though with old links and package names): http://iphonedevlog.wordpress.com/2014/04/07/installing-chris-brodys-sqlite-database-with-cordova-cli-android/.

Installation source

Source tree

  • SQLitePlugin.coffee.md: platform-independent (Literate coffee-script, can be read by recent coffee-script compiler)
  • www: platform-independent Javascript as generated from SQLitePlugin.coffee.md (and committed!)
  • src: platform-specific source code
  • scripts: installation hook script to fetch the external dependencies via npm
  • spec: test suite using Jasmine (2.4.1)
  • 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 subdirectory

Installation test

Easy installation test

Use window.sqlitePlugin.echoTest and/or window.sqlitePlugin.selfTest as described above (please wait for the deviceready event).

Quick installation test

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;
   });
  });

Support

Policy

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: sales@litehelpers.net

Before asking for help

First steps:

and check the following:

  • You are using the latest version of the Plugin (Javascript and platform-specific part) from this repository.
  • The plugin is installed correctly.
  • You have included the correct version of cordova.js.
  • You have registered the plugin properly in config.xml.

If you still cannot get something to work:

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.

What will be supported for free

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.

Support for issues with Angular/"ngCordova"/Ionic

Commercial support is available for use with Ionic and other forms of ngCordova/Angular. For more information please contact: sales@litehelpers.net

What information is needed for help

Please include the following:

  • Which platform(s) Android/iOS/WP8/Windows 8.1/Windows Phone 8.1/Windows 10
  • 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.

Please do NOT use any of these formats

  • screen casts or videos
  • RAR or similar archive formats
  • Intel, MS IDE, or similar project formats unless absolutely necessary

Where to ask for help

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

Professional support is available, please contact: sales@litehelpers.net

Unit tests

Unit testing is done in spec.

running tests from shell

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

Adapters

Lawnchair Adapter

Common adapter

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.

Included files

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)

Sample

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: Not all db options are supported by the Lawnchair adapter. The workaround is to first open the database file using sqlitePlugin.openDatabase().

Adapters to be supported in the near future

  • IndexedDBShim

Adapters not supported

PouchDB

The adapter is part of PouchDB as documented at:

The PouchDB authors maintain their own sqlite plugin. TBD a comparison will be given soon.

Sample: Interact with the SQLite database

The SQLite storage plugin sample allows you to execute SQL statements to interact with the database. The code snippets in this section demonstrate simple plugin tasks including:

Open the database and create a table

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

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);

Read data from the database

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');
    });
}

Remove a row from the database

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');
    });
}

Update rows in the database

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);

Close the database

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);
    });
}

Contributing

Community

  • Testimonials of apps that are using this plugin would be especially helpful.
  • Reporting issues can help improve the quality of this plugin.

Code

WARNING: Please do NOT propose changes from your default branch. Contributions may be 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 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.

Contact

sales@litehelpers.net